在开发中，可能经常使用mysql的各种join操作，当数据量小的时候，这种操作很ok。但当数据量达到几百万甚至几千万时，多表连接会出现耗时过大的问题。对于这种问题，可以将大表join操作拆分成小的表查询，再到代码层进行数据的整合，再传递给前端。

比如以下场景：教室和学生的一对多关系

• 一个教室有多个学生
• 一个学生只能存在于一个教室

假如我们需要做以下查询：

1. 查出每个教室的所有学生

操作步骤：

1. 查出所有教室
2. 拿到教室的id集合roomIdList
3. 使用in操作，查出属于该roomIdList的所有学生集合studentList
4. 将studentList进行分类，分属到每一个教室下

2. 查出每个学生所属的教室的教室名称

相当于

select student.*,classroom.name from student stu left join classroom room on stu.room_id = room.id;

操作步骤：

1. 查出所有学生
2. 拿到所有学生所属的roomId集合roomIdList，并且进行重复过滤
3. 使用in 查出roomIdList里面的教室classroomList
4. 根据stu.room_id = room.id进行关联，将room.name设置到每一个学生的属性中

以下为具体使用：（模拟部分数据）

    public static void main(String[] args) {
        boolean flag = true;

        List<Student> studentList = new ArrayList<>();
        List<Classroom> classroomList = new ArrayList<>();

        Classroom classroom = new Classroom();
        classroom.setRoomId(111);
        classroom.setRoomName("name+" + 111);
        Classroom classroom2 = new Classroom();
        classroom2.setRoomId(222);
        classroom2.setRoomName("name+" + 222);

        classroomList.add(classroom);
        classroomList.add(classroom2);

        Student student = new Student();
        for (int i = 0; i < 10; i++) {
            student = new Student();
            student.setRoomId(i);
            student.setName("name+" + i);

            if (flag) {
                student.setRoomId(classroom.getRoomId());
            } else {
                student.setRoomId(classroom2.getRoomId());
            }
            flag = !flag;

            studentList.add(student);
        }

        //为每个学生赋值他所在的教室
        MergeUtil.merge(studentList,classroomList,(stu,room) -> stu.getRoomId() == room.getRoomId(),(stu,room) -> stu.setRoomName(room.getRoomName()));

        studentList.forEach((data) -> {
            System.out.println(data.toString());
        });

        //为每个教室，赋值属于他的学生
        classroomList.stream().forEach(room -> {
            List dataList = studentList.stream().filter(student1 -> student1.getRoomId() == room.getRoomId() ).collect(Collectors.toList());
            room.setStudentList(dataList);
        });
//
        System.out.println(classroomList);

        // 使用工具类
        //为每个教室，赋值属于他的学生
        MergeUtil.mergeList(classroomList,studentList,
                (classroom1, student1) -> classroom1.getRoomId() == student1.getRoomId(),
                (classroom1, students) -> classroom1.setStudentList(students));

        System.out.println(classroomList);


    }

如果不使用java8的filter操作，使用for循环自己写，操作如下

 HashMap<Integer ,List<Student>> hashMap = new HashMap<>();
        for (Student stu:studentList){
            Integer roomId = stu.getRoomId();
            List<Student> tempList;
            if (hashMap.containsKey(roomId)){
                tempList = hashMap.get(roomId);
            }else {
                tempList = new ArrayList();
            }
            tempList.add(stu);
            hashMap.put(roomId,tempList);
        }
        for (Classroom room:classroomList){
            room.setStudentList(hashMap.get(room.getRoomId()));
        }

但经过试验，在100w个student的情况下进行测试，使用java8的filter操作耗时比自己for循环+hashMap要快一半左右， 所以比较建议使用filter；

最后贴上这部分操作要用到的工具类：

public class MergeUtil {

    /**
     * 把sourceList里面的一些属性合并到targetList里面
     * 基于testFunction的条件,合入逻辑实现为biConsumer
     *
     * @param targetList
     * @param sourceList
     * @param testFunction
     * @param biConsumer
     * @param <T>
     * @param <S>
     */
    public static <T, S> void merge(List<T> targetList, List<S> sourceList, BiFunction<? super T, ? super S, Boolean> testFunction,
                                    BiConsumer<? super T, ? super S> biConsumer) {

        targetList.forEach((t)->{
            Optional<S> optional = sourceList.stream().filter(s->testFunction.apply(t, s)).findFirst();
            if (optional.isPresent()) {
                biConsumer.accept(t, optional.get());
            }
        });

    }

    /**
     * 把sourceList里面的一些item分类合并到targetList的每一个item里面
     *
     * @param targetList
     * @param sourceList
     * @param testFunction
     * @param biConsumer
     * @param <T>
     * @param <S>
     */
    public static <T, S> void mergeList(List<T> targetList, List<S> sourceList, BiFunction<? super T, ? super S, Boolean> testFunction,
                                    BiConsumer<? super T, ? super List<S>> biConsumer) {

        targetList.forEach((t)->{
            List<S> dataList = sourceList.stream().filter(s->testFunction.apply(t, s)).collect(Collectors.toList());
            Optional<List<S>> optional = Optional.of(dataList);
            if (optional.isPresent()) {
                biConsumer.accept(t, optional.get());
            }
        });
    }
}