Java: ¿cómo puedo dividir una ArrayList en múltiples ArrayLists pequeñas?

¿Cómo puedo dividir una ArrayList (tamaño = 1000) en múltiples ArrayLists del mismo tamaño (= 10)?

ArrayList results; 

Puede usar subList(int fromIndex, int toIndex) para obtener una vista de una parte de la lista original.

De la API:

Devuelve una vista de la parte de esta lista entre el fromIndex especificado, inclusive, y toIndex , exclusivo. (Si fromIndex y toIndex son iguales, la lista devuelta está vacía). La lista devuelta está respaldada por esta lista, por lo que los cambios no estructurales en la lista devuelta se reflejan en esta lista, y viceversa. La lista devuelta admite todas las operaciones de lista opcionales admitidas por esta lista.

Ejemplo:

  List numbers = new ArrayList( Arrays.asList(5,3,1,2,9,5,0,7) ); List head = numbers.subList(0, 4); List tail = numbers.subList(4, 8); System.out.println(head); // prints "[5, 3, 1, 2]" System.out.println(tail); // prints "[9, 5, 0, 7]" Collections.sort(head); System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7]" tail.add(-1); System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7, -1]" 

Si necesita que estas listas subList NO sean una vista, simplemente cree una nueva List en la subList . Aquí hay un ejemplo de poner algunas de estas cosas juntas:

 // chops a list into non-view sublists of length L static  List> chopped(List list, final int L) { List> parts = new ArrayList>(); final int N = list.size(); for (int i = 0; i < N; i += L) { parts.add(new ArrayList( list.subList(i, Math.min(N, i + L))) ); } return parts; } List numbers = Collections.unmodifiableList( Arrays.asList(5,3,1,2,9,5,0,7) ); List> parts = chopped(numbers, 3); System.out.println(parts); // prints "[[5, 3, 1], [2, 9, 5], [0, 7]]" parts.get(0).add(-1); System.out.println(parts); // prints "[[5, 3, 1, -1], [2, 9, 5], [0, 7]]" System.out.println(numbers); // prints "[5, 3, 1, 2, 9, 5, 0, 7]" (unmodified!) 

Puede agregar la biblioteca Guava a su proyecto y usar el método Lists.partition , por ejemplo

 List bigList = ... List> smallerLists = Lists.partition(bigList, 10); 

Apache Commons Collections 4 tiene un método de partición en la clase ListUtils . Así es como funciona:

 import org.apache.commons.collections4.ListUtils; ... int targetSize = 100; List largeList = ... List> output = ListUtils.partition(largeList, targetSize); 

La respuesta proporcionada por polygenelubricants divide una matriz basada en el tamaño dado. Estaba buscando un código que dividiera una matriz en una cantidad determinada de partes. Aquí está la modificación que hice al código:

 public static List> chopIntoParts( final List ls, final int iParts ) { final List> lsParts = new ArrayList>(); final int iChunkSize = ls.size() / iParts; int iLeftOver = ls.size() % iParts; int iTake = iChunkSize; for( int i = 0, iT = ls.size(); i < iT; i += iTake ) { if( iLeftOver > 0 ) { iLeftOver--; iTake = iChunkSize + 1; } else { iTake = iChunkSize; } lsParts.add( new ArrayList( ls.subList( i, Math.min( iT, i + iTake ) ) ) ); } return lsParts; } 

Espero que ayude a alguien.

Esto funciona para mí

 /** * Returns List of the List argument passed to this function with size = chunkSize * * @param largeList input list to be portioned * @param chunkSize maximum size of each partition * @param  Generic type of the List * @return A list of Lists which is portioned from the original list */ public static  List> chunkList(List list, int chunkSize) { if (chunkSize <= 0) { throw new IllegalArgumentException("Invalid chunk size: " + chunkSize); } List> chunkList = new ArrayList<>(list.size() / chunkSize); for (int i = 0; i < list.size(); i += chunkSize) { chunkList.add(list.subList(i, i + chunkSize >= list.size() ? list.size() : i + chunkSize)); } return chunkList; } 

P.ej :

 List stringList = new ArrayList<>(); stringList.add(0); stringList.add(1); stringList.add(2); stringList.add(3); stringList.add(4); stringList.add(5); stringList.add(6); stringList.add(7); stringList.add(8); stringList.add(9); List> chunkList = getChunkList1(stringList, 2); 

Supongo que el problema que está teniendo es nombrar 100 ArrayLists y poblarlos. Puede crear una matriz de ArrayLists y completar cada una de ellas utilizando un bucle.

La forma más simple (leer la más estúpida) de hacer esto es así:

 ArrayList results = new ArrayList(1000); // populate results here for (int i = 0; i < 1000; i++) { results.add(i); } ArrayList[] resultGroups = new ArrayList[100]; // initialize all your small ArrayList groups for (int i = 0; i < 100; i++) { resultGroups[i] = new ArrayList(); } // put your results into those arrays for (int i = 0; i < 1000; i++) { resultGroups[i/10].add(results.get(i)); } 

Aquí se discutió una pregunta similar, Java: ¿dividir una Lista en dos sublistas?

Principalmente puedes usar sublista. Más detalles aquí: subList

Devuelve una vista de la porción de esta lista entre fromIndex, inclusive, e toIndex, exclusivo. (Si fromIndex y toIndex son iguales, la lista devuelta está vacía.) La lista devuelta está respaldada por esta lista, por lo que los cambios en la lista devuelta se reflejan en esta lista, y viceversa. La lista devuelta admite todas las operaciones de lista opcionales compatibles con esta lista …

Cree una nueva lista y agregue una vista de sublista de la lista de fonts con el método addAll para crear una nueva sublista
Lista newList = new ArrayList (); newList.addAll (sourceList.subList (startIndex, endIndex));

También puede usar la biblioteca FunctionalJava ; hay un método de partition para List . Esta lib tiene sus propios tipos de colección, puede convertirlos a colecciones java de ida y vuelta.

 import fj.data.List; java.util.List javaList = Arrays.asList("a", "b", "c", "d" ); List fList = Java.Collection_List().f(javaList); List partitions = fList.partition(2); 
 import org.apache.commons.collections4.ListUtils; ArrayList mainList = .............; List> multipleLists = ListUtils.partition(mainList,100); int i=1; for (List indexedList : multipleLists){ System.out.println("Values in List "+i); for (Integer value : indexedList) System.out.println(value); i++; } 

si no desea importar la biblioteca de Apache commons intente este código simple:

 final static int MAX_ELEMENT = 20; public static void main(final String[] args) { final List list = new ArrayList(); for (int i = 1; i <= 161; i++) { list.add(String.valueOf(i)); System.out.print("," + String.valueOf(i)); } System.out.println(""); System.out.println("### >>> "); final List> result = splitList(list, MAX_ELEMENT); for (final List entry : result) { System.out.println("------------------------"); for (final String elm : entry) { System.out.println(elm); } System.out.println("------------------------"); } } private static List> splitList(final List list, final int maxElement) { final List> result = new ArrayList>(); final int div = list.size() / maxElement; System.out.println(div); for (int i = 0; i <= div; i++) { final int startIndex = i * maxElement; if (startIndex >= list.size()) { return result; } final int endIndex = (i + 1) * maxElement; if (endIndex < list.size()) { result.add(list.subList(startIndex, endIndex)); } else { result.add(list.subList(startIndex, list.size())); } } return result; } 

Necesitas saber el tamaño del fragmento por el cual estás dividiendo tu lista. Supongamos que tiene una lista de 108 entries y necesita un tamaño de fragmento de 25 . Por lo tanto, terminarás con 5 lists :

  • 4 que tienen 25 entries cada una;
  • 1 (el quinto) que tiene 8 elements .

Código:

 public static void main(String[] args) { List list = new ArrayList(); for (int i=0; i<108; i++){ list.add(i); } int size= list.size(); int j=0; List< List > splittedList = new ArrayList>() ; List tempList = new ArrayList(); for(j=0;j(); } } if(size%25!=0){ //adding the remaining enteries splittedList.add(tempList); } for (int k=0;k
		      	

Java 8

Podemos dividir una lista según algún tamaño o según una condición.

 static Collection> partitionIntegerListBasedOnSize(List inputList, int size) { return inputList.stream() .collect(Collectors.groupingBy(s -> (s-1)/size)) .values(); } static  Collection> partitionBasedOnSize(List inputList, int size) { final AtomicInteger counter = new AtomicInteger(0); return inputList.stream() .collect(Collectors.groupingBy(s -> counter.getAndIncrement()/size)) .values(); } static  Collection> partitionBasedOnCondition(List inputList, Predicate condition) { return inputList.stream().collect(Collectors.partitioningBy(s-> (condition.test(s)))).values(); } 

Entonces podemos usarlos como:

 final List list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); System.out.println(partitionIntegerListBasedOnSize(list, 4)); // [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]] System.out.println(partitionBasedOnSize(list, 4)); // [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]] System.out.println(partitionBasedOnSize(list, 3)); // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]] System.out.println(partitionBasedOnCondition(list, i -> i<6)); // [[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]]