Java：List转List （用stream实现）

//实体类public class Student {privateString no;//学号privateString name;//姓名//构造方法忽略//set、get 方法忽略}public class Teacher{privateString no;//教师号privateString name; //姓名}一、List<Object> 转 List<String&

文章共6,115字 · 阅读需要大约21分钟

一键AI生成摘要，助你高效阅读

问答

seniorShen

46270人浏览 · 2021-09-13 13:02:52

seniorShen · 2021-09-13 13:02:52 发布

//实体类
public class Student {
    private  String no;  //学号
    private  String name;	//姓名
    //构造方法忽略
    //set、get 方法忽略
}
public class Teacher{
    private  String no;  //教师号
    private  String name; //姓名
}
public class Subject{
    private  String no;  //学科编码
    private  String name; //学科名称
    private  List<Student> studnetList; //报名该学科的学生集合
}

一、`List<Object>` 转 `List<String>`（不过滤/过滤）(不去重/去重)

//声明一个List集合
List<Student> list = new ArrayList();  
	 list.add(new Student("1001", "小A"));  
	 list.add(new Student("1001", "小B"));//学号重复（下面特殊处理）
	 list.add(new Student("1002", "小C"));
	 list.add(new Student("1003", "小D"));
       
//将List转换List 【提取1个属性】【不过滤，不去重】
List<String> stringList = 
     list.stream().map( Student::getNo ).collect(Collectors.toList());
或
List<String> stringList = list.stream().map( obj -> obj.getNo() ).collect(Collectors.toList());
     
//将List转换List 【提取1个属性】【不过滤，去重】 
List<String> stringList = 
     list.stream().map( Student::getNo ).distinct().collect(Collectors.toList());

//将List转换List 【提取1个属性】【过滤，不去重】 （备注：过滤判断可根据自己需求写，公式可多条件判断）
List<String> stringList = 
     list.stream().map( Student::getNo ).filter(no -> !"".equals(no)).collect(Collectors.toList());

//将List转换List 【提取1个属性】【过滤，去重】 （备注：过滤判断可根据自己需求写，公式可多条件判断）
List<String> stringList = 
     list.stream().map( Student::getNo ).filter(no -> !"".equals(no)).distinct().collect(Collectors.toList());


//将List转换List 【提取多个属性】【不过滤，不去重】
List<String> stringList = 
     list.stream().map( obj -> obj.getNo() + "_" + obj.getName() ).collect(Collectors.toList());
     
。。。。。。

二、`List<Object>` 转 `List<Object>` (返回对象本身) （不过滤/过滤)(不去重/去重)

//声明一个List集合
List<Student> list = new ArrayList();  
	 list.add(new Student("1001", "小A"));  
	 list.add(new Student("1001", "小B"));//学号重复（下面特殊处理）
	 list.add(new Student("1002", "小C"));
	 list.add(new Student("1003", "小D"));
       
//将List转换List 【不过滤，去重】
List<Student> studentList = 
	 list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(obj -> obj.getNo()))), ArrayList::new));

//将List转换List 【过滤，不去重】
List<Student> studentList =
	 list.stream().filter(
             obj -> "小C".equals(obj.getName())
     ).collect(Collectors.toList());

//将List转换List 【过滤，去重】
List<Student> studentList =
	 list.stream().filter(
             obj -> "小C".equals(obj.getName())
     ).collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(obj -> obj.getNo()))), ArrayList::new));

三、`List<Object>` 转 `List<Object>` (返回对象本身) （排序)

//声明一个List集合
List<Student> list = new ArrayList();  
	 list.add(new Student("1001", "小A"));  
	 list.add(new Student("1001", "小B"));
	 list.add(new Student("1002", "小C"));
	 list.add(new Student("1003", "小D"));
       
//将List转换List 【不过滤，不去重，排序】 （根据对象中1个属性：升序）  (本案例：根据学号升序)
List<Student> studentList =
	 list.stream().sorted(Comparator.comparing(Student::getNo)).collect(Collectors.toList());

//将List转换List 【不过滤，不去重，排序】 （根据对象中多个属性：升序）   (本案例：根据学号升序，学号相同根据年龄升序)
List<Student> studentList =
	 list.stream().sorted(Comparator.comparing(Student::getNo).thenComparing(Student::getAge)).collect(Collectors.toList());


//将List转换List 【不过滤，不去重，排序】 （根据对象中1个属性：降序）    (本案例：根据学号降序)
List<Student> studentList =
	list.stream().sorted(Comparator.comparing(Student::getNo).reversed()).collect(Collectors.toList());

//将List转换List 【不过滤，不去重，排序】 （根据对象中多个属性：降序）   (本案例：根据学号降序，学号相同根据年龄降序)
List<Student> studentList =
	list.stream().sorted(Comparator.comparing(Student::getNo).thenComparing(Student::getAge).reversed()).collect(Collectors.toList());

四、`List<Object>` 转 `List<Object>` (返回对象本身) （取有限数)

//将List转换List 【不过滤，不去重，排序，取有限数】  (本案例：取年龄最小2位)
List<Student> studentList =
	 list.stream().sorted(Comparator.comparing(Student::getAge)).limit(2).collect(Collectors.toList());

//将List转换List 【不过滤，不去重，排序，取有限数】  (本案例：取年龄最大2位)
List<Student> studentList =
	list.stream().sorted(Comparator.comparing(Student::getAge).reversed()).limit(2).collect(Collectors.toList());

【备注】求集合中某个字段的和、平均、最大、最小，请见我另一个文章： https://blog.csdn.net/SeniorShen/article/details/120280293

五、`List<Object1>` 转 `List<Object2>` (返回另一个对象)（不过滤/过滤)(不去重)

//声明一个List集合 
List<Student> list = new ArrayList();
	list.add(new Student("1001", "小A"));
	list.add(new Student("1001", "小B"));
	list.add(new Student("1002", "小C"));
	list.add(new Student("1003", "小D"));

//将List转换List   【不过滤，不去重】 
List<Teacher> teacherList = 
	list.stream().map(
		stu -> {
            Teacher teacher = new Teacher();
            teacher.setNo(stu.getNo());
            teacher.setName(stu.getName());
            return teacher;
        }
   ).collect(Collectors.toList());


//将List转换List  【过滤，不去重】 
List<Teacher> teacherList2 =
	 list.stream().filter( stu -> StringUtils.isNotBlank(stu.getName()) ).map(
        	  stu -> {
              Teacher teacher = new Teacher();
              teacher.setNo(stu.getNo());
              teacher.setName(stu.getName());
              return teacher;
        	  }
     ).collect(Collectors.toList());

六、`List<Object1>` 转 `List<Object2>` (返回另一个对象) （多重集合，取里面集合，并合并)

//声明一个List集合
List<Student> list = new ArrayList();  
	 list.add(new Student("1001", "小A"));  
	 list.add(new Student("1001", "小B"));
	 list.add(new Student("1002", "小C"));
	 list.add(new Student("1003", "小D"));
List<Subject> subjectList = new ArrayList<>();
        Subject subject1 = new Subject();
        subject1.setId(1);
        subject1.setStudentList(studentList);
		subjectList.add(subject1);
		
        Subject subject2 = new Subject();
        subject1.setId(2);
        subject1.setStudentList(studentList);
        subjectList.add(subject2);

        Subject subject3 = new Subject();
        subject1.setId(3);
        subject1.setStudentList(studentList);
        subjectList.add(subject3);
  
//将List转换List 【flatMap取集合中的集合 再合并】  (本案例：把所有科目下的报名学生，取出来，并合并。注意：学生没有去重)
List<Student> studentList =
	 subjectList.stream().flatMap( item -> item.getStudentList().stream() ).collect(Collectors.toList());

七、`List<Object>` 转 `List<String>` （多重集合，取里面集合，并合并。再取一个字段)

//声明一个List集合
List<Student> list = new ArrayList();  
	 list.add(new Student("1001", "小A"));  
	 list.add(new Student("1001", "小B"));
	 list.add(new Student("1002", "小C"));
	 list.add(new Student("1003", "小D"));
List<Subject> subjectList = new ArrayList<>();
        Subject subject1 = new Subject();
        subject1.setId(1);
        subject1.setStudentList(studentList);
		subjectList.add(subject1);
		
        Subject subject2 = new Subject();
        subject1.setId(2);
        subject1.setStudentList(studentList);
        subjectList.add(subject2);

        Subject subject3 = new Subject();
        subject1.setId(3);
        subject1.setStudentList(studentList);
        subjectList.add(subject3);
  
//将List转换List 【flatMap取集合中的集合 再合并】  (本案例：把所有科目下的报名学生，取出来，并合并。再取学生集合中的某个字段)
List<String> stringList =
	 subjectList.stream().flatMap( item -> item.getStudentList().stream() ).map(Student::getNo).collect(Collectors.toList());