Java：如何在多个小型ArrayLists中拆分ArrayList？

我怎样才能在一个大小相同（= 10）的多个ArrayList中分割一个ArrayList（size = 1000）？

ArrayList<Integer> results; 

Answer 1

您可以使用subList(int fromIndex, int toIndex)来获取原始列表的一部分视图。

从API：

返回指定的fromIndex （包含）和toIndex （不包括）之间的列表部分视图。 （如果fromIndex和toIndex相等，则返回的列表是空的。）返回的列表由此列表支持，因此返回列表中的非结构化更改将反映在此列表中，反之亦然。 返回的列表支持此列表支持的所有可选列表操作。

例：

  List<Integer> numbers = new ArrayList<Integer>( Arrays.asList(5,3,1,2,9,5,0,7) ); List<Integer> head = numbers.subList(0, 4); List<Integer> 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]" 

如果你需要这些切碎的列表不是一个视图，那么只需从subList List创build一个新的List 。 以下是将这些内容放在一起的一个例子：

 // chops a list into non-view sublists of length L static <T> List<List<T>> chopped(List<T> list, final int L) { List<List<T>> parts = new ArrayList<List<T>>(); final int N = list.size(); for (int i = 0; i < N; i += L) { parts.add(new ArrayList<T>( list.subList(i, Math.min(N, i + L))) ); } return parts; } List<Integer> numbers = Collections.unmodifiableList( Arrays.asList(5,3,1,2,9,5,0,7) ); List<List<Integer>> 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!) 

Answer 2

您可以将谷歌collections Guava库添加到您的项目，并使用Lists.partition方法，例如

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

Answer 3

Apache Commons Collections 4在ListUtils类中有一个分区方法。 这是如何工作的：

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

Answer 4

由polygenelubricants提供的答案根据给定的大小分割arrays。 我正在寻找将数组分成给定数量的部分的代码。 这是我对代码所做的修改：

 public static <T>List<List<T>> chopIntoParts( final List<T> ls, final int iParts ) { final List<List<T>> lsParts = new ArrayList<List<T>>(); 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<T>( ls.subList( i, Math.min( iT, i + iTake ) ) ) ); } return lsParts; } 

希望它可以帮助别人。

Answer 5

我猜你所遇到的问题是命名100个ArrayLists并填充它们。 您可以创build一个ArrayLists数组，并使用循环填充每个数组列表。

最简单的（阅读愚蠢）的方式是这样的：

 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)); } 

Answer 6

在这里讨论了一个类似的问题， Java：将List分成两个子列表？

主要你可以使用子列表。 更多细节在这里： subList

返回fromIndex（包含）和toIndex（不包括）之间的列表部分视图。 （如果fromIndex和toIndex相等，则返回的列表是空的。）返回的列表由此列表支持，所以返回列表中的更改反映在此列表中，反之亦然。 返回的列表支持此列表支持的所有可选列表操作…

Answer 7

这对我有用

 /** * 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 <T> Generic type of the List * @return A list of Lists which is portioned from the original list */ private <T> List<List<T>> getChunkList(List<T> largeList , int chunkSize) { List<List<T>> chunkList = new ArrayList<>(); for (int i = 0 ; i < largeList.size() ; i += chunkSize) { chunkList.add(largeList.subList(i , i + chunkSize >= largeList.size() ? largeList.size() : i + chunkSize)); } return chunkList; } 

例如：

 List<Integer> 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<List<Integer>> chunkList = getChunkList1(stringList, 2); 

Answer 8

你也可以使用FunctionalJava库 – 有List partition方法。 这个lib有自己的集合types，可以将它们来回转换为java集合。

 import fj.data.List; java.util.List<String> javaList = Arrays.asList("a", "b", "c", "d" ); List<String> fList = Java.<String>Collection_List().f(javaList); List<List<String> partitions = fList.partition(2); 

Answer 9

使用addAll方法创build一个新的列表并添加源列表的子列表视图来创build一个新的子列表
List newList = new ArrayList（）; newList.addAll（sourceList.subList（startIndex，endIndex））;

Answer 10

 import org.apache.commons.collections4.ListUtils; ArrayList<Integer> mainList = .............; List<List<Integer>> multipleLists = ListUtils.partition(mainList,100); int i=1; for (List<Integer> indexedList : multipleLists){ System.out.println("Values in List "+i); for (Integer value : indexedList) System.out.println(value); i++; } 

Answer 11

如果你不想导入apache的commons库，试试这个简单的代码：

 final static int MAX_ELEMENT = 20; public static void main(final String[] args) { final List<String> list = new ArrayList<String>(); 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<List<String>> result = splitList(list, MAX_ELEMENT); for (final List<String> entry : result) { System.out.println("------------------------"); for (final String elm : entry) { System.out.println(elm); } System.out.println("------------------------"); } } private static List<List<String>> splitList(final List<String> list, final int maxElement) { final List<List<String>> result = new ArrayList<List<String>>(); 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; } 

Answer 12

你需要知道你分割你的列表的块大小。 假设你有一个108 entries的列表，你需要一个25的块大小。 因此，你将会得到5 lists ：

• 4 25 entries每个25 entries ;
• 1（第五）有8 elements 。

码：

 public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); for (int i=0; i<108; i++){ list.add(i); } int size= list.size(); int j=0; List< List<Integer> > splittedList = new ArrayList<List<Integer>>() ; List<Integer> tempList = new ArrayList<Integer>(); for(j=0;j<size;j++){ tempList.add(list.get(j)); if((j+1)%25==0){ // chunk of 25 created and clearing tempList splittedList.add(tempList); tempList = null; //intializing it again for new chunk tempList = new ArrayList<Integer>(); } } if(size%25!=0){ //adding the remaining enteries splittedList.add(tempList); } for (int k=0;k<splittedList.size(); k++){ //(k+1) because we started from k=0 System.out.println("Chunk number: "+(k+1)+" has elements = "+splittedList.get(k).size()); } }