Java8流式操作——中间操作

什么是中间操作？

对数据进行过滤、排序……操作

---

方法

● filter:过滤
● distinct:去重（去除集合中重复的元素）
● sorted:排序
● skip:跳过。从前往后数，跳过前xxx个元素，保留剩下的元素
● limit:限制，只取流中前指定位的元素。从前往后数，只取前xxx个元素
● map:用指定的元素来替换流中的元素

---

实践说明

一、前提条件

Person类

package com.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.context.annotation.Configuration;

import java.util.Objects;

/**
 * @BelongsProject: StreamOperate
 * @BelongsPackage: com.example
 * @CreateTime: 2023-05-01  11:18
 * @Description: Person实体类
 * @Version: 1.0
 */
public class Person implements Comparable<Person>{
    
    
    public String getName() {
    
    
        return name;
    }

    public Person setName(String name) {
    
    
        this.name = name;
        return this;
    }

    public int getAge() {
    
    
        return age;
    }

    public Person setAge(int age) {
    
    
        this.age = age;
        return this;
    }

    public int getScore() {
    
    
        return score;
    }

    public Person setScore(int score) {
    
    
        this.score = score;
        return this;
    }

    private String name;
    private int age;
    private int score;


    public Person(String name, int age, int score) {
    
    
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public Person() {
    
    

    }

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public boolean equals(Object o) {
    
    
        //地址相同，为true
        if (this == o) return true;
        //为null，并且类型不一样，为false
        if (o == null || getClass() != o.getClass()) return false;
        //向下转型，再去比较属性值
        Person person = (Person) o;
        //如果属性值相同，最后的结果为true
        return age == person.age && score == person.score && Objects.equals(name, person.name);


        //return false;
    }

    @Override
    public int hashCode() {
    
    
        return Objects.hash(name, age, score);
    }


    @Override
    public int compareTo(Person o) {
    
    
        return this.getScore()-o.getScore();
    }
}

Data类

package com.example;

import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;

/**
 * @BelongsProject: StreamOperate
 * @BelongsPackage: com.example
 * @CreateTime: 2023-05-01  11:08
 * @Description: Data类
 * @Version: 1.0
 */
public class Data {
    
    
    public static ArrayList<Person> getData() {
    
    
        ArrayList<Person> personList = new ArrayList<>();

        personList.add(new Person("张三", 18, 90));
        personList.add(new Person("李四", 19, 100));
        personList.add(new Person("王五", 17, 60));
        personList.add(new Person("赵六", 18, 89));
        personList.add(new Person("孙七", 20, 96));
        personList.add(new Person("郑十", 20, 46));
        personList.add(new Person("周八", 20, 96));
        personList.add(new Person("周八", 20, 96));
        personList.add(new Person("吴九", 20, 45));
        personList.add(new Person("邓十一", 20, 35));
        personList.add(new Person("刘十二", 20, 99));
        personList.add(new Person("小十三", 20, 56));
        personList.add(new Person("小十三", 20, 56));

        return personList;
    }
}

---

二、操作

filter:过滤

//获取数据源
Stream<Person> stream = Data.getData().stream();

//成绩大于等于90的人员
stream.filter(ele -> ele.getScore() >= 90).forEach(System.out::println);

输出结果:

---

distinct:去重（去除集合中重复的元素）

去重规则：1、判断hashCode（）     
                 2、如果hashCode相同，再判断equals（）
//获取数据源
Stream stream = Data.getData().stream();

//去重并循环输出结果
stream.distinct().forEach(System.out::println);

输出结果:

---

sorted:排序

①、sorted():无参构造

规则：实现Comparable接口，重写compareTo方法定义要排序的规则

 public static void main(String[] args) {
    
    
     //将成绩从低到高排序
	Data.getData().stream().sorted().forEach(System.out::println);
 }

输出结果：

②、sorted(Compartor compartor)：有参构造

规则：直接在表达式中自定义排序规则

 public static void main(String[] args) {
    
    
     //将年龄从低到高排序
	Data.getData().stream().sorted().forEach(System.out::println);
 }

输出结果:

---

skip:跳过。从前往后数，跳过前xxx个元素，保留剩下的元素

limit:限制，只取流中前指定位的元素。从前往后数，只取前xxx个元素

 public static void main(String[] args) {
    
    
    //limit：只取前2个元素
    Data.getData().stream().limit(2).forEach(System.out::println);
    
    System.out.println("------------------------------------------------");
            
    //skip:跳过前4个元素，保留剩下的元素
    Data.getData().stream().skip(4).forEach(System.out::println);
 }

输出结果:

扫描二维码关注公众号，回复： 14972737 查看本文章

我们也可以将skip和limit结合使用:
需求：获取从第2个到第5个元素

 public static void main(String[] args) {
    
    
    //获取数据源        
    Stream<Person> stream = Data.getData().stream();
    
		//思路：2-5一共4个人
    stream.skip(1).limit(4).forEach(System.out::println);
}

输出结果:

---

map:元素映射，用指定的元素来替换流中的元素

需求：将流中分数大于等于80的Person对象替换成他们的姓名

 public static void main(String[] args) {
    
    
    //获取数据源        
    Stream<Person> stream = Data.getData().stream();

    //获取元素
    stream.map(ele -> ele.getScore() >= 80 ? ele : ele.getName()).forEach(System.out::println);
}

输出结果:





如果有想要交流的内容欢迎在评论区进行留言，如果这篇文档受到了您的喜欢那就留下你点赞+收藏+评论脚印支持一下博主~