Java 8 - 从列表中删除重复的元素序列

Question

我有一个要求，我希望使用Java Stream Api来处理来自系统的事件流，并应用数据清理过程来删除重复的事件。 这是按顺序重复多次删除相同的事件，而不是创建不同事件的列表。大多数可在线提供的Java Stream api示例旨在创建来自给定输入的独特输出。

实施例，对输入流

[A，B，C，A，A，A，A，d，d，d，C，C，E，E，E，E，E， E，F，F，F]

输出列表或流应是

[A，b，C，A，d，C，E，F]

我的cu rrent执行（不使用流API）看起来像

public class Test { 
    public static void main(String[] args) { 
     String fileName = "src/main/resources/test.log"; 
     try { 
      List<String> list = Files.readAllLines(Paths.get(fileName)); 
      LinkedList<String> acc = new LinkedList<>(); 

      for (String line: list) { 
       if (acc.isEmpty()) 
        acc.add(line); 
       else if (! line.equals(acc.getLast())) 
        acc.add(line); 
      } 

      System.out.println(list); 
      System.out.println(acc); 

     } catch (IOException ioe) { 
      ioe.printStackTrace(); 
     } 
    } 
} 

输出，

[a, b, c, a, a, a, a, d, d, d, c, c, e, e, e, e, e, e, f, f, f] 
[a, b, c, a, d, c, e, f] 

我试着减少，groupingBy等各种例子，但没有成功。如果存在这样的可能性，我似乎无法找到一种方法来比较流与我的累加器中的最后一个元素。

Answer 1

您可以使用IntStream获得索引位置的保持在List，并使用你的优势如下：

List<String> acc = IntStream 
      .range(0, list.size()) 
      .filter(i -> ((i < list.size() - 1 && !list.get(i).equals(list 
        .get(i + 1))) || i == list.size() - 1)) 
      .mapToObj(i -> list.get(i)).collect(Collectors.toList()); 
System.out.println(acc); 

说明

1. IntStream.range(0,list.size())：返回的原始序列将用作访问列表的索引位置的int值元素。
2. filter(i -> ((i < list.size() - 1 && !list.get(i).equals(list.get(i + 1) || i == list.size() - 1))：仅继续如果在当前索引位置的元素不是在下一索引位置等于所述元件，或者如果最后一个索引位置达到
3. mapToObj(i -> list.get(i)：流转换为Stream<String>。
4. collect(Collectors.toList())：将结果收集到列表中。

Answer 2

请再试此解决方案：

public class TestDuplicatePreviousEvent { 

public static void main(String[] args) { 
    List<Integer> inputData = new ArrayList<>(); 
    List<Integer> outputData = new ArrayList<>(); 

    inputData.add(1); 
    inputData.add(2); 
    inputData.add(2); 
    inputData.add(3); 
    inputData.add(3); 
    inputData.add(3); 
    inputData.add(4); 
    inputData.add(4); 
    inputData.add(4); 
    inputData.add(4); 
    inputData.add(1); 

    AtomicInteger index = new AtomicInteger(); 
    Map<Integer, Integer> valueByIndex = inputData.stream().collect(Collectors.toMap(i -> index.incrementAndGet(), i -> i)); 

    outputData = valueByIndex.entrySet().stream().filter(i -> !i.getValue().equals(valueByIndex.get(i.getKey() - 1))).map(x -> x.getValue()).collect(Collectors.toList()); 
    System.out.println(outputData); 
} 

}

输出： [1，2，3，4，1]

解决方案没有地图：

public class TestDuplicatePreviousEvent { 

public static void main(String[] args) { 
    List<Integer> inputData = new ArrayList<>(); 
    List<Integer> outputData = new ArrayList<>(); 

    inputData.add(1); 
    inputData.add(2); 
    inputData.add(2); 
    inputData.add(3); 
    inputData.add(3); 
    inputData.add(3); 
    inputData.add(4); 
    inputData.add(4); 
    inputData.add(4); 
    inputData.add(4); 
    inputData.add(1); 
    inputData.add(1); 
    inputData.add(1); 
    inputData.add(4); 
    inputData.add(4); 

    AtomicInteger index = new AtomicInteger(); 
    outputData = inputData.stream().filter(i -> filterInputEvents(i, index, inputData)).collect(Collectors.toList()); 
    System.out.println(outputData); 
} 

private static boolean filterInputEvents(Integer i, AtomicInteger index, List<Integer> inputData) { 

    if (index.get() == 0) { 
     index.incrementAndGet(); 
     return true; 
    } 
    return !(i.equals(inputData.get(index.getAndIncrement() - 1))); 
} 

}

Answer 3

您可以使用自定义Collector来实现您的目标。请看以下细节：

Stream<String> lines = Files.lines(Paths.get("distinct.txt")); 
LinkedList<String> values = lines.collect(Collector.of(
      LinkedList::new, 
      (list, string) -> { 
       if (list.isEmpty()) 
        list.add(string); 
       else if (!string.equals(list.getLast())) 
        list.add(string); 
      }, 
      (left, right) -> { 
       left.addAll(right); 
       return left; 
      } 
    )); 

values.forEach(System.out::println); 

但是它可能有一些问题，当使用parallel流。

Answer 4

编辑：由@Bolzano评论，这种方法不符合要求。

如果t是输入流然后

Map<String,Boolean> s = new HashMap<>(); 
Stream<String> u = t.filter(e -> s.put(e, Boolean.TRUE)==null); 

将产生独特的元素的流，而不创建列表。

然后一个普通的

List<String> m = u.collect(Collectors.toList()); 

可以创造独特的元素的列表。

我不明白为什么像@CKing和@Anton提出的这样冗长的解决方案会被要求？我错过了什么吗？