Java 8——Stream

404_NOT_FOUND@

已于 2024-05-21 16:52:35 修改

阅读量1k

点赞数 19

文章标签： java

于 2024-05-21 16:51:38 首次发布

本文链接：https://blog.csdn.net/m0_70830675/article/details/139095601

版权

一、什么是 Stream

1.Stream概述

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。

要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念。

简单案例:

public static void main(String[] args) {
 List<Apple> applestore = new ArrayList();
  applestore.add(new Apple(1,"red",500,"河南"));
  applestore.add(new Apple(2,"red",400,"陕西"));
  applestore.add(new Apple(3,"green",300,"上海"));
  applestore.add(new Apple(4,"green",200,"湖北"));
  applestore.add(new Apple(5,"green",100,"湖南"));
}

我们的需求是在 applestore 集合中找出红色苹果手机，使用 Stream 流快速实现操作

List<Apple> apples = applestore
                     .stream()
                     .filter(a -> a.getColor().equals("red"))
                     .collect(Collectors.toList());

这里使用的就是 Java8 中的 stream 流

使用的是声明性方式写的：

说明想要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。同时可以将这些操作链接起来，达到一种流水线式的效果：

Java8 中的集合支持一个新的 Stream 方法，它会返回一个流

2.流的定义

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”

元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源 :获取数据的源，比如集合。

数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

二、获取流

使用 Collection 接口下的 stream()，将集合转为流

List<String> list = new ArrayList<>();

Stream<String> stream = list.stream();

  ArrayList<Integer> arrayList = new ArrayList<>();
                           arrayList.add(1);
                           arrayList.add(2);
                           arrayList.add(3);
                           arrayList.add(4);
  Stream<Integer> stream = arrayList.stream();//集合转换为流

使用 Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10];

Stream<Integer> stream = Arrays.stream(nums);

 Integer[] array = new Integer[]{1,2,3,5,4,2};
 Stream<Integer> stream1 = Arrays.stream(array);//数组转为流

使用 Stream 中的静态方法：of()

Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

 Stream stream2 = Stream.of(1,2,3,4);

三、流操作

流操作可以分为两类： 中间操作 和 终端操作 。回看之前的代码：

List<Apple> apples = applestore
                     .stream() //获得流
                     .filter(a -> a.getColor().equals("red"))//中间操作
                     .collect(Collectors.toList()); //终端操作

简化一下就是：

数据源 => 中间操作 => 终端操作 => 结果

诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

1.中间操作

filter：过滤流中的某些元素,

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合 limit(n)可实现分页

map(): 将其映射成一个新的元素

public class Demo2 {
    public static void main(String[] args) {
        Integer[] array = new Integer[]{1,2,3,5,4,2};
        Arrays.stream(array)
                .skip(2)//跳过前两个元素
                .limit(2)//获取两个元素
                .forEach((e)->{
                    System.out.println(e);//遍历元素
                });

        Arrays.stream(array)
                .filter((e)->{
                    return e<5;//过滤掉大于5的元素
                })
                .sorted((o1,o2)->{
                    return o2-o1;//降序排序
                })
                .distinct()//去重
                .forEach((e)->{
                    System.out.println(e);//遍历元素
                });
    }
}

2.终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false

findFirst：返回流中第一个元素

public class Demo3 {
    public static void main(String[] args) {
       
        Integer[] array = new Integer[]{6,1,2,3,5,4,2};
        boolean result = Arrays.stream(array)
                         .distinct()
                         .anyMatch((e)->{ //只要有一个元素满足条件，返回true
                             return e>2;
                         });
        System.out.println(result);

        boolean result1 = Arrays.stream(array)
                .distinct()
                .allMatch((e)->{ //所有元素都满足条件，返回true
                    return e>=1;
                });
        System.out.println(result1);

        Integer result2 = Arrays.stream(array)
                .distinct()
                .findFirst()//返回第一个元素
                .get();
        System.out.println(result2);

        Integer max = Arrays.stream(array)
                .max((o1,o2)->{
                    return o1-o2;
                }).get();//返回最大的数
        System.out.println(max);

        Integer min = Arrays.stream(array)
                .min((o1,o2)->{
                    return o1-o2;
                }).get();//返回最小的数
        System.out.println(min);

    }
}

collect:将流中的元素倒入一个集合,Collection 或 Map

创建一个Student类

public class Student {
    private String name;
    private int num;
    private int age;


    public Student(String name, int num,int age) {
        this.name = name;
        this.num = num;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getNum() {
        return num;
    }

    public int getAge() {
        return age;
    }

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

    public void setNum(int num) {
        this.num = num;
    }

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

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

public class Demo4 {
    public static void main(String[] args) {
        Student s1 = new Student("张三1", 1, 20);
        Student s2 = new Student("张三2", 2, 23);
        Student s3 = new Student("张三3", 3, 20);
        Student s4 = new Student("张三4", 4, 21);
        Student s5 = new Student("张三5", 5, 22);

        ArrayList<Student> students = new ArrayList<>();
        students.add(s4);
        students.add(s3);
        students.add(s2);
        students.add(s5);
        students.add(s1);

        List<Student> students1 = students.stream()
                .sorted((stu1,stu2)->{
                    return  stu1.getNum()-stu2.getNum();
                })
                .collect(Collectors.toList());
        System.out.println(students1);


        List<Student> students2 = students.stream()
                .filter((stu)->{
                    return  stu.getAge()>18;
                })
                .collect(Collectors.toList());
        System.out.println(students2);

        List list = students.stream()
                .map(Student::getNum)
                .collect(Collectors.toList());
        System.out.println(list);

       Map<Integer,String> map = students.stream()
               .collect(Collectors.toMap(Student::getNum,Student::getName));
        System.out.println(map);


    }
}