用java 8重写收集列表（创建集群）答案

【问题标题】：Rewrite collecting list of list with java 8 (create clusters)用java 8重写收集列表（创建集群）
【发布时间】：2018-01-15 00:11:09
【问题描述】：

我有类似下面的东西写成“老派”版本，我试图在给定的List 中收集和分组相似之处。我想将此解决方案转换为我认为更好的functional 方式和grouping 或更多java 8 stream 方式。

实际上我想摆脱 List<List<T>> listOfLists = new LinkedList<List<T>>(); 的初始化并将这个实例传递给 getMatchedList 方法。

这是我目前的解决方案：

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;

public class HelloWorld {

    public static void main(String... args) {

        List<Integer> originalList = Arrays.asList(1, 2, 4, 5, 7);

        List<List<Integer>> listOfLists = new LinkedList<>();
        originalList.stream()
                .forEach(item -> {
                    Optional<List<Integer>> list = getMatchedList(item, listOfLists);
                    if (list.isPresent()) {
                        list.get().add(item);
                    } else {
                        listOfLists.add(new LinkedList<>(Arrays.asList(item)));
                    }
                });
        System.out.println(listOfLists);
    }

    static Optional<List<Integer>> getMatchedList(Integer item, List<List<Integer>> list) {
        return list.stream().filter(a -> matched(a, item)).findAny();
    }

    static boolean matched(List<Integer> list, Integer b) {
        return list.stream().filter(x -> isSimilar(x, b)).findAny().isPresent();
    }

    static boolean isSimilar(Integer a, Integer b) {
        return Math.abs(a - b) <= 1; // true or false based on additional logic
    }

}

假设 isSimilar 函数是Math.abs(a - b) <= 1。因此，我希望列出如下列表：

[
   [1,2],
   [4,5],
   [7]
]

注意：例如，如果我们有1,2,3，我们应该有列表：[1,2,3]，尽管1 和3 并不相似。但它们是“连接”的，具有共同的相似性，即2。

注意二：问题不在于数字。数字只是为了简单。实际上我有自定义对象不是Integers，我也有不同的isSimilar 函数。目标是以java-8 functional 方式实现对集群的这种“分组”。

【问题讨论】：

如果 a 类似于 b 并且 b 类似于 c 但a 和 c 不相似？
@shmosel 如果我们有1,2,3，其中1 是a，2 是b 和3 是c，根据您的注释，我们应该得到一个列表关注：[1,2,3]
你的代码能做到吗？
你的结果依赖于顺序，即如果输入是1, 2, 4, 5, 7, 3, 6，你不会得到[[1, 2, 3, 4, 5, 6, 7]]，而是[[1, 2, 3], [4, 5, 6], [7]]。流操作通常不适合这种依赖顺序的操作，或者需要额外的努力才能正确。此外，我推荐阅读When to use LinkedList over ArrayList?...
如果isSimilar 不是传递函数，这意味着isSimilar(x, y) && isSimilar(y,z) 并不暗示isSimilar(x, z)，那么使用Streams 获得一个体面的实现将是相当困难的。如果isSimilar 是可传递的，您可以使用reduce 继续将元素添加到一组相似/“等价”组中。

标签： java collections java-8 grouping java-stream

【解决方案1】：

我了解您想在 OP 中做什么：摆脱 List<List<T>> listOfLists = new LinkedList<List<T>>()... 的初始化...但不知道为什么。这是我的答案，也许不是你想要的。首先，我想从我个人的角度提高一点可读性：

public void test_45551110() {
    List<Integer> originalList = Arrays.asList(1, 2, 4, 5, 7);

    List<List<Integer>> listOfLists = new ArrayList<>();
    originalList.stream().forEach(item -> getMatchedList(item, listOfLists).add(item));
    System.out.println(listOfLists);
}

static List<Integer> getMatchedList(Integer item, List<List<Integer>> listOfLists) {
    return listOfLists.stream().filter(a -> matched(a, item)).findAny().orElseGet(() -> {
        List<Integer> list = new ArrayList<>();
        listOfLists.add(list);
        return list;
    });
}

其次，如果列表中的原始元素可以根据某些属性进行排序。 StreamEx可以轻松解决您的疑虑

List<List<Integer>> res = StreamEx.of(Arrays.asList(1, 2, 5, 7, 3))
        .sorted().collapse((a, b) -> isSimilar(a, b), Collectors.toList()).toList();
System.out.print(res); // output: [[1, 2, 3], [5], [7]]

我认为大多数人可能更关心时间复杂度 n ^ 2，而不是摆脱 List<List<T>> listOfLists = new LinkedList<List<T>>() 的初始化。如果您能在 isSimilar 中分享真实的数据结构和逻辑，我们或许能够为您的问题找出真正/更好的解决方案。

【讨论】：