java - 用java 8重写列表的收集列表(创建集群)

Question

我将类似下面的内容写成“老派”版本，我试图在给定的 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 中实现对集群的这种“分组”方式。

Answer 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 中分享真实的数据结构和逻辑，我们也许能够为您的问题找到真实/更好的解决方案。