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提出的這樣冗長的解決方案會被要求？我錯過了什麼嗎？