【JavaSE】初学Stream流

iknow181

已于 2023-06-01 17:33:17 修改

阅读量103

点赞数

分类专栏： JavaSE 文章标签： java 开发语言

于 2022-11-21 20:07:17 首次发布

本文链接：https://blog.csdn.net/qinjilll/article/details/127970924

版权

JavaSE 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

什么是Stream流？

目的：用于简化集合和数组操作的API

普通方法与Stream流对比

List<String> names = new ArrayList<>();
    Collections.addAll(names,"张三丰","张无忌","周芷若","赵敏","张强");
    System.out.println(names);

普通方法

//1.找姓张的放到张姓集合中
    List<String> zhangList = new ArrayList<>();
    names.forEach(n -> {
        if (n.startsWith("张")) {
            zhangList.add(n);
        }
    });
    System.out.println(zhangList);

    //2.找名称长度是3的姓名
    List<String> threeLengthList = new ArrayList<>();
    zhangList.forEach(n -> {
        if (n.length() == 3) {
            threeLengthList.add(n);
        }
    });
    System.out.println(threeLengthList);

    

使用stream流实现

names.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

Stream流的核心思想

1.先得到集合或者数组的stream流（相当于一根传送带）

2.把元素放上去

3.然后用Stream流简化的API来方便操作元素。

Stream流的三类方法

一、获取Stream流

创建一条流水线，并把数据放到流水线上准备操作

二、中间方法

流水线上操作。可以支持链式操作。

三、终结方法

一个Stream流只能有一个终结方法，是流水线上的最后一个操作

一、获取Stream流

        //------------------------Collection集合获取流---------------------------------
        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();

        //------------------------Map集合获取流----------------------------------------
        Map<String,Integer> maps = new HashMap<>();
        //键流
        Stream<String> keyStream = maps.keySet().stream();
        //值流
        Stream<Integer> valuesStream = maps.values().stream();
        //键值对流（拿整体）
        Stream<Map.Entry<String,Integer>>  keyAndValueStream = maps.entrySet().stream();

        //------------------------数组获取流-------------------------------------------
        String[] names = {"aaa","bbb","冲冲冲","DDD"};
        Stream<String> nameStream = Arrays.stream(names);
        Stream<String> nemeStream2= Stream.of(names);

二、Stream流加工

        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张三丰");

        //找所有姓张的
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));

        //找所有姓名长度为3的
        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size);

        //找姓张的前两个
        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);

        //跳过姓张的前两个
        list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);

        //map加工方法：第一个参数为原材料 -> 第二个参数为加工后的结果
        //给集合元素的前面加上 厉害的
        list.stream().map(s -> "厉害的" + s).forEach(System.out::println);

        //将所有的名称，加工成一个学生对象
        list.stream().map(s -> new Student(s)).forEach(System.out::println);
        //                                ||
        //list.stream().map(Student::new).forEach(System.out::println);

        //合并流
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = list.stream().filter(s -> s.length() == 3);
        Stream<String> s3 = Stream.concat(s1,s2);
        s3.forEach(System.out::println);

        //去除流中重复的元素
        s3.distinct().forEach(System.out::println);

三、收集Stream流

        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张三丰");

        //收集为List集合
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        List<String> zhangList = s1.collect(Collectors.toList());
        System.out.println(zhangList);

        //流只能使用一次！！
        //收集为Set集合
        Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
        Set<String> zhangSet = s2.collect(Collectors.toSet());
        System.out.println(s2);

        //收集为Array集合
        Stream<String> s3 = list.stream().filter(s -> s.startsWith("张"));
        Object[] arrs = s3.toArray();
        System.out.println("Arrays数组" + Arrays.toString(arrs));

四、综合案例

需求：某个公司的开发部门，分为开发一部和二部，现在需要进行年中数据结算。
1：员工信息至少包含了（名称、性别、工资、奖金、处罚记录）
2：开发一部有4个员工、开发二部有5名员工：分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象 Topperformer
3：分别统计出2个部门的平均月收入，要求去掉最高和最低工资。
4：统计2个开发部门整体的平均工资，去掉最低和最高工资的平均值。
Employee类

    package d3_stream;

    public class Employee {
    private String name;//姓名
    private char sex;//性别
    private double salary;//工资
    private double bonus;//奖金
    private String punish;//处罚信息

    public Employee() {
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}';
    }
}

Topperformer类

package d3_stream;

public class Topperformer {
    private String name;
    private Double money;

    public Topperformer() {
    }

    public Topperformer(String name, Double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Topperformer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

StreamTest

package d3_stream;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest2 {

    public static double allMoney = 0;

    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("aaa",'男',30000,25000,null));
        one.add(new Employee("bbb",'男',25000,15000,null));
        one.add(new Employee("ccc",'女',20000,1000,"调戏同事aaa"));
        one.add(new Employee("ddd",'女',20000,25000,null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("AAA",'男',25000,9000,null));
        two.add(new Employee("BBB",'女',19000,5000,null));
        two.add(new Employee("CCC",'男',50000,12000,"被人打"));
        two.add(new Employee("DDD",'男',15000,1000,"打人"));
        two.add(new Employee("ABC",'女',10000,0,"窃取公司机密"));

        start(one,"开发一部");
        start(two,"开发二部");
        allArgMoney(one,two);
    }

    private static void allArgMoney(List<Employee> one, List<Employee> two) {
        //合并2个集合流，再统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1,s2);
        s3.sorted((e1,e2) -> Double.compare(e1.getSalary() + e2.getBonus(),e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() + two.size() - 2).forEach(e -> {
                    allMoney += (e.getSalary() + e.getBonus());
                });
        //用BigDecimal来保存精度(四舍五入)
        BigDecimal a = BigDecimal.valueOf(allMoney);
        BigDecimal b = BigDecimal.valueOf((one.size() + two.size() - 2));
        System.out.println("开发部的平均工资是：" + a.divide(b,2,RoundingMode.HALF_UP));
    }

    public static void start(List<Employee> list,String name){

        //1.最高工资员工
        //指定大小规则
        Topperformer t = list.stream().max((e1,e2) -> Double.compare((e1.getSalary() + e1.getBonus()),(e2.getSalary()) + e2.getBonus()))
                .map(e -> new Topperformer(e.getName(), (e.getSalary()) + e.getBonus())).get();
        System.out.println(name + "的最高工资员工：");
        System.out.println(t);

        //2.统计平均工资，去掉最高工资和最低工资
        list.stream().sorted((e1,e2) -> Double.compare((e1.getSalary() + e1.getBonus()),e2.getSalary() + e2.getBonus()))
                .skip(1).limit(list.size() - 2).forEach(e ->
                        //求出总和：剩余员工工资的总和
                        allMoney += (e.getSalary() + e.getBonus()));
        //用BigDecimal来保存精度(四舍五入)
        BigDecimal a = BigDecimal.valueOf(allMoney);
        BigDecimal b = BigDecimal.valueOf(list.size() - 2);
        System.out.println(name + "的平均工资：" + a.divide(b, RoundingMode.HALF_UP));
    }
}