Estoy tratando de aplanar una ArrayList con N-Depth. Para esto intenté usar el método flapMap de Stream API. soy capaz de conseguirlo. Pero tengo que usar el método flatMap() repetidamente según el número de listas. Si estoy usando un método flatMap() más, muestra un error de tiempo de compilación. ¿Hay alguna forma de hacerlo dinámicamente?
Este es el código que usé:
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));Para List<List<List<List<Integer>>>> listB , .stream().flatMap(.stream()).flatMap(.stream()).flatMap(.stream()).collect()
Pero para List<List<List<Integer>>> listA , .stream().flatMap(.stream()).flatMap(.stream()).collect() .
Vea que el recuento de flatMap() es solo uno menos que la profundidad genérica.
Espero que sepa que las colecciones profundamente anidadas no son la mejor manera de representar los datos y deben evitarse ( es un indicador casi seguro de un diseño defectuoso ). Así que trataré esta pregunta como un enigma críptico en lugar de una tarea práctica.
Puede lograr eso sin usar la recursividad. Pero tenga cuidado, este enfoque también es vicioso porque el enfoque recursivo también requiere renunciar a la seguridad de tipos proporcionada por los genéricos ( he advertido que no debe hacer eso en primer lugar ).
Para hacer eso, debe realizar comprobaciones de intanceof en un bucle . Y rellene la lista resultante de tipo de fila con elementos de una lista anidada .
Nota :
List<Integer> que se caracterizan como covariantes ( es decir, solo puede asignarle una colección del mismo tipo ), puede asignar cualquier cosa a la lista de tipo de fila y modificarla también. Lo cual es una combinación insegura y, por lo tanto, se desaconseja encarecidamente el uso de colecciones de tipo de fila.El ciclo sale si el primer elemento no es una lista .
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; }Producción
[[[[4, 5, 6], [7, 8, 9]]]] [4, 5, 6, 7, 8, 9]