Stream

最新推荐文章于 2022-12-15 11:27:46 发布

面向c v编程

最新推荐文章于 2022-12-15 11:27:46 发布

阅读量281

点赞数 1

分类专栏：笔记文章标签： java udp 开发语言

本文链接：https://blog.csdn.net/m0_49797779/article/details/122368904

版权

笔记专栏收录该内容

52 篇文章 0 订阅

订阅专栏

什么是 Stream？

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。
要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream(IO中对文件的输入输出) 是完全不同的概念.
steam擅长对数据的操作.
简单案例:

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

public class Demo1 {
    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());
        System.out.println(apples);
    }


    static class Apple {
        Integer id;
        String color;
        Integer number;
        String address;

        public Apple() {
        }

        public Apple(Integer id, String color, Integer number, String address) {
            this.id = id;
            this.color = color;
            this.number = number;
            this.address = address;
        }

        @Override
        public String toString() {
            return "Apple{" +
                    "id=" + id +
                    ", color='" + color + '\'' +
                    ", number=" + number +
                    ", address='" + address + '\'' +
                    '}';
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public Integer getNumber() {
            return number;
        }

        public void setNumber(Integer number) {
            this.number = number;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }
    }
}

运行结果:[Apple{id=1, color=‘red’, number=500, address=‘河南’}, Apple{id=2, color=‘red’, number=400, address=‘陕西’}]

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。
**元素列表:**和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。
数据源 :获取数据的源，比如集合,数组。
数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。
简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

在这里插入图片描述

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

获取流

使用 Collection 接口下的 stream()方法
使用 Arrays 中的 stream() 方法，将数组转成流
使用 Stream 中的静态方法：of()
使用 BufferedReader.lines() 方法，将每行内容转成流

流操作

流操作可以分为两类：中间操作和终端操作。回看之前的代码：
在这里插入图片描述
诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

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

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

distinct: 去除重复元素 limit(n): 获取 n 个元素

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

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

终端操作
forEach: 遍历流中的元素

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

Min:返回流中元素最小值

Max:返回流中元素最大值

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

Reduce:所有元素求和

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

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

findFirst：返回流中第一个元素
collect:将流中的元素倒入一个集合,Collection 或 Map.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

public class Demo {
    /*
   stream  java8 之后对集合(集合,数组)进行遍历操作的高级迭代器(重点在于对数据操作)

   集合/数组 --> 元素序列(stream)  --> 中间操作(过滤,排序,去重...) --> 终端操作(最终的结果)

   流的使用:
   1.获取流     集合,数组  都可以转为流
   2.中间操作
   3.终端操作

    */
    public static void main(String[] args) {
        /*
          获取流
        List<String> list = new ArrayList<>();
        list.stream();

        int arr[] = new int[10];
        Arrays.stream(arr);

        Stream.of(2, 3, 4, 5, 1, 8, 9, 6, 7);
       */

        Stream.of(2, 3, 4, 5, 1, 8, 9, 6, 7, 5, 6, 7, 8)
                .filter((e) -> {
                    return e > 3;  //把大于3的内容留下来
                }).sorted(((o1, o2) -> o2.compareTo(o1))) //逆序排序
                .distinct()      //去除重复
                .forEach((a) -> {
                    System.out.println(a);    //输出
                });
        System.out.println("max=" + Stream.of(10, 3, 4, 5, 1, 8, 9)
                .max(((o1, o2) -> {
                    return o1.compareTo(o2);  //比较大小
                }))
                .get()
        );
        Integer sum = Stream.of(10, 3, 4, 5, 1, 8, 9)
                .reduce((o1, o2) -> {
                    return o1 + o2;    //q求和
                })
                .get();
        System.out.println("和为:" + sum);

        Boolean b = Stream.of(10, 3, 4, 5, 1, 8, 9)
                .anyMatch((e) -> {  // anyMath
                    return e > 3;   //只要有一个大于3就返回true,否则返回false
                });
        System.out.println(b);

        Boolean b1 = Stream.of(10, 3, 4, 5, 1, 8, 9)
                .allMatch((e) -> {  // allMatch
                    return e > 3;   //只要有一个不是小于等于3就返回false,否则返回true
                });
        System.out.println(b1);
    }
}

运行结果:
在这里插入图片描述
中间操作map 以及终端操作collect:

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

public class Demo1 {

    /*
    stream  java8 之后对集合(集合,数组)进行遍历操作的高级迭代器(重点在于对数据操作)

    集合/数组 --> 元素序列(stream)  --> 中间操作(过滤,排序,去重...) --> 终端操作(最终的结果)

    流的使用:
    1.获取流     集合,数组  都可以转为流
    2.中间操作
    3.终端操作

     */
    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(5, "green", 200, "湖北"));
        applestore.add(new Apple(4, "green", 100, "湖南"));

        /*//我们的需求是在 applestore 集合中找出红色苹果手机. 使用 Stream 流快速实现操作
        List<Apple> apples = applestore.
                stream().    //获得流
                filter(a -> a.getColor().equals("red")).  //中间操作
                collect(Collectors.toList());   //终端操作
        System.out.println(apples);*/

        /*
        map(方法) 将某一个值 映射到stream中去
         */

        applestore.stream()
                .map(Apple::getId)  //只把id映射到map中去
                .forEach((e) -> {
                    System.out.println(e);
                });

        List list = applestore.stream()
                .sorted(((o1, o2) -> {
                    return o1.getId() - o2.getId();
                }))
                .collect(Collectors.toList());

        System.out.println(list);


        //前提得重写equal方法,hashcode方法
        Set set = applestore.stream()
                .sorted(((o1, o2) -> {
                    return o1.getId() - o2.getId();
                }))
                .collect(Collectors.toSet());

        System.out.println(set);

        Map<Integer, String> map = applestore.stream()
                .sorted(((o1, o2) -> {
                    return o1.getId() - o2.getId();
                }))
                .collect(Collectors.toMap(Apple::getId, Apple::getAddress));

        System.out.println(map);
    }


    static class Apple {
        private Integer id;
        private String color;
        private Integer number;
        private String address;

        public Apple() {
        }

        public Apple(Integer id, String color, Integer number, String address) {
            this.id = id;
            this.color = color;
            this.number = number;
            this.address = address;
        }

        @Override
        public String toString() {
            return "Apple{" +
                    "id=" + id +
                    ", color='" + color + '\'' +
                    ", number=" + number +
                    ", address='" + address + '\'' +
                    '}';
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public Integer getNumber() {
            return number;
        }

        public void setNumber(Integer number) {
            this.number = number;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }

    }
}

运行结果:
在这里插入图片描述

面向c v编程

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Stream

什么是 Stream？Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream(IO中对文件的输入输出) 是完全不同的概念.steam擅长对数据的操作.简单案例:import java.util.ArrayList;import java.util.
复制链接

扫一扫

专栏目录