【Java 开发实例】Java List分片方法

---

一、概述

    在实际开发过程中，我们可能会遇到一条批量插入的SQL语句出现 SQL过大超过MySQL数据库的限制。解决方案呢也有两个，一个是修改下 MySQL的SQL语句的大小限制，另一个呢是去将 批量的数据进行分片切割。而这两个方案中我认为第二个方案需要更加稳妥。

方案一：

• 优点：不需要调整业务逻辑代码，直接修改MySQL数据库的配置重启即可。
• 缺点：可能修改之后仍会出现SQL语句过大的问题。

方案二：

• 优点：分批次数据插入，性能相比较好。
• 缺点：需要调整业务代码。

而对方案二，我们可以有如下工具对 List 集合进行切割分片处理：

在 Java 中，分片的常见实现方法有以下几种：

1. 使用 Google 的 Guava 框架实现分片；
2. 使用 Apache 的 commons 框架实现分片；
3. 使用国产神级框架 Hutool 实现分片；
4. 使用 JDK 8 中提供 Stream 实现分片；
5. 自定义分片功能。

二、具体方案

（1）Google Guava 实现

① 引入 Google Guava 的依赖包

<!-- google guava 工具类 -->
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

② 使用工具类 Lists.partition 方法

import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;

/**
 * Guava 分片
 */
public class PartitionByGuavaExample {
    // 原集合
    private static final List<String> OLD_LIST = 
        Arrays.asList("唐僧,悟空,八戒,沙僧,曹操,刘备,孙权".split(","));

    public static void main(String[] args) {
        // 集合分片
        List<List<String>> newList = Lists.partition(OLD_LIST, 3);
        // 打印分片集合
        newList.forEach(i -> {
            System.out.println("集合长度：" + i.size());
        });
    }
}

③ 结果

（2）Apache Commons

① 引入依赖包

<!-- apache 集合工具类 -->
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

② 使用 ListUtils.partition 方法

import org.apache.commons.collections4.ListUtils;

import java.util.Arrays;
import java.util.List;

/**
 * commons.collections4 集合分片
 */
public class PartitionExample {
    // 原集合
    private static final List<String> OLD_LIST = 
        Arrays.asList("唐僧,悟空,八戒,沙僧,曹操,刘备,孙权".split(","));

    public static void main(String[] args) {
        // 集合分片
        List<List<String>> newList = ListUtils.partition(OLD_LIST, 3);
        newList.forEach(i -> {
            System.out.println("集合长度：" + i.size());
        });
    }
}

③ 结果

（3）Hutool 实现

① 引入依赖包

<!-- 工具类 hutool -->
<!-- https://mvnrepository.com/artifact/cn.hutool/hutool-all -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.14</version>
</dependency>

② 使用 ListUtil.partition 实现

import cn.hutool.core.collection.ListUtil;

import java.util.Arrays;
import java.util.List;

public class PartitionByHutoolExample {
    // 原集合
    private static final List<String> OLD_LIST = 
        Arrays.asList("唐僧,悟空,八戒,沙僧,曹操,刘备,孙权".split(","));

    public static void main(String[] args) {
        // 分片处理
        List<List<String>> newList = ListUtil.partition(OLD_LIST, 3);
        newList.forEach(i -> {
            System.out.println("集合长度：" + i.size());
        });
    }
}

③ 结果

（4）JDK 8 Stream

① 代码示例

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * JDK Stream Partition
 */
public class PartitionByStreamExample {
    // 原集合
    private static final List<Integer> OLD_LIST = Arrays.asList(1, 2, 3, 4, 5, 6);

    public static void main(String[] args) {
        // 集合分片：将大于 3 和小于等于 3 的数据分别分为两组
        Map<Boolean, List<Integer>> newMap = OLD_LIST.stream().collect(
            Collectors.partitioningBy(i -> i > 3)
        );
        // 打印结果
        System.out.println(newMap);
    }
}

② 结果

③ 优缺点     此方式的优点的无需添加任何框架，但缺点是只能实现简单的分片（将一个 List 分为两个），并且要有明确的分片条件。比如本篇案例中设置的分片条件就是数组是否大于 3，如果大于 3 就会被归为一组，否则就会被分到另一组。

（5）自定义分片

使用 集合中的 subList 方法。

① 代码示例

import java.util.Arrays;
import java.util.List;

public class App {
    private static final List<String> _OLD_LIST = 
        Arrays.asList("唐僧,悟空,八戒,沙僧,曹操,刘备,孙权".split(","));

    public static void main(String[] args) {
        // 集合分隔
        List<String> list = _OLD_LIST.subList(0, 3);
        // 打印集合中的元素
        list.forEach(i -> {
            System.out.println(i);
        });
    }
}

② 结果

总结

    如果是简单的分片就可以考虑使用 JDK 的 Stream 或者是 List 内置的 subList 方法来实现分片功能了。

扩展

案例：复杂的集合根据属性分组，保证分组的顺序性。

LinkedHashMap<String, List<ProcessDetails>> resultSort;

//根据开始日期排序, groupBy字段分组返回类型修改为LinkedHashMap，否则乱序
resultSort = result.stream()
    .sorted(Comparator.comparing(ProcessDetails::getBeginTime))
    .collect(Collectors.groupingBy(
        ProcessDetails::getGroupBy, // 对象属性
        LinkedHashMap::new, // 每个小组数据存放的容器
        Collectors.toList() // 最终Stream转成集合
    )
);

---

至此，感谢阅读！🙏