如何分割数组列表分成相等的部分？(How to split array list into equa

反正是有ArrayList中分裂成不同的部分，而不知道它的大小，直到运行？ 我知道有一个叫方法：

list.subList(a,b);

但我们需要明确提到盯着结束列表的范围。 我的问题是，我们得到的含有是，如2000,4000账号数据（有数字不会在编码时已知的）账号一个ArrayList中，我需要通过这个ACC号为PL / SQL的IN查询，如在它不支持超过1000个值，我试图分裂成多个区块，并在发送查询

注：我不能使用任何外部库，例如番石榴等.. :(这方面的任何指导表示赞赏。

Answer 1:

这应该给你你所有的部件：

int partitionSize = 1000;
List<List<Integer>> partitions = new LinkedList<List<Integer>>();
for (int i = 0; i < originalList.size(); i += partitionSize) {
    partitions.add(originalList.subList(i,
            Math.min(i + partitionSize, originalList.size())));
}

Answer 2:

泛型函数：

public static <T> ArrayList<T[]> chunks(ArrayList<T> bigList,int n){
    ArrayList<T[]> chunks = new ArrayList<T[]>();

    for (int i = 0; i < bigList.size(); i += n) {
        T[] chunk = (T[])bigList.subList(i, Math.min(bigList.size(), i + n)).toArray();         
        chunks.add(chunk);
    }

    return chunks;
}

享受吧〜:)

Answer 3:

Java的8（不在于它具有的优势）：

    List<String> list = new ArrayList<>();
    Collections.addAll(list,  "a","b","c","b","c","a","c","a","b");

分组大小：

    final int G = 3;
    final int NG = (list.size() + G - 1) / G;

在旧样式：

    List<List<String>> result = new ArrayList(NG);
    IntStream.range(0, list.size())
        .forEach(i -> {
            if (i % G == 0) {
                result.add(i/G, new ArrayList<>());
            }
            result.get(i/G).add(list.get(i));
        });

在新的风格：

    List<List<String>> result = IntStream.range(0, NG)
        .mapToObj(i -> list.subList(3 * i, Math.min(3 * i + 3, list.size())))
        .collect(Collectors.toList());

由于@StuartMarks的遗忘toList。

Answer 4:

如果你被限制PL / SQL in限制，那么你想知道如何将一个列表分成大小<= n，其中n是极限块。 这是一个简单得多的问题，因为它不需要知道列表的大小提前。

伪代码：

for (int n=0; n<list.size(); n+=limit)
{
    chunkSize = min(list.size,n+limit);
    chunk     = list.sublist(n,chunkSize);
    // do something with chunk
}

Answer 5:

如果你已经拥有或者不介意加入番石榴库，你不需要推倒重来。

简单地做： final List<List<String>> splittedList = Lists.partition(bigList, 10);

其中bigList实现List接口和10是每个子列表的所需尺寸（最后可以更小）

Answer 6:

listSize = oldlist.size();
chunksize =1000;
chunks = list.size()/chunksize;
ArrayList subLists;
ArrayList finalList;
int count = -1;
for(int i=0;i<chunks;i++){
     subLists = new ArrayList();
     int j=0;
     while(j<chunksize && count<listSize){
        subList.add(oldList.get(++count))
        j++;
     }
     finalList.add(subLists)
}

因为它包含了oldList的chuncks列表您可以使用此finalList。

Answer 7:

我也做钥匙：用于索引值值映射。

  public static void partitionOfList(List<Object> l1, List<Object> l2, int partitionSize){
            Map<String, List<Object>> mapListData = new LinkedHashMap<String, List<Object>>();
            List<Object> partitions = new LinkedList<Object>();
            for (int i = 0; i < l1.size(); i += partitionSize) {
                partitions.add(l1.subList(i,Math.min(i + partitionSize, l1.size())));
                l2=new ArrayList(partitions);
            }
            int l2size = l2.size();
            System.out.println("Partitioned List: "+l2);
            int j=1;
            for(int k=0;k<l2size;k++){
                 l2=(List<Object>) partitions.get(k);
                // System.out.println(l2.size());
                 if(l2.size()>=partitionSize && l2.size()!=1){
                mapListData.put("val"+j+"-val"+(j+partitionSize-1), l2);
                j=j+partitionSize;
                 }
                 else if(l2.size()<=partitionSize && l2.size()!=1){
                    // System.out.println("::::@@::"+ l2.size());
                     int s = l2.size();
                     mapListData.put("val"+j+"-val"+(j+s-1), l2);
                        //k++;
                        j=j+partitionSize;
                 }
                 else if(l2.size()==1){
                    // System.out.println("::::::"+ l2.size());
                     //int s = l2.size();
                     mapListData.put("val"+j, l2);
                        //k++;
                        j=j+partitionSize;
                 }
            }
            System.out.println("Map: " +mapListData);
        }

    public static void main(String[] args) {
            List l1 = new LinkedList();
            l1.add(1);
            l1.add(2);
            l1.add(7);
            l1.add(4);
            l1.add(0);
            l1.add(77);
            l1.add(34);

    partitionOfList(l1,l2,2);
    }

输出：

分配列表：[[1，2]，[7,4]，[0，77]，[34]]

地图：{VAL1-val2的= [1，2]，VAL3-VAL4 = [7,4]，val5-VAL6 = [0，77]，val7 = [34]}

Answer 8:

下面的代码：

  private static List<List<Object>> createBatch(List<Object> originalList, int 
  batch_size) {
    int Length = originalList.size();
    int chunkSize = Length / batch_size;
    int residual = Length-chunkSize*batch_size;
    List<Integer> list_nums = new ArrayList<Integer>();
    for (int i = 0; i < batch_size; i++) {
        list_nums.add(chunkSize);
    }
    for (int i = 0; i < residual; i++) {
        list_nums.set(i, list_nums.get(i) + 1);
    }
    List<Integer> list_index = new ArrayList<Integer>();
    int cumulative = 0;
    for (int i = 0; i < batch_size; i++) {
        list_index.add(cumulative);
        cumulative += list_nums.get(i);
    }
    list_index.add(cumulative);
    List<List<Object>> listOfChunks = new ArrayList<List<Object>>();
    for (int i = 0; i < batch_size; i++) {
        listOfChunks.add(originalList.subList(list_index.get(i), 
 list_index.get(i + 1)));
    }
    return listOfChunks;
  }

产生以下输出：

  //[0,..,99] equally partition into 6 batch
  // result:batch_size=[17,17,17,17,16,16]
  //Continually partition into 6 batch, and residual also equally 
  //partition into top n batch
  // Output:
  [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,40,41,42,43,44,45,46,47,48,49,50] 
  [51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67] 
  [68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83]       
  [84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]  

Answer 9:

您的帮助泛型方法：

private static List<List<Object>> createBatch(List<Object> originalList,
        int chunkSize) {
    List<List<Object>> listOfChunks = new ArrayList<List<Object>>();
    for (int i = 0; i < originalList.size() / chunkSize; i++) {
        listOfChunks.add(originalList.subList(i * chunkSize, i * chunkSize
                + chunkSize));
    }
    if (originalList.size() % chunkSize != 0) {
        listOfChunks.add(originalList.subList(originalList.size()
                - originalList.size() % chunkSize, originalList.size()));
    }
    return listOfChunks;

文章来源: How to split array list into equal parts?