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]

我当前的实现（不使用 Stream 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]

我尝试了各种使用 reduce、groupingBy 等的示例，但均未成功。如果有这样的可能性，我似乎找不到将流与累加器中的最后一个元素进行比较的方法。

Answer 1

另一种简洁的语法是

AtomicReference<Character> previous = new AtomicReference<>(null);
Stream.of('a', 'b', 'b', 'a').filter(cur -> !cur.equals(previous.getAndSet(cur)));

Answer 2

您可以使用自定义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 3

您可以使用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 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 提出的冗长解决方案？我错过了什么吗？

Answer 5

在 Java 7 中，您可以使用迭代器来做到这一点。

Iterator<Integer> iterator = list.values().iterator();
Integer previousValue = null;

while(iterator.hasNext()) {
    Integer currentValue = iterator.next();
    if(currentValue.equals(previousValue)){
        iterator.remove();
    }
    previousValue = currentValue;
}

Answer 6

请试试这个解决方案：

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)));
}

}