写在前面

    今天碰到一个需求,定时任务,批量从表里取数据并做一些其他操作然后再存表,每次取1000条,由于计算过程比较耗时所以要起多个线程同时跑,需要将List按照指定大小等分,如每100条数据起一个线程,若最后剩余一份不到100,也放到一个线程里,网络上的实现方法有很多,我测试之后理出三种相对比较好的实现方法,如下:

/*第一种方法 思路比较简单,遍历list,将元素添加到subList,
*每当i到pageSize的时候,将subList添加到listArray并新建,subList
*/
public static <T> List<List<T>> splitList1(List<T> list, int pageSize) {

    List<List<T>> listArray = new ArrayList<List<T>>();

    List<T> subList = null;

    for (int i = 0; i < list.size(); i++) {

        if (i % pageSize == 0) {

            subList = new ArrayList<T>();

            listArray.add(subList);

        }

        subList.add(list.get(i));

    }

    return listArray;

}

/*第二种方法 思路和方法1差不多,遍历list,将元素添加到subList,
*当subList的size等于pageSize的时候,将subList添加到listArray并新建subList
*/
public static <T> List<List<T>> splitList2(List<T> list, int pageSize) {

    List<List<T>> listArray = new ArrayList<List<T>>();

    ArrayList<T> subList = new ArrayList<T>();
    for (T x : list) {
        subList.add(x);
        if (pageSize == subList.size()) {
            listArray.add(subList);
            subList = new ArrayList<T>();
        }
    }

    if (0 != subList.size()) {
        listArray.add(subList);
    }

    return listArray;
}

/*第三种方法,用到了java list自带的方法subList,
*先判断list的size＜pageSize的情况,然后利用subList方法循环切块
*/
public static <T> List<List<T>> splitList3(List<T> list, int pageSize) {
    List<List<T>> listArray = new ArrayList<List<T>>();
    if (list != null && pageSize > 0) {
        int listSize = list.size();
        if (listSize <= pageSize) {
            listArray.add(list);
            return listArray;
        }
        int batchSize = listSize / pageSize;
        int remain = listSize % pageSize;

        for (int i = 0; i < batchSize; i++) {
            int fromIndex = i * pageSize;
            int toIndex = fromIndex + pageSize;
            listArray.add(list.subList(fromIndex, toIndex));
        }
        if (remain > 0) {
            listArray.add(list.subList(listSize - remain, listSize));
        }
    }
    return listArray;
}

    我从list的subList方法中得到灵感,也实现了一种方式,可读性稍好一些,如下:

/*我的思路也比较简单,就是遍历加切块,
*若toIndex大于list的size说明已越界,需要将toIndex设为list的size值
*/
public static <T> List<List<T>> splitList4(List<T> list, int pageSize) {
    List<List<T>> listArray = new ArrayList<List<T>>();
    for (int i = 0; i < list.size(); i+=pageSize) {
        int toIndex = i + pageSize>list.size()?list.size():i+pageSize;
        listArray.add(list.subList(i, toIndex));
    }
    return listArray;
}

    以上四种方法经过测试都可实现功能,如果List的size比较小,几十,几百,应该效率都差不多,那如果list的size很大,比如10万,100万,那么以上四种方式,哪一种效率最高呢,我简单测试了一下,pageSize设为20,list的size分别为10万,和100万,分别跑100次,然后取平均值,如下:

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();

    for (int i = 0; i < 100000; i++) {
        list.add(i);
    }

    Long time1 = System.currentTimeMillis();
    for (int i = 0; i <100 ; i++) {
        splitList1(list, 20);
    }
    Long time2 = System.currentTimeMillis();
    for (int i = 0; i <100 ; i++) {
        splitList2(list, 20);
    }
    Long time3 = System.currentTimeMillis();
    for (int i = 0; i <100 ; i++) {
        splitList3(list, 20);
    }
    Long time4 = System.currentTimeMillis();
    for (int i = 0; i <100 ; i++) {
        splitList3(list, 20);
    }
    Long time5 = System.currentTimeMillis();


    System.out.println("list的size为10000,执行100次,平均时间为:");
    System.out.println("方法1--->:" + (time2 - time1)/100.0+"ms");
    System.out.println("方法2--->:" + (time3 - time2)/100.0+"ms");
    System.out.println("方法3--->:" + (time4 - time3)/100.0+"ms");
    System.out.println("方法4--->:" + (time5 - time4)/100.0+"ms");


}

执行结果为

ist的size为100000,执行100次,平均时间为:
方法1--->:2.86ms
方法2--->:2.08ms
方法3--->:0.66ms
方法4--->:0.43ms

    从执行结果中可以看到前两种方法效率,明显不如后两种,后两种时间相差不大,但看起来似乎方法4更好一些,再将list的size设为100万时,执行结果为:

list的size为1000000,执行100次,平均时间为:
方法1--->:21.65ms
方法2--->:14.09ms
方法3--->:0.95ms
方法4--->:0.57ms

    size设为1000万时,执行结果为:

list的size为1000000,执行100次,平均时间为:
方法1--->:138.39ms
方法2--->:112.86ms
方法3--->:6.63ms
方法4--->:6.07ms

    综上所看,方法4的效率稍好于方法3,方法2稍好于方法1,但3和4的效率比1和2要高出一个数量级,主要是因为方法1和2,是逐个设置的,很明显不如subList,在这里推荐方法4,代码简洁,稍微理解下,可读性也不错.