列表的列表的列表（用 N 深度展平 ArrayList）

Question

我正在尝试用 N 深度展平 ArrayList。为此，我尝试使用 Stream API 的flapMap 方法。我能够得到它。但我必须根据列表列表的数量重复使用 flatMap() 方法。如果我再使用一种 flatMap() 方法，它会显示编译时错误。有什么办法可以动态地完成它。

这是我使用的代码：

List<Integer> list1 = Arrays.asList(4,5,6);
List<Integer> list2 = Arrays.asList(7,8,9);

List<List<Integer>> listOfLists = Arrays.asList(list1, list2);

List<List<List<Integer>>> listA = Arrays.asList(listOfLists);
List<List<List<List<Integer>>>> listB = Arrays.asList(listA);

List<Integer> listFinal = listB.stream()
    .flatMap(x -> x.stream())
    .flatMap(x -> x.stream())
    .flatMap(x -> x.stream())
    .collect(Collectors.toList());
//In the above line, If I use listA instead of listB, it is showing error.

listFinal.forEach(x-> System.out.println(x));

Answer 1

这似乎对我有用，使用递归。当给定一个列表时，

• 检查它是否是一个整数列表，在这种情况下返回它。
• 否则它是一个列表的列表。 FlatMap 它（以删除 1 层嵌套），并展平生成的列表。

private static List<Integer> flatten(List<?> list) {
    if (list.get(0) instanceof Integer) {
        return (List<Integer>) list;
    }

    List<List<?>> listOfLists = (List<List<?>>) list;
    return flatten(listOfLists.stream()
            .flatMap(Collection::stream)
            .collect(Collectors.toList()));
}

然后

public static void main(String[] args) {
    List<List<List<List<List<Integer>>>>> listC = Arrays.asList(
            Arrays.asList(
                    Arrays.asList(
                            Arrays.asList(
                                    Arrays.asList(0, 1),
                                    Arrays.asList(2, 3, 4)
                            ),
                            Arrays.asList(
                                    Arrays.asList(5),
                                    Arrays.asList(6, 7),
                                    Arrays.asList(8, 9)
                            )
                    ),
                    Arrays.asList(
                            Arrays.asList(
                                    Arrays.asList(10, 11),
                                    Arrays.asList(12, 13, 14)
                            ),
                            Arrays.asList(
                                    Arrays.asList(15),
                                    Arrays.asList(16, 17),
                                    Arrays.asList(18, 19)
                            )
                    )
            ),
            Arrays.asList(
                    Arrays.asList(
                            Arrays.asList(
                                    Arrays.asList(20, 21),
                                    Arrays.asList(22, 23, 24)
                            ),
                            Arrays.asList(
                                    Arrays.asList(25),
                                    Arrays.asList(26, 27),
                                    Arrays.asList(28, 29)
                            )
                    ),
                    Arrays.asList(
                            Arrays.asList(
                                    Arrays.asList(30, 31),
                                    Arrays.asList(32, 33, 34)
                            ),
                            Arrays.asList(
                                    Arrays.asList(35),
                                    Arrays.asList(36, 37),
                                    Arrays.asList(38, 39)
                            )
                    )
            )
    );

    List<Integer> result = flatten(listC);

    System.out.println(listC);
    System.out.println(result);

}

打印

[[[[[0, 1], [2, 3, 4]], [[5], [6, 7], [8, 9]]], [[[10, 11], [12, 13, 14]], [[15], [16, 17], [18, 19]]]], [[[[20, 21], [22, 23, 24]], [[25], [26, 27], [28, 29]]], [[[30, 31], [32, 33, 34]], [[35], [36, 37], [38, 39]]]]]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]

There is a bit of Uncheckedcasting正在进行，但不知道如何做没有

Answer 2

对于List>>> listB, .stream().flatMap(.stream()).flatMap(.stream()).flatMap(.stream()).collect()

但是对于 列表<列表<列表<整数>>> listA，.stream().flatMap(.stream()).flatMap(.stream()).collect()。

请参阅 flatMap() 计数仅比通用深度少 1。

Answer 3

我希望您知道深度嵌套的集合并不是表示数据的最佳方式，必须避免（它几乎肯定是错误设计的指标）。因此，我将把这个问题视为一个神秘的谜题，而不是一个实际任务。

您可以在不使用递归的情况下实现这一点。但请注意，这种方法和递归一样都是恶性的，因为递归方法也需要放弃泛型提供的类型安全（我警告过你不应该'首先不要这样做）。

为此，您需要在循环中执行instanceof检查。并使用嵌套列表的元素填充行类型的结果列表。

注意：

• 与常用的泛型集合相反，例如List，其特征为协变（即您可以仅分配相同类型的集合给它）您可以将任何东西分配给< em>行类型 和修改它。这是一个不安全的组合，因此强烈建议不要使用行类型集合。

如果第一个元素不是列表，则循环退出。

public static void main(String[] args) {
    List<List<List<List<Integer>>>> source =
            List.of(List.of(List.of(List.of(4,5,6), List.of(7,8,9))));

    List<Integer> result = source.stream()
            .flatMap(list -> deepFlatten(list).stream())
            .collect(Collectors.toList());
    
    System.out.println(source);
    System.out.println(result);
}

public static List<Integer> deepFlatten(List<?> nestedList) {
    if (nestedList.isEmpty()) {
        return (List<Integer>) nestedList;
    }

    List result = new ArrayList<>();
    List current = nestedList;
    while (current.get(0) instanceof List<?>) {
        for (Object next: current) {
            result.addAll((List) next);
        }
        current = result;
        result = new ArrayList<>();
    }
    return (List<Integer>) current;
}

输出

[[[[4, 5, 6], [7, 8, 9]]]]
[4, 5, 6, 7, 8, 9]

Answer 4

下面的代码片段对我有用。感谢大家的回复。

列表 list1 = Arrays.asList(4,5,6);
列表 list2 = Arrays.asList(7,8,9);

    List<List<Integer>> listOfLists = Arrays.asList(list1, list2);

    List< List< List<Integer> > > list = Arrays.asList(listOfLists);
    List< List< List<List<Integer>> > > listB = Arrays.asList(list);
    
    
    //List<Integer> listF = listB.stream().flatMap(x -> x.stream()).flatMap(x -> x.stream()).flatMap(x -> x.stream()).collect(Collectors.toList());
    
    List<Integer> flattenList = (List<Integer>) getList(listB);
    flattenList.forEach(x-> System.out.println(x));
    
    
}
public static List<?> getList(List<? > s) {
    
    if( s.isEmpty() || !( s.get(0) instanceof List) ) {
        return s;
    }
    
    return getList( (List<?>) s.stream().flatMap(x-> ((List)x).stream()).collect(Collectors.toList()));
}