java加强 -stream流

CodeBlossom

于 2025-05-14 23:39:41 发布

阅读量471

点赞数 13

文章标签： java python windows

本文链接：https://blog.csdn.net/2401_88743650/article/details/147965404

版权

Stream流是jdk8开始新增的一套api，可以用于操作集合或数组的内容。

Stream流大量的结合了Lambda的语法风格来编程，功能强大，性能高效，代码简洁，可读性好。

体验Stream流

把集合中所有以三开头并且三个字的元素存储到一个新集合。

package streamDemo;

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

public class StreamDemo1 {
    public static void main(String[] args) {
        //目标：认识stream流，掌握基本使用步骤，体会它的优势
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张无忌");
        list.add("张三丰");
        list.add("张小四");
        //用传统方案找出姓张的人名字为三个字的存入到新集合中
        List<String> newList = new ArrayList<>();
        for(String name : list)
        {
            if(name.startsWith("张")&&name.length()==3)
            {
                newList.add(name);
            }
        }
        System.out.println(newList);
        //用stream流
        List<String> newList2=list.stream().filter(s -> s.startsWith("张")).filter(s ->s.length()==3).collect(Collectors.toList());
        System.out.println(newList2);
    }
}

相较于传统方法的排序和筛选，stream流只需要一行就可以实现功能，代码更简洁。

获取Stream流

语法：

Stream<集合或数组内存储的数据类型> 变量名 = 数组或集合名.stream();

示例

package streamDemo;

import java.util.*;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main(String[] args) {
        //获取stream流的方式
        //1、获取集合的stream流，调用集合提供的stream（）方法
        Collection<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();

        //2、Map集合
        Map<String,Integer> map = new HashMap<>();
        //获取它的键流
        Stream<String> s2 = map.keySet().stream();
        //值流
        Stream<Integer> s3 = map.values().stream();
        //键值对流
        Stream<Map.Entry<String, Integer>> s4 = map.entrySet().stream();
        //3、数组的流
        String[] names = {"张三丰","张学友","张学良"};
        Stream<String> s5 = Arrays.stream(names);
        System.out.println(s5.count());
        Stream<String> s6 = Stream.of(names);
        Stream<String> s7 = Stream.of("张三丰", "张无忌", "张三");
    }
}

Stream流的常用中间方法

中间方法指的是，使用完这个方法后，会返回一个新的Stream流，例如筛选完姓张的人后返回一个只有姓张的人的集合用于后续操作。

获取的Stream流可以使用多个中间方法进行筛选，直到选出我们需要的数据。

常用的几种方法有：过滤方法、合并方法、映射/加工方法等

Stream流中若是需要为自定义数据类型规定排序规则/筛选规则，可以使用Lambda方法。

示例

package streamDemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo3 {
    public static void main(String[] args) {
        //掌握Stream流常用的中间方法，对流上的数据进行处理（返回新流：支持链式存储）
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张无忌");
        list.add("张三丰");
        list.add("张小四");
        //过滤方法
        list.stream()
                .filter(s -> s.startsWith("张"))
                .filter(s ->s.length()==3)
                .forEach(s -> System.out.println(s));
        //排序方法
        List<Double> scorce = new ArrayList<>();
        scorce.add(99.8);
        scorce.add(98.7);
        scorce.add(83.7);
        scorce.add(67.5);
        scorce.add(67.5);
        scorce.stream().sorted().forEach(s-> System.out.println(s));//升序
        System.out.println("=============================");
        scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
                .forEach(s-> System.out.println(s));//降序
        System.out.println("=============================");
        scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
                .limit(2).forEach(System.out::println);//只要前两名
        System.out.println("=============================");
        scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
                .skip(2).forEach(System.out::println);//跳过前两名
        System.out.println("=============================");
        //如果希望自定义对象能够去重，需要重写对象的hashCode和equals方法才能去重
        scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
                .distinct().forEach(System.out::println);//去重

        //映射/加工方法： 把流上原本的数据拿出来变成新数据放回流上
        scorce.stream().map(s->"加十分后："+(s+10)).forEach(System.out::println);
        //合并流
        Stream<String> s1 = Stream.of("张三丰", "张无忌", "张三");
        Stream<Integer> s2 = Stream.of(111,22,33);
        Stream<Object> s3 = Stream.concat(s1,s2);//每次只能合并两个
        System.out.println(s3.count());
    }
}

Stream流的常用终结方法

终结方法指的是调用完后不会返回新的Stream流了，不能再继续调用流了。

常用的一些终结方法有统计/收集方法。收集方法是将目前流中的数据存储到一个集合/数组中，统计方法是统计流中目前的元素数量，流中的最大值最小值等。

package streamDemo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Teacher implements Comparable<Teacher>{
    private String name;
    private int age;
    private double salary;
    @Override
    public String toString()
    {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}'+"\n";
    }
    //t2.compareTo(t1)
    //t2==this 比较者
    //t1==o 被比较者
    //规定：如果t2大于t1，返回正数；如果t2小于t1，返回负数；如果t2等于t1，返回0
    @Override
    public int compareTo(Teacher o) {
        //按照年龄升序排序
//            if (this.age>o.age)
//                return 1;
//            else if (this.age<o.age)
//                return -1;
//            return 0;
//    }
        return this.age-o.age;//升序
        //return o.age-this.age;//降序
    }
}

package streamDemo;

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo4 {
    public static void main(String[] args) {
        //掌握Stream流的统计，收集操作（终结方法）
        List<Teacher> teachers = new ArrayList<>();
        teachers.add(new Teacher("张三",18,5000));
        teachers.add(new Teacher("老陈",38,8000));
        teachers.add(new Teacher("老金",58,15000));
        teachers.add(new Teacher("老魏",63,16000));
        teachers.add(new Teacher("张五",28,3500));

        teachers.stream().filter(s->s.getSalary()>6000).forEach(s-> System.out.println(s));
        System.out.println("======================================");
        long count = teachers.stream().filter(s -> s.getSalary() > 15000).count();  //计15000薪水以上的人数
        System.out.println(count);
        System.out.println("======================================");
        //获取薪水最高的老师对象
        Optional<Teacher> max = teachers.stream().max((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));
        Teacher maxTeacher = max.get();
        System.out.println(maxTeacher);
        //最小
        Optional<Teacher> min = teachers.stream().min((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));
        Teacher minTeacher = min.get();
        System.out.println(minTeacher);
        System.out.println("=====================================");
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张无忌");
        list.add("张三丰");
        list.add("张小四");
        //收集到集合或数组中
        Stream<String> s1 = list.stream().filter(s->s.startsWith("张"));
        //收集到list集合
        //流只能收集一次
        List<String> List1 = s1.collect(Collectors.toList());
        System.out.println(List1);
        //收集到Set集合
        Set<String> list2 =list.stream().filter(s->s.startsWith("张")).collect(Collectors.toSet());
        System.out.println(list2);
        System.out.println("=============收集到map集合===================");
        Stream<Teacher> s4 = teachers.stream();
        //收集到Map集合：键是老师名称，值是老师薪水
        Map<String, Double> map = s4.collect(Collectors.toMap(t1 -> t1.getName(), t1 -> t1.getSalary()));
        System.out.println(map);

    }
}

以上就是关于Stream流的基本语法。