Java基础知识点第四篇 Stream流体系-CSDN博客

本文链接：https://blog.csdn.net/csdnnbyyds/article/details/131282821

本文介绍了如何使用Java中的List集合和Stream流进行数据处理，包括添加元素、过滤条件、长度检查以及链式编程思想。同时展示了从Collection、Map和数组获取流的方式，以及Stream的各种操作，如filter、forEach、map、distinct、skip、limit等。此外，还涉及了流的不可重复使用性及收集到其他集合或转换为数组的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

普通代码

List<String> name=new ArrayList<>();
      Collections.addAll(name,"张三丰","张无忌","赵敏","周芷若","张强");
        System.out.println(name);
        List<String> zhangList=new ArrayList<>();
        for (String s : name) {
            if (s.startsWith("张")){
                zhangList.add(s);
            }

        }
        System.out.println(zhangList);
        List<String> zhangThreeList=new ArrayList<>();
        for (String s : zhangList) {
            if (s.length() == 3){
                zhangThreeList.add(s);
            }
        }
        System.out.println(zhangThreeList);

使用stream流，一行代码搞定，stream流支持链式编程

      List<String> name=new ArrayList<>();
      Collections.addAll(name,"张三丰","张无忌","赵敏","周芷若","张强");
      name.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(s -> System.out.println(s));

Stream流的思想相当于传动带，依次按着顺序过滤

Collection集合、Map集合、数组获取流的方式

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


        //Map集合获取流
        Map<String,Integer> map=new HashMap<>();
        //获取键流
        Stream<String> keyStream = map.keySet().stream();
        //获取值流
        Stream<Integer> valueStream = map.values().stream();
        //获取键值对流
        Stream<Map.Entry<String, Integer>> keyAndValueStream = map.entrySet().stream();

        //数组获取流，有两种方式
        String[] names={"伽罗","刘备","关羽"};
        Stream<String> namesStream = Arrays.stream(names);
        //第二种方式
        Stream<String> namesStream2 = Stream.of(names);

public static void main(String[] args) {
         List<String> list=new ArrayList<>();
         list.add("伽罗");
         list.add("刘备");
         list.add("刘非");
         list.add("刘禅");
         list.add("刘山");
         list.stream().filter(s -> s.startsWith("刘")).forEach(s-> System.out.print(s));
        System.out.println("  ");
         //上面代码可以简化，  s->System.out.println(s) 输入是s输出也是s，可以简写为 System.out::println
        list.stream().filter(s->s.startsWith("刘")).forEach(System.out::print);
        System.out.println("  ");
        //统计名字长度为2的元素
        long count = list.stream().filter(s -> s.length() == 2).count();
        System.out.println(count);
        //打印出姓刘的前两位名字
        list.stream().filter(s->s.startsWith("刘")).limit(2).forEach(System.out::print);
        System.out.println("  ");

        //打印出姓刘的名字，跳过前两位
        list.stream().filter(s->s.startsWith("刘")).skip(2).forEach(System.out::print);
        System.out.println("-----------------");

        //map加工方法，让所有名字前面加上”英勇的“
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return "英勇的"+s;
            }
        }).forEach(System.out::println);
        //将上面代码简化
        list.stream().map(s -> "聪明的"+s).forEach(System.out::println);

        //把所有的名称加工成学生对象   创建学生类，里面只有一个name属性
        list.stream().map(s -> new Student(s)).forEach(System.out::println);
        //上述代码可以简化
        list.stream().map(Student::new).forEach(System.out::println);


        //合并流  两个不同类型得流和并，要用他们共同的父类类型来接
        Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> stream2 = Stream.of("java","java2");
        Stream<String> stream3=Stream.concat(stream1,stream2);

        //去重复distinct
        stream1.distinct();


    }

public static double allMoney=0.0;
    public static void main(String[] args) {
        //定义总工资
        List<Employee> list1=new ArrayList<>();
        list1.add(new Employee("伽罗",20,10000,5000,""));
        list1.add(new Employee("刘备",30,12000,6666,"顶撞上司"));
        list1.add(new Employee("张飞",21,9999,6666,""));
        list1.add(new Employee("关羽",24,8888,13140,""));
        List<Employee> list2=new ArrayList<>();
        list2.add(new Employee("猪八戒",25,66666,7000,""));
        list2.add(new Employee("孙悟空",26,99999,66666,""));
        list2.add(new Employee("沙僧",22,77777,7777,""));
        list2.add(new Employee("唐僧",30,88888,9090,"打架"));


        //分别筛选出两个部门的最高工资的员工信息，封装成优秀员工对象
        //选出部门1最优秀员工
        Topper topper1 = list1.stream().max(( o1,  o2) ->
                 Double.compare(o1.getSalary() + o1.getBonus(), o2.getSalary() + o2.getBonus())
        ).map(e -> new Topper(e.getName(), e.getBonus() + e.getSalary())).get();

        //选出部门二最优秀员工
        Topper topper2 = list2.stream().max(( o1,  o2) ->
                 Double.compare(o1.getSalary() + o1.getBonus(), o2.getSalary() + o2.getBonus())
        ).map(s -> new Topper(s.getName(), s.getBonus() + s.getSalary())).get();

        //求开发一部的平均工资
        list1.stream().sorted(( o1,  o2)->
                 Double.compare(o1.getSalary()+o1.getBonus(),o2.getSalary()+o2.getBonus())
        ).skip(1).limit(list1.size()-2).forEach(e->
                allMoney +=e.getBonus()+e.getSalary()
                );
        System.out.println("开发一部平均工资："+allMoney / (list1.size()-2));
        //求开发二部平均工资
        list2.stream().sorted(( o1,  o2)->
                 Double.compare(o1.getSalary()+o1.getBonus(),o2.getSalary()+o2.getBonus())
        ).skip(1).limit(list2.size()-2).forEach(e ->
                allMoney +=e.getBonus()+e.getSalary()
                );
        System.out.println("开发二部平均工资"+allMoney /(list2.size()-2));

        //统计两个部门的平均工资，去掉最低工资和最高工资
        Stream<Employee> stream1 = list1.stream();
        Stream<Employee> stream2 = list2.stream();
        Stream<Employee> concat = Stream.concat(stream1, stream2);
        concat.sorted(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return Double.compare(o1.getSalary()+o1.getBonus(),o2.getSalary()+o2.getBonus());
            }
        }).skip(1).limit(list1.size()+ list2.size()-2).forEach(e ->
                allMoney +=e.getBonus()+e.getSalary()
                );
        BigDecimal b=BigDecimal.valueOf(allMoney);
        BigDecimal c=BigDecimal.valueOf(list1.size()+list2.size()-2);
        System.out.println("综合平均工资为"+b.divide(c,2, RoundingMode.HALF_UP));


    }

注意注意注意流只能使用一次

 public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"伽罗","刘备","刘飞","刘刘");


        //把流收集
        Stream<String> liuList = list.stream().filter(s -> s.startsWith("刘"));
        List<String> collect = liuList.collect(Collectors.toList());
        //收集两次会报错，流只能用一次
        Set<String> collect1 = liuList.collect(Collectors.toSet());

        //把流转换成数组
        Stream<String> liuList2 = list.stream().filter(s -> s.startsWith("刘"));
        Object[] objects = liuList2.toArray();
        //默认都是Object类型，要是非要转换成其他类型
         String[] strings = liuList2.toArray(String[]::new);

    }