【JAVA】使用Java8 stream流对List进行遍历、过滤、查询、去重、排序、分组等

使用Java8 stream流对List进行遍历、过滤、查询、去重、排序等

Java8提供了Stream（流）处理集合的关键抽象概念，它可以对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
Stream API 借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性

—下面是使用Stream的常用方法的综合实例—

创建Student.class（学生的实体类）

package com.demoutils.entity;

import lombok.Data;

/**
 * @Desc
 * @Date 2020/10/18 9:06
 * @Version JDK 1.8
 **/
@Data
public class Student {

    /**
     * id 主键
     */
    private Integer Id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 年级
     */
    private String grade;

    /**
     * 班级
     */
    private String classNmae;

    public Student(Integer id, String name, Integer age, String grade, String classNmae) {
        Id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
        this.classNmae = classNmae;
    }

}

创建StudentService.class（模拟从数据库获取数据）。

package com.demoutils.service;

import com.demoutils.entity.Student;

import java.util.ArrayList;
import java.util.List;

/**
 * @Desc
 * @Date 2020/10/18 9:21
 * @Version JDK 1.8
 **/
public class StudentService {

    /**
     * 获取List数据
     * @return
     */
    public static List<Student> getStudentList(){
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student(1,"小明",16,"高一","3班"));
        studentList.add(new Student(1,"小李",18,"高三","1班"));
        studentList.add(new Student(1,"小王",16,"高一","2班"));
        studentList.add(new Student(1,"小徐",17,"高二","4班"));
        studentList.add(new Student(1,"小马",19,"高三","6班"));
        return studentList;
    }
}

1.1使用 forEach()遍历List

package com.demoutils;

import com.demoutils.entity.Student;
import com.demoutils.service.StudentService;

import java.util.List;

/**
 * @Desc
 * @Date 2020/10/18 9:13
 * @Version JDK 1.8
 **/
public class test {
    public static void main(String[] args) {
        // 获取 List 数据
        List<Student> studentList = StudentService.getStudentList();
        // 1.Java8 遍历List
        studentList.forEach(System.out ::println);
        // studentList.forEach(System.out ::println); 等同于 studentList.forEach(student -> {System.out.println(student);});
//        studentList.forEach(student -> {System.out.println(student);});

    }
}

1.2遍历结果：

2.1使用 filter() 过滤List数据。

获取年级为“高三”的数据

package com.demoutils;

import com.demoutils.entity.Student;
import com.demoutils.service.StudentService;

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

/**
 * @Desc
 * @Date 2020/10/18 9:57
 * @Version JDK 1.8
 **/
public class test1 {
    public static void main(String[] args) {
        // 获取 List 数据
        List<Student> studentList = StudentService.getStudentList();
        // 1.使用Java8 遍历List
        studentList.forEach(System.out::println);
        // 2.使用Java8 过滤List
        // 获取高三年级的学生信息
        System.out.println( "--------使用filter() 过滤获取高三年级的学生信息--------");
        List<Student> filterList = studentList.stream().filter(student -> student.getGrade() == "高三").collect(Collectors.toList());
        // 3.遍历过滤后的List
        filterList.forEach(System.out::println);
    }
}

2.2遍历结果：

3.1查询 findAny() 和 findFirst()

findFirst() 和 findAny() 都是获取列表中的第一条数据，但是findAny()操作，返回的元素是不确定的，对于同一个列表多次调用findAny()有可能会返回不同的值。使用findAny()是为了更高效的性能。如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行（parallelStream并行流）的情况，那就不能确保是第一个。

package com.demoutils;

import com.demoutils.entity.Student;
import com.demoutils.service.StudentService;

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

/**
 * @Desc
 * @Date 2020/10/18 10:09
 * @Version JDK 1.8
 **/
public class test2 {
    public static void main(String[] args) {
        // 获取 List 数据
        List<Student> studentList = StudentService.getStudentList();
        // 1.使用Java8 遍历List
        studentList.forEach(System.out::println);
        // 2.使用Java8 过滤List
        // 获取姓名为“小徐”的学生信息，如果没有找到则返回null
        System.out.println( "--------获取姓名为“小徐”的学生信息，如果没有找到则返回null--------");
        Student studentInfo = studentList.stream().filter(student -> "小徐".equals(student.getName())).findAny().orElse(null);
        System.out.println(studentInfo);
    }
}

3.2获取结果：

4.1 使用 distinct() 方法可以去除重复的数据。

package com.demoutils;

import com.demoutils.entity.Student;
import com.demoutils.service.StudentService;

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

/**
 * @Desc
 * @Date 2020/10/18 10:09
 * @Version JDK 1.8
 **/
public class test3 {
    public static void main(String[] args) {
        // 获取 List 数据
        List<Student> studentList = StudentService.getStudentList();
        // 1.使用Java8 遍历List
        studentList.forEach(System.out::println);
        // 2.使用Java8 对list去重
        // 获取年级列表去除重复的数据
        System.out.println("--------对list去重--------");
        // 第一种
        List<String> distintctList = studentList.stream().map(Student::getGrade).distinct().collect(Collectors.toList());
        distintctList.forEach(System.out::println);
        // 第二种
        List<Student> entities = entityList.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<Student>(Comparator.comparing(Student::getGrade))), ArrayList::new)
        );
        entities .forEach(System.out::println);
    }
}

4.2 去重的后结果

5.1 使用sorted()排序

package com.demoutils;

import com.demoutils.entity.Student;
import com.demoutils.service.StudentService;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Desc
 * @Date 2020/10/18 10:09
 * @Version JDK 1.8
 **/
public class test4 {
    public static void main(String[] args) {
        // 获取 List 数据
        List<Student> studentList = StudentService.getStudentList();
        // 1.使用Java8 遍历List
        studentList.forEach(System.out::println);
        // 2.使用Java8 sorted()对list排序
        // 根据年龄排序（升序）
        System.out.println("--------对list排序--------");
        System.out.println("升序:");
        // 升序
        List<Student> sortenList = studentList.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
        sortenList.forEach(System.out::println);
        System.out.println("降序:");
        // 降序
        List<Student> sortenListDesc = studentList.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
        sortenListDesc.forEach(System.out::println);
    }
}

5.2 排序结果：

6.1 分组

package com.demoutils;

import com.demoutils.entity.Student;
import com.demoutils.service.StudentService;

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

/**
 * @Desc
 * @Date 2020/10/18 10:51
 * @Version JDK 1.8
 **/
public class test5 {
    public static void main(String[] args) {
        // 获取 List 数据
        List<Student> studentList = StudentService.getStudentList();
        // 1.使用Java8 遍历List
        studentList.forEach(System.out::println);
        // 2.使用Java8 groupingBy对list分组
        // 根据年年级分组
        System.out.println("--------对list分组--------");
        Map<String, List<Student>> groupListMap = studentList.stream().collect(Collectors.groupingBy(Student::getGrade));
        //遍历分组后的结果
        groupListMap.forEach((key, value) -> {
            System.out.println(key + "：");
            value.forEach(System.out::println);
            System.out.println("--------------------------------------------------------------------------");
        });
        System.out.println(groupListMap);
    }
}

6.2 分组结果