Java Stream相关用法

雨点打透心脏的1/2处 2023-10-13 16:49 33阅读 0赞

Java Stream排序是对集合中的元素进行排序的重要方式，而Java Stream本身就是一种优雅而高效的处理集合的方法。本文将从多个方面对Java Stream排序做详细的阐述，包括排序方法、自定义排序、对象排序等等。

### 一、排序方法 ###

Java Stream提供了多种对集合进行排序的方式，如sorted()、sorted(Comparator)、distinct()等等。其中，sorted()方法是最常用的排序方法之一。

**sorted()方法** 无需传入参数，会自动使用元素的自然顺序进行排序。例如对一个Integer类型的集合进行排序：

//初始列表
    List<Integer> list = Arrays.asList(3,2,1,4,5);
    
    //排序后的列表
    List<Integer> sortedList = list.stream().sorted().collect(Collectors.toList());
    
    //打印输出排序后的结果 1 2 3 4 5
    sortedList.forEach(System.out::print);

**sorted(Comparator)方法**需要传入一个Comparator对象，该对象定义了元素的排序规则。

例如按照元素大小降序排列：

List<Integer> list = Arrays.asList(3,2,1,4,5);
    list.stream().sorted((x, y) -> y - x).forEach(System.out::print); // 5 4 3 2 1

### 二、自定义排序 ###

如果元素的类型是自定义的类，而不是基本类型或字符串类型，我们可以使用sorted(Comparator)方法，并传入自定义的比较器来排序。例如，对一个Person类对象的集合，按照年龄升序排列：

List<Person> personList = Arrays.asList(
        new Person("Jenny", 20),
        new Person("Tom", 19),
        new Person("Mike", 24),
        new Person("Amy", 18)
    );
    
    
    // Person的第一个属性为名称（name）, 第二个属性为年龄（age）
    
    List<Person> sortedList = personList.stream()
    .sorted(Comparator.comparing(Person::getAge))
    .collect(Collectors.toList());
    
    // 排序结果为： Amy --> Tom --> Jenny --> Mike

``

``

### 三、对象单一属性排序 ###

有时我们需要对一个对象的某个属性进行排序，而不是整个对象。

例如，对一个班级里有多个学生，对学生按照学号进行排序：

List<Student> studentList = Arrays.asList(
        new Student("Tom", 5),
        new Student("Jenny", 1),
        new Student("Mike", 3),
        new Student("Amy", 2)
    ));
    
    // Student的第一个属性为名称（name）, 第二个属性为学号（number）
    
    List<Student> sortedStudentList = studentList.stream()
    .sorted(Comparator.comparing(Student::getNumber))
    .collect(Collectors.toList());
    
    // 排序结果为： Jenny --> Amy --> Mike  --> Tom

``

### 四、多层次排序（对象多属性排序） ###

有时我们需要按照多个属性进行排序，例如按照学号升序排列，如果学号相同，则按照姓名升序排列：

List<Student> studentList = Arrays.asList(
        new Student("Tom", 5),
        new Student("Jenny", 1),
        new Student("Mike", 3),
        new Student("Amy", 2)
    ));
    
    List<Student> sortedStudents = students.stream().sorted(
    Comparator.comparing(Student::getNumber).thenComparing(Student::getName)
    ).collect(Collectors.toList());
    
    // 排序结果为： Jenny --> Amy --> Mike  --> Tom

````

### 五、倒序排列 ###

如果需要对集合进行倒序排列，可以使用sorted(Comparator)方法，传入一个自定义的Comparator对象，来实现倒序排列。例如，将原本按照学号升序排列的学生集合进行倒序排列：

List<Student> studentList = Arrays.asList(
        new Student("Tom", 5),
        new Student("Jenny", 1),
        new Student("Mike", 3),
        new Student("Amy", 2)
    ));
    
    //按学号对学生进行倒序排序
    List<Student> sortedStudents = studentList().stream().sorted(
    Comparator.comparing(Student::getNumber).reversed()
    ).collect(Collectors.toList());
    
    // 排序结果为： Tom --> Mike --> Amy --> Jenny

``

### 六、去重操作 ###

Java Stream提供了distinct()方法，用于去重。它会返回一个去重后的集合，不会改变原集合。例如，有一个包含重复元素的集合：

#### 6.1 元素列表去重 ####

List<Integer> list = Arrays.asList(1,2,3,2,1,4,5,3);
    list.stream().distinct().forEach(System.out::print); // 1 2 3 4 5

#### 6.2 按对象单一属性去重 ####

//按学生名称去重
    List<Student> distintStudents = students.stream().collect(
                    Collectors.collectingAndThen(Collectors.toCollection(
                            () -> new TreeSet<>(Comparator.comparing(s -> s.getName()))), ArrayList::new)
            );

#### 6.3 按对象多属性去重 ####

//根据name与number进行去重
    List<Student> distinctStudents = students.stream().collect(
                    Collectors.collectingAndThen(Collectors.toCollection(
                            () -> new TreeSet<>(Comparator.comparing(p -> p.getName()+";"+p.getNumber()))), ArrayList::new)
            );

### 七、filter 过滤 ###

List<Student> studentList = Arrays.asList(
        new Student("Tom", 5),
        new Student("Jenny", 1),
        new Student("Mike", 3),
        new Student("Amy", 2)
    ));
    
    List<Student> filterStudents = students.stream().filter(s -> s.getNumber()>3).collect(Collectors.toList());
    
    //租户学生列表 filterStudents只剩学生Tom