由多个属性区分的 Java 流

Question

我在流中有以下对象：

class Foo{
    String a;
    String b;
    int c;
}

我想根据以下条件过滤流：

例如。在流中有条目：foo1 和 foo2：

foo1 和 foo2 具有相同的 a 和 b 值，但它们的 c 属性不同。

在这种情况下，我想删除 c 更高的条目。

Answer 1

必须有更好的方法来做到这一点，但这里有一个解决方案。

List<Foo> list = new ArrayList<>();

list.stream().filter(foo ->
    list.stream()
    .filter(oth -> foo.a.equals(oth.a) && foo.b.equals(oth.b))
    .sorted(Comparator.comparingInt(x -> x.c))
    .findFirst()
    .equals(Optional.of(foo))
)
.collect(Collectors.toList());

1. 对于列表中的所有元素
2. 遍历所有元素，
3. 并找到匹配 A 和 B 的那些
4. 按C排序，得到最低的
5. 保留步骤 1 中的元素，如果它是具有最低 C 的 Foo
6. 将结果收集到新列表中

Answer 2

您可以使用groupBy 对您的Foo 对象进行分组并将它们视为一个列表：

    List<Foo> filtered = list.stream()
            .collect(Collectors.groupingBy(
                foo -> foo.a.hashCode() + foo.b.hashCode()))   // group them by attributes
            .values().stream()                                 // get a stream of List<Foo>
            .map(fooList -> {
                fooList.sort((o1, o2) -> o2.c - o1.c);         // order the list
                return fooList;
            })
               .map(fooList -> {                               // if there is more than 1 item remove it
                   if (fooList.size() > 1)
                       return fooList.subList(0, fooList.size() - 1);
                   else
                       return fooList;
               })
            .flatMap(Collection::stream)                        // Stream<List<Foo>> -> Stream<Foo>
            .collect(Collectors.toList());                      // collect

Answer 3

所以如果我从你的 cmets 中理解正确的话，它应该是这样的：

 List<Foo> foos = Stream.of(new Foo("a", "b", 1), new Foo("a", "b", 2), new Foo("a", "b", 3),
            new Foo("a", "bb", 3), new Foo("aa", "b", 3))
            .collect(Collectors.collectingAndThen(
                    Collectors.groupingBy(
                            x -> new AbstractMap.SimpleEntry<>(x.getA(), x.getB()),
                            Collectors.minBy(Comparator.comparing(Foo::getC))),
                    map -> map.values().stream().map(Optional::get).collect(Collectors.toList())));

    System.out.println(foos);

Answer 4

简单的解决方案是

.stream()
.sorted((f1,f2) -> Integer.compare(f1.c, f2.c))
.distinct()

但它需要在 Foo 中进行丑陋的覆盖，这可能会破坏代码的另一部分

public boolean equals(Object other) {
    return a.equals(((Foo)other).a) && b.equals(((Foo)other).b);
}

public int hashCode() {
    return a.hashCode() + b.hashCode();
}

Answer 5

语义上等同于Eugene’s answer，但更简单一些：

List<Foo> foos = Stream.of(new Foo("a", "b", 1), new Foo("a", "b", 2),
                 new Foo("a", "b", 3), new Foo("a", "bb", 3), new Foo("aa", "b", 3))
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(x -> Arrays.asList(x.getA(), x.getB()), x -> x,
                         BinaryOperator.minBy(Comparator.comparing(Foo::getC))),
            map -> new ArrayList<>(map.values())));

您需要按包含两个属性的键进行分组，并且由于缺少标准的 Pair 类型，您可以使用带有两个元素的 List 或 Map.Entry，两者都可以。但是使用 List 更简单（在 Java 9 中，您将使用更简单的 List.of(…, …)）并且如果两个属性中可能出现相同的值，则具有更好的哈希码。

当下游操作是纯归约时，例如选择C 属性的最小值，toMap 收集器更适合，因为它不需要处理Optional。

Answer 6

有一种方法可以在没有流的情况下做到这一点。我知道这个问题特别要求基于流的解决方案，但我认为这是实现相同目标的好方法。我写这个答案主要是作为对其他答案的补充，也许它对未来的读者有用。

代码如下：

List<Foo> list = Arrays.asList(
    new Foo("a", "b", 1),
    new Foo("a", "b", 2),
    new Foo("a", "b", 3),
    new Foo("a1", "b", 1));

Map<List<String>, Foo> map = new HashMap<>();
list.forEach(foo -> map.merge(Arrays.asList(foo.getA(), foo.getB()), foo,
    (oldFoo, newFoo) -> newFoo.getC() < oldFoo.getC() ? newFoo : oldFoo));
Collection<Foo> distinct = map.values();

System.out.println(distinct);

这会迭代列表并使用Map.merge 来减少具有相同a 和b 的Foo 实例。

注意：您也可以在他的回答中像 Holger 一样使用BinaryOperator.minBy 来减少：

list.forEach(foo -> map.merge(Arrays.asList(foo.getA(), foo.getB()), foo,
    BinaryOperator.minBy(Comparator.comparingInt(Foo::getC))));