Java 使用List.subList执行元素批处理逻辑

我需要获取一个有几千个元素的ArrayList，然后一次处理1000个元素。所以我需要一个大的ArrayList（假设它有3500个元素）并创建一个最多有1000个元素的新ArrayList。我正在使用下面的代码，但我觉得它没有那么有效，有什么建议吗

import java.util.ArrayList;
import java.util.List;

public class SubList {

  public static void main(String[] args) {
    List<Long> ids = new ArrayList<Long>();
   for(int i=0; i<3500; i++){
     ids.add(Long.valueOf(i));
   }
   int threashold=1000;
   double iteration = (double)ids.size()/threashold;
   int fromIndex=0;
   int toIndex=threashold;
   for(int i=0; i<iteration; i++){
     if(i + 1 >= iteration){
       toIndex = ids.size();
       List<Long> list = ids.subList(fromIndex, toIndex);
       processList(list);
     }else{
       List<Long> list = ids.subList(fromIndex, toIndex);
       processList(list);
       fromIndex += threashold;
       toIndex += threashold;
     }
   }

  }
  private static void processList(List<Long> ids){
    System.out.println("size=" + ids.size());
  }

}

import java.util.ArrayList；
导入java.util.List；
公共类子列表{
公共静态void main（字符串[]args）{
列表ID=新的ArrayList（）；
对于（inti=0；i我检查了类ArrayList（表单openjdk）中方法子列表的实现

公共列表更多…子列表（int-fromIndex，int-toIndex）{
子列表范围检查（从索引到索引、大小）；
返回新的子列表（this，0，fromIndex，toIndex）；
}

返回的类不是ArrayList的实例，而是名为SubList的内部类的实例

SubList(AbstractList<E> parent,
    int offset, int fromIndex, int toIndex) {
    this.parent = parent;
    this.parentOffset = fromIndex;
    this.offset = offset + fromIndex;
    this.size = toIndex - fromIndex;
    this.modCount = ArrayList.this.modCount;
}

子列表（抽象列表父级、，
整数偏移量，整数从索引，整数到索引）{
this.parent=parent；
this.parentOffset=fromIndex；
this.offset=offset+fromIndex；
this.size=toIndex-fromIndex；
this.modCount=ArrayList.this.modCount；
}

子列表存储与原始ArrayList的关系，并使用它而不是制作简单的副本，因此它应该与原始ArrayList一样高效，并且子列表是在固定时间内创建的

因此，您的实现可能还可以。
我对字符串列表做了类似的操作。我已将其转换为Long for you。它基本上是一个列表副本，除非当它达到阈值时，它存储列表并开始一个新的列表。它不像您那样内联处理列表。但这是一种“整洁”的方法

public static List<List<Long>> getSubLists(List<Long> list, int size) {
    List<List<Long>> outer = new ArrayList<List<Long>>();

    List<Long> subList = new ArrayList<Long>(size);
    for (Long l : list) {
        subList.add(l);

        if (subList.size() >= size) {
            outer.add(subList);
            subList = new ArrayList<Long>(size);
        }
    }
    if (subList.size() > 0) {
        outer.add(subList);
    }
    return outer;
}

publicstaticlist获取子列表（列表列表，int-size）{
List outer=new ArrayList（）；
列表子列表=新的ArrayList（大小）；
用于（长l:列表）{
子列表。添加（l）；
if（subList.size（）>=size）{
添加（子列表）；
子列表=新阵列列表（大小）；
}
}
if（subList.size（）>0）{
添加（子列表）；
}
返回外部；
}
但我觉得它没有那么高效
你有什么数据支持吗？你有没有将它与其他解决方案进行过比较？你的实现绝对明智且高效。不用担心。
public static List<List<Long>> getSubLists(List<Long> list, int size) {
    List<List<Long>> outer = new ArrayList<List<Long>>();

    List<Long> subList = new ArrayList<Long>(size);
    for (Long l : list) {
        subList.add(l);

        if (subList.size() >= size) {
            outer.add(subList);
            subList = new ArrayList<Long>(size);
        }
    }
    if (subList.size() > 0) {
        outer.add(subList);
    }
    return outer;
}