有没有一种新方法可以将 java 8 中相同列表的元素与 lambda 进行比较？

Question

有没有办法在 java 8 中比较列表中的元素？

我有兴趣重新编写两个 for 循环。

private static void test(List<Foo> a) {
    for(int i = 0 ; i < a.size(); i++){
        for(int j = 1; j < a.size() ; j++){
            Foo o1= a.get(i);
            Foo o2= a.get(j);
            if (o1.getFooA().equals(o2.getFooA()) && !o1.getFooB().equals(o2.getFooB()) ) {
                    throw new Exception("some message goes here...");
                }
            }

        }
    }

有没有一种很酷的方法可以使用 lambdas/streams 或 java 8 遇到的任何其他功能？

Answer 1

不要要求“lambdas/streams”，而是要实际改进。

当你使用

private static void test(List<Foo> a) throws Exception {
    Map<TypeOfFooA, TypeOfFooB> seen = new HashMap<>();
    for(Foo f: a) {
        TypeOfFooB fooB = f.getFooB(), previous = seen.putIfAbsent(f.getFooA(), fooB);
        if(previous != null && !fooB.equals(previous))
            throw new Exception("some message goes here...");
    }
}

您正在一次执行操作，而不是嵌套循环。这使得线性时间复杂度和二次时间复杂度之间存在差异。这比“看起来很酷”更有影响力。

您可以重写它以使用 Stream API，例如

private static void test(List<Foo> a) throws Exception {
    Map<TypeOfFooA, TypeOfFooB> seen = a.stream()
        .collect(Collectors.toMap(Foo::getFooA, Foo::getFooB,
            (previous, fooB) -> {
                if(!fooB.equals(previous))
                    throw new RuntimeException("some message goes here...");
                return previous;
            }));
}

但不推荐。收集到之后并不真正需要的映射，结合使用合并/归约函数进行验证并抛出异常，可能会让读者感到惊讶，它只适用于未经检查的异常。此外，抛出函数既不能访问Foo 实例也不能访问FooA 键，用于构造异常消息。

我建议保持循环。

Answer 2

这是一个优化的，但不是那么明显的解决方案：

a.stream()
 .collect(toMap(Foo::getFooA, Foo::getFooB, (x, y) -> {
     if (x.equals(y)) {
         return x;
     } else {
         throw new RuntimeException("some message goes here...");
     }
 }));

它利用了HashMap 的O(1) 访问时间，从而放弃了具有复杂性O(n) 的嵌套循环。

---

通常在编程时您应该注意两个方面：可读性和性能。

您的普通 Java 代码可读性很强，但没有经过优化。在最坏的情况下，它具有复杂性 O(n*n)，而使用 Map 您可以将其简化为线性 O(n)。

这种差异对于处理大型列表非常有意义。

Answer 3

如果您绝对必须使用 lambdas 作为“酷”因素。这是一种选择：

private static void test(List<Foo> a) {
    a.forEach(o1 -> {
        if (a.stream().anyMatch(o2 -> o1.getFooA().equals(o2.getFooA()) && !o1.getFooB().equals(o2.getFooB()))) {
            throw new Exception("some message goes here...");
        }
    });
}

它不是两个嵌套的 for 循环，而是一个带有嵌套“anyMatch”的“forEach”lambda，它做同样的事情。我选择这种方法是因为这样可以更清楚地看到这里发生的事情。