在前两天的工作中遇到这样一一个场景:我查询出来了两组List集合的数据,需要将一个集合中得对象的数据赋值给另一个集合对象对应的字段,两个对象中有一个共同的id字段,首相我想到的用for循环加上if判断的方式来完成,但是总觉得这样写不够优雅;然候又想到了通过stream流的方式来实现,而且在复杂的应用场景下或者在数据量大的情况下使用stream流会有更高的效率,因为stream是多线程并行操作的.当然在业务简单而且数据量也不大的情况下还是不同的for循环加if判断效率高一些,比如我接下来的测试数据.

定义两个类,有个Student类和一个Name类,最终目的就是将Name中的姓名赋值给Student类中的name字段.

public class Student {
    private int id;
    private String name;
    private int age;
    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
public class Name {
    private int id;
    private String name;
    public Name(int id, String name) {
        this.id = id;
        this.name = name;
创建两个集合进并封装数据
 
     * 封装Student集合
    private static List<Student> getStudentList() {
        List<Student> students = new ArrayList<>();
        students.add(new Student(1, null, 18));
        students.add(new Student(2, null, 20));
        students.add(new Student(3, null, 23));
        students.add(new Student(4, null, 20));
        students.add(new Student(5, null, 17));
        students.add(new Student(6, null, 15));
        return students;
     * 封装Name集合
    private static List<Name> getNameList() {
        List<Name> names = new ArrayList<>();
        names.add(new Name(1, "张三"));
        names.add(new Name(2, "李四"));
        names.add(new Name(3, "王五"));
        names.add(new Name(4, "赵六"));
        names.add(new Name(5, "田七"));
        names.add(new Name(6, "马八"));
        return names;
 然后下面是使用stream流的核心代码
 
     * 使用流对象的方法插入数据
    private static List<Student> methodA(List<Student> students, List<Name> names) {
        List<Student> studentList = students.stream().map(student -> {
            return names.stream().filter(name -> {        //条件判断
                return student.getId() == name.getId();
            }).map(name -> {
                student.setName(name.getName());
                return student;                            //返回的结果
            }).collect(Collectors.toList());
        }).flatMap(List::stream).collect(Collectors.toList());//设置返回结果类型
        return studentList;
输出结果:可以看到结果是正常的,id都匹配上了对应的name
 
[Student{id=1, name='张三', age=18}, Student{id=2, name='李四', age=20}, Student{id=3, name='王五', age=23}, Student{id=4, name='赵六', age=20}, Student{id=5, name='田七', age=17}, Student{id=6, name='马八', age=15}]
为了测试一下这种简单场景下两种方法的效率,于是将for循环加if判断的也加上了
 
     * 循环遍历插入数据
    private static List<Student> methodB(List<Student> students, List<Name> names) {
        for (Student student : students) {
            for (Name name : names) {
                if (student.getId() == name.getId()) {
                    student.setName(name.getName());
        return students;
public static void main(String[] args) {
        List<Student> students = getStudentList();
        List<Name> names = getNameList();
        Date date1 = new Date();
        long startTime = date1.getTime();
        //使用stream流方式
        List<Student> studentList = methodA(students, names);
        //使用for循环方式
        //List<Student> studentList = methodB(students, names);
        Date date2 = new Date();
        long endTime = date2.getTime();
        System.out.println("所用时长: " + (endTime - startTime));
        System.out.println("输出结果: " + studentList);
以下是两种方式的对比,可以看出来对比还是很明显的,在简单的场景下使用for循环的效率要更高一些.
 
 在数据量大的情况下还是stream更给力一些,可以参考这位博主的测试:
 
https://www.xyhtml5.com/5302.htmlhttps://www.xyhtml5.com/5302.html
                    在前两天的工作中遇到这样一一个场景:我查询出来了两组List集合的数据,需要将一个集合中得对象的数据赋值给另一个集合对象对应的字段,两个对象中有一个共同的id字段,首相我想到的用for循环加上if判断的方式来完成,但是总觉得这样写不够优雅;然候又想到了通过stream流的方式来实现,而且在复杂的应用场景下或者在数据量大的情况下使用stream流会有更高的效率,因为stream是多线程并行操作的.当然在业务简单而且数据量也不大的情况下还是不同的for循环加if判断效率高一些,比如我接下来的测试数据.定义两
				
public static void main(String[] args) {
    List<String> list1 = new ArrayList<String>();
     list1.add("1");
   list1.add("2");
   list1.add("3");
   list1.add("5");
   list1.add("6");
				
java使用stream实现list中对象属性的合并:
根据两个List中的某个相同字段合并成一条List，包含两个List中的字段
目录一、前言二、示例示例1：java8 合并两个 list＜map＞示例2：java8 合并两个 list＜T＞示例3：java8 合并两个 list＜T＞，集合个数前者小于后者，要后者示例4：java8 合并两个 list＜T＞，集合个数前者大于后者，要后者
为什么要用Lambda表达式和Stream流做集合的处理？ 因为效率高、代码简洁、高端大气上档次！
				
JAVA 使用java8新特性使用 stream() 把list赋值到另一个list中
 List<StaffEducation> eduList = JSON.parseArray(JSON.toJSONString(data), StaffEducation.class);
 eduList = eduList.stream().map(item->{
  item.setAcademic(getRedisValue("EDUCATIONAI_HISTORY",item.getAca
				
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;
@Slf4j
public class ListUtils {
				
Java一个List中的部分字段赋值给另一个List:
当接口中需要使用一个list中的部分值的作为最终结果，可以使用下面的方式进行简单构造，之前喜欢用迭代器，这种方式更加简洁。
 List<KeyWordSearchResponse> companyNameList = qccService.findCompanyNameList(keyword);
        return companyNameList.stream().map(result -> new CompanyName
				
Streams
   lambda表达式允许我们在不创建新类的情况下传递行为，从而帮助我们写出干净简洁的代码。lambda表达式是一种简单的语法结构，它通过使用函数式接口来帮助开发者简单明了的传递意图。
   Stream是java8引入的一个重度使用lambda表达式的API。Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高...
				
stream类处理集合1. 将集合类型进行一个转换（map）2. 过滤集合中符合条件的元素，并返回一个新集合（filter）3. 循环集合进行操作（forEach）
简单的使用方法，是将list转为流进行处理
1. 将集合类型进行一个转换（map）
// 1.将对象包装为返回类
List<User> dataList = UserMapper.selectList(null);
List<UserVO> voList = dataList.stream().map(data -&gt
List<List<String>> collection = new ArrayList<>();
collection.add(Arrays.asList("hello", "world"));
collection.add(Arrays.asList("Java", "programming"));
List<String> result = collection.stream()
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
System.out.println(result);
// Output: [hello, world, Java, programming]
注意：本AI为CSDN开发的ChitGPT，与ChatGPT及OpenAI无关，如有其他问题，可继续提问。