Java：如何将 ArrayList 拆分为多个小 ArrayList？

Java: how can I split an ArrayList in multiple small ArrayLists?

提问by aneuryzm

How can I split an ArrayList (size=1000) in multiple ArrayLists of the same size (=10) ?

如何将 ArrayList (size=1000) 拆分为多个相同大小 (=10) 的 ArrayLists ？

ArrayList<Integer> results;

采纳答案by polygenelubricants

You can use subList(int fromIndex, int toIndex)to get a view of a portion of the original list.

您可以使用subList(int fromIndex, int toIndex)来查看原始列表的一部分。

From the API:

从API：

Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. (If fromIndexand toIndexare equal, the returned list is empty.) The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations supported by this list.

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

Example:

例子：

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]"

If you need these chopped lists to be NOT a view, then simply create a new Listfrom the subList. Here's an example of putting a few of these things together:

如果您需要这些切碎的列表不是视图，那么只需List从subList. 这是将其中一些东西放在一起的示例：

// 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!)

回答by angstrom91

I'm guessing that the issue you're having is with naming 100 ArrayLists and populating them. You can create an array of ArrayLists and populate each of those using a loop.

我猜您遇到的问题是命名 100 个 ArrayLists 并填充它们。您可以创建一个 ArrayList 数组并使用循环填充每个数组。

The simplest (read stupidest) way to do this is like this:

最简单（读起来最愚蠢）的方法是这样的：

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

回答by Incognito

A similar question was discussed here, Java: split a List into two sub-Lists?

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

Mainly you can use sublist. More details here : subList

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

Returns a view of the portion of this list between fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the returned list is empty.) The returned list is backed by this list, so changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations supported by this list...

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

回答by Mike Q

You can add the Guavalibrary to your project and use the Lists.partitionmethod, e.g.

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

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

回答by Lara

The answer provided by polygenelubricants splits an array based on given size. I was looking for code that would split an array into a given number of parts. Here is the modification I did to the code:

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

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

Hope it helps someone.

希望它可以帮助某人。

回答by Mikhail Golubtsov

You can also use FunctionalJavalibrary - there is partitionmethod for List. This lib has its own collection types, you can convert them to java collections back and forth.

您还可以使用FunctionalJava库 - 有partition用于List. 这个 lib 有自己的集合类型，你可以将它们来回转换为 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);

回答by johnnieb

Apache Commons Collections 4has a partitionmethod in the ListUtilsclass. Here's how it works:

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

回答by user688

Create a new list and add sublist view of source list using addAll method to create a new sublist
List newList = new ArrayList(); newList.addAll(sourceList.subList(startIndex, endIndex));

创建一个新列表并添加源列表的子列表视图，使用 addAll 方法创建一个新的子
列表 List newList = new ArrayList(); newList.addAll(sourceList.subList(startIndex, endIndex));

回答by B.JAAFAR

if you don't want to import the apache commons library try this simple code:

如果您不想导入 apache 公共库，请尝试以下简单代码：

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

回答by J.R

This works for me

这对我有用

/**
* 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 
*/
public static  <T> List<List<T>> chunkList(List<T> list, int chunkSize) {
    if (chunkSize <= 0) {
        throw new IllegalArgumentException("Invalid chunk size: " + chunkSize);
    }
    List<List<T>> 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()-1 : i + chunkSize));
    }
    return chunkList;
}

Eg :

例如：

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