基于嵌套对象属性的 Java 8 过滤器列表

Question

我有一个 Thingy pojo 的列表，例如：

public class Thingy {
    private DifferentThingy nestedThingy;
    public DifferentThingy getNestedThingy() {
        return this.nestedThingy;
    }
}

...

public class DifferentThingy {
    private String attr;
    public String getAttr() {
        return this.attr;
    }
}

我要过滤一个

List<Thingy>

是唯一的基于

attr

Thingy 的

DifferentThingy

这是我迄今为止尝试过的：

private List<Thingy> getUniqueBasedOnDifferentThingyAttr(List<Thingy> originalList) {
    List<Thingy> uniqueItems = new ArrayList<Thingy>();
    Set<String> encounteredNestedDiffThingyAttrs= new HashSet<String>();
    for (Thingy t: originalList) {
        String nestedDiffThingyAttr = t.getNestedThingy().getAttr();
        if(!encounteredNestedDiffThingyAttrs.contains(nestedDiffThingyAttr)) {
            encounteredNestedDiffThingyAttrs.add(nestedDiffThingyAttr);
            uniqueItems.add(t);
        }
    }
    return uniqueItems;
}

我想为最终检索用于确定唯一性的属性的两个 getter 使用 Java 8 流和 lambda，但我不确定如何。当用于比较的属性位于 pojo 的顶层时，我知道该怎么做，但当属性嵌套在另一个对象中时，我不知道。

Answer 1

你可以这样做：

originalList.stream()
    .collect(Collectors.toMap(thing -> thing.getNestedThingy().getAttr(), p -> p, (p, q) -> p))
    .values();

不确定是否是最佳方式，我在 Android 上，所以不要在日常工作中使用流。

UPD

对于无法编译的人，我的测试文件有full code。

Answer 2

如何使用javaslang 使其更加明确

javaslang.collection.List.ofAll(thingies)
  .distinctBy(t -> t.getNestedThingy().getAttr());

Javaslang 核心是 Java 8+ 的函数库。它有助于减少代码量并增加健壮性。函数式编程的第一步是开始思考不可变的值。 Javaslang 提供了不可变集合以及对这些值进行操作所需的函数和控制结构。结果很漂亮，而且很有效。

Answer 3

我保留了一组独特的嵌套事物的属性... 然后我尝试向它添加一个元素。 当集合“增长”时，意味着遇到了一个独特的元素。 当设置大小没有改变时，这意味着这个Thingy 有一个NestedThingy 带有一个已经遇到的属性。 再加上一个简单的测试：

public class Thingies {

    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        final Set<Object> seen = Collections.synchronizedSet(new HashSet<>());
        return t -> seen.add(keyExtractor.apply(t));
    }

    private static List<Thingy> getUniqueBasedOnDifferentThingyAttr(List<Thingy> originalList) {
        return originalList.stream()
                .filter(distinctByKey(thingy -> thingy.getNestedThingy().getAttr()))
                .collect(toList());
    }

    public static void main(String[] args) {
        List<Thingy> originalList = new ArrayList<>();
        originalList.add(new Thingy(new DifferentThingy("first")));
        originalList.add(new Thingy(new DifferentThingy("first")));
        originalList.add(new Thingy(new DifferentThingy("second")));
        System.out.println(getUniqueBasedOnDifferentThingyAttr(originalList));
    }
}

输出：

[first, second]

帮助 OP 的原始答案（有点冗长，不适合并行流）包含这样的方法：

private static List<Thingy> getUniqueBasedOnDifferentThingyAttr(List<Thingy> originalList) {
    final Set<String> uniqueAttributes = new HashSet<>(originalList.size());
    return originalList.stream()
            .filter(thingy -> {
                int initialSize = uniqueAttributes.size();
                uniqueAttributes.add(thingy.getNestedThingy().getAttr());
                return initialSize != uniqueAttributes.size();
            }).collect(toList());
}

Answer 4

您可以使用TreeSet，它的比较器可以到达子对象的属性：

private static List<Thingy> getUniqueBasedOnDifferentThingyAttr(List<Thingy> originalList) {

    Set<Thingy> uniqueSet = new TreeSet<Thingy>(Comparator.comparing(thingy -> thingy.getNestedThingy().getAttr()));

    return originalList.stream()
            .filter(uniqueSet::add)
            .collect(Collectors.toList());
}

uniqueSet::add 是一个足够的唯一性过滤器，因为它仅在项目不在集合中时才返回 true。

Answer 5

与StreamEx:

StreamEx.of(originalList).distinct(e -> e.getNestedThingy().getAttr()).toList();

或AbacusUtil

Stream.of(originalList).distinct(e -> e.getNestedThingy().getAttr()).toList();