Stream流的一些基本用法

最新推荐文章于 2024-09-19 21:43:28 发布
最新推荐文章于 2024-09-19 21:43:28 发布
阅读量4.6k 收藏 14
点赞数 5
分类专栏： Stream流 文章标签： java 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Linzc19/article/details/127426135
版权

一、Stream流介绍

        stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。
        同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。在Stream中的操作每一次都会产生新的流，内部不会像普通集合操作一样立刻获取值，而是 惰性取值 ，只有等到用户真正需要结果的时候才会执行。 并且对于现在调用的方法，本身都是一种高层次构件，与线程模型无关。因此在并行使用中，开发者们无需再去操 心线程和锁了。Stream内部都已经做好了 。
        关于对Stream流的理解，你可以把他当成工厂中的流水线，每个stream流的操作过程遵循着创建 -->操作 -->获取结果的过程，就像流水线上的节点一样组成一个个链条。除此之外你还可以把他理解成sql的视图，集合就相当于数据表中的数据，获取stream流的过程就是确定数据表的属性和元数据的过程，元数据的每一个元素就是表中的数据，对stream流进行操作的过程就是通过sql对这些数据进行查找、过滤、组合、计算、操作、分组等过程，获取结果就是sql执行完毕之后获取的结果视图一样，深入理解stream流可以让我们使用更加简洁的代码获取自己想要的数据。

二、Stream流的基本用法

 List<String> strList = Arrays.asList("1", "2", "3", "4", "5","5","4");
        System.out.println(strList);

        //过滤
        List<String> filter = strList.stream().filter(s -> 
        s.equals("3")||s.equals("4")).collect(Collectors.toList());
        System.out.println(filter);

        //去重
        List<String> distinct = strList.stream().distinct().collect(Collectors.toList());
        System.out.println(distinct);

        //获取第一个元素
        String any = strList.stream().findAny().get();
        String first = strList.stream().findFirst().get();

        System.out.println(any);
        System.out.println(first);
        //此方法值不确定
        for (int i = 0; i < 100; i++) {
            String findAny = strList.parallelStream().findAny().get();
            System.out.println(findAny);
        }

        //获取最长的字符串
        List<String> stringList = Arrays.asList("xiao", "xiaobu", "xiaobudian");
        Optional<String> max = stringList.stream().max(Comparator.comparing(String::length));
        System.out.println(max);

        //获取最短的字符串
        Optional<String> strMin = stringList.stream().min(Comparator.comparing(String::length));
        System.out.println(strMin);
        Optional<String> min = stringList.stream().min(String::compareToIgnoreCase);
        System.out.println(min);

        //获取int最大值
        List<Integer> integers = Arrays.asList(1, 2, 3, 6, 51, 45);
        Optional<Integer> integerMax = integers.stream().max(Integer::compareTo);
        System.out.println(integerMax);

        //获取int最小值
        Optional<Integer> minInt = integers.stream().min(Comparator.comparingInt(Integer::shortValue));
        Optional<Integer> minInt1 = integers.stream().min(Comparator.comparing(Integer::intValue));
        System.out.println(minInt);
        System.out.println(minInt1);

三、Stream流的对象值比较

        //对象值比较
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("小明",15));
        personList.add(new Person("大强",18));
        personList.add(new Person("小泽玛利亚",22));
        //获取名字最长的对象
        Person person = personList.stream().max(Comparator.comparing(Person::getName)).get();
        System.out.println(person);
        //获取年龄最小的
        Person person1 = personList.stream().min(Comparator.comparing(Person::getAge)).get();
        System.out.println(person1);

四、Stream流的缩减

        List<Integer> integerList = Arrays.asList(1, 2, 3, 6, 51, 45);
        //求和
        Integer reduce = integerList.stream().reduce(0,Integer::sum);
        System.out.println(reduce);
        //在求和的值上加10
        Integer reduce1 = integerList.stream().reduce(10,Integer::sum);
        System.out.println(reduce1);

        //其他写法
        Integer reduce2 = integerList.stream().reduce(10, (x, y) -> x + y);
        System.out.println(reduce2);
        //相乘并乘10
        Integer reduce3 = integerList.stream().reduce(10, (x, y) -> x * y);
        System.out.println(reduce3);

        //求最大值
        Optional<Integer> reduce4 = integerList.stream().reduce(Integer::max);
        System.out.println(reduce4);


        List<Person> personList = new ArrayList<>();
        personList.add(new Person("小明",15));
        personList.add(new Person("小泽玛利亚",22));
        personList.add(new Person("大强",18));
        personList.add(new Person("光头强",12));
        //对象中求年龄的和
        Optional<Integer> ageSum = personList.stream().map(p -> p.getAge()).reduce(Integer::sum);
        System.out.println(ageSum);
        //对象中年龄最大的
        Optional<Integer> reduce5 = personList.stream().map(p -> p.getAge()).reduce(Integer::max);
        personList.stream().max(Comparator.comparing(Person::getAge));
        //对比后获得年龄最大的对象
        Person person = personList.stream().reduce((p1, p2) -> p1.getAge() > p2.getAge() ? p1 : p2).get();
        System.out.println(person);
        System.out.println(reduce5);

五、Stream流的Collect用法

 List<Person> personList = new ArrayList<>(4);
        personList.add(new Person("小明",15));
        personList.add(new Person("小明",18));
        personList.add(new Person("小明",18));
        personList.add(new Person("小泽玛利亚",22));
        personList.add(new Person("大强",18));
        personList.add(new Person("光头强",12));
        // 获取平均年龄 averaging
        Double avg = personList.stream().collect(Collectors.averagingInt(Person::getAge));
        System.out.println(avg);
        //同时计算长度 和 最大值 最小值 平均值
        DoubleSummaryStatistics doubleCollect = personList.stream().collect(Collectors.summarizingDouble(Person::getAge));
        System.out.println(doubleCollect);

        //获取姓名组合为字符串，以,分割
        String pName = personList.stream().map(Person::getName).collect(Collectors.joining(","));
        System.out.println(pName);

        //求年龄的和
        Integer sum = personList.stream().map(Person::getAge).reduce(0, (x, y) -> x + y);
        Integer sum1 = personList.stream().map(Person::getAge).reduce(Integer::sum).get();
        System.out.println(sum);
        System.out.println(sum1);

        //分组
        //以名字进行分组
        Map<String, List<Person>> collect = personList.stream().collect(Collectors.groupingBy(Person::getName));
        System.out.println(collect);

        //先以名字分组，再以年龄分组
        Map<String, Map<Integer, List<Person>>> collect1
                = personList.stream().collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(Person::getAge)));
        System.out.println(collect1);

        // toList、toSet、toMap
        List<Person> collect2 = personList.stream().collect(Collectors.toList());
        System.out.println(collect2);

六、Stream流的映射

 //转换为大写
        String[] strArr = { "abcd", "bcdd", "defde", "ftr" };
        Arrays.stream(strArr).map(String::toUpperCase).forEach(System.out::print);
        //转化list
        List<String> collect = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
        System.out.println(collect);

七、Stream流的排序

        //自然排序并转换为list
        String[] strArr = { "ab", "bcdd", "defde", "ftr" };
        List<String> collect = Arrays.stream(strArr).sorted().collect(Collectors.toList());
        System.out.println(collect);
        //自定义排序
        // 按照字符串的长度 从小到大
        List<String> collect1 = Arrays.stream(strArr).sorted(Comparator.comparing(String::length)).collect(Collectors.toList());
        System.out.println(collect1);
        //倒序
        List<String> collect2 = Arrays.stream(strArr).sorted(Comparator.comparing(String::length).reversed()).collect(Collectors.toList());
        System.out.println(collect2);

        // 首字母倒序
        List<String> collect3 = Arrays.stream(strArr).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println(collect3);

        List<String> collect4 = Arrays.stream(strArr).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
        System.out.println(collect4);

八、Stream流的提取流和组合流

 String[] arr1 = {"a","b","c","d"};
        String[] arr2 = {"d","e","f","g"};
        String[] arr3 = {"i","j","k","l"};

        Stream<String> stream1 = Arrays.stream(arr1);
        Stream<String> stream2 = Arrays.stream(arr2);
        Stream<String> stream3 = Arrays.stream(arr3);

        //合并去重
        List<String> collect = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        System.out.println(collect);


        // limit，限制从流中获得前n个数据
        List<String> collect1 = collect.stream().limit(3).collect(Collectors.toList());
        System.out.println(collect1);

        // skip，跳过前n个数据
        List<String> collect2 = collect.stream().skip(3).collect(Collectors.toList());
        System.out.println(collect2);

Linzc19
关注
专栏目录
简单总结Java IO中stream流的使用方法
09-02
Java IO中的Stream流是Java语言进行输入输出操作的核心机制。它以“流”的方式处理数据，使得数据的传输变得简单且高效。Stream流分为两种主要...理解并熟练掌握流的使用方法，是成为一名合格的Java开发者的必备技能。
Stream使用
weixin_42705499的博客
07-15 3400
Stream类使用Stream类生成流stream().map()转换成大写字母平方数stream().filter()筛选出偶数多条件筛选stream().peek()stream().reduce()stream().limit()和stream().skip()stream().sorted()stream().max()和stream().min()stream().distinct()matchstream().mapTo...()参考 Stream类 Stream为Java8的新特性 S
【Java 8 新特性】Java Stream 通过min()和max()获取列表最小值和最大值
热门推荐
猫巳的博客
12-14 7万+
【Java 8 新特性】Java Stream 通过min和max方法获取列表最小值和最大值1.Stream.min()2.Stream.max()3.在字符串(`String`)和整数(`Integer`)中如何使用min和max方法4.在对象类型(`Object`)中使用Min和Max方法5.在日期类型(`Date`)中使用Min和Max方法 本页将介绍Stream.min和Stream.max示例。 java.util.stream.Stream已经在java8中引入。 使用Stream.min方法，
JAVA8新特性——Stream
最新发布
m0_73731267的博客
09-19 968
Stream流的出现极大的方便了我们对数据的处理，作为处理数据的一种通用方式。它提供了一种高效且灵活的方法来执行诸如过滤、映射、汇总等操作。Stream API 可以用于任何实现了 Iterable 接口的数据结构，或者能够转换为支持流式处理的对象。
Java8中Stream流求最大值最小值
qq_43842093的博客
02-18 1万+
【代码】Java8中Stream流求最大值最小值。
Stream.min
06-22 3843
Optional<T>min​(Comparator<? superT>comparator) 这个方法和上面max方法的作用和使用方式一样。唯一区别就是对比较结果的判断和max相反。还有就是对比较结果强制为0的时候和-1是一样的效果。看代码： void stream_min() { List<String> list = List.of("Mr.zhangsan","Mr.lisi","Mr.wanger","Mr.mazi"); ...
Java8新特性 - Stream - 13 - Stream的max()、min()方法详解
northcastle的博客
03-14 2万+
java8新特性 Stream操作 集合数据 求max()、min() 取集合中的最大值最小值
stream流的简单使用
06-05
在本资源中，我们将通过一个简单的示例来介绍Stream流的基本使用。 Person类定义 首先，我们需要定义一个Person类，用于存储人员信息。该类中包含三个私有成员变量：name、age和gender。同时，我们还重写了...
NodeJS 中Stream 的基本使用
10-18
本文将深入探讨Node.js中的Stream基本使用，主要包括创建可读流、流动状态与暂停状态的理解。 首先，创建可读流是通过`fs.createReadStream`方法实现的。该方法接受两个参数，第一个是文件路径，第二个是选项对象，...
Java Stream的基本概念以及创建方法
09-07
Stream API提供了一些静态方法，如`Stream.of()`，可以直接创建一个Stream。例如： ```java Stream<String> stream = Stream.of("a", "b", "c"); ``` 4. 从I/O通道创建： 可以使用`Files.lines()`从文件读取行...
Java8 Stream API 详细使用方法与操作技巧指南
08-19
Java8 Stream API 详细使用方法与操作技巧指南 Java 8 引入了 Stream API，这是一个重要的特性，允许开发者以一种声明式的方式对数据进行处理。Stream 翻译过来是“流”，它可以看做是一个可操作的数据集序列，具有...
stream流的用法，超全
qq_61547726的博客
05-09 4037
循环 List 或 Map 可以使用 Java的 for 循环、增强 for 循环、迭代器和 Stream 流等方式。
Stream流使用方法总结
python15397的博客
07-02 6787
流是一种处理数据的高级手段，任何数据都可以转化成流进行处理。对Stream流来说，比较常见数据源有集合、数组、IO等。我们可以把流想象成一条流水线，流水线的源头是数据源，数据源中的每个元素是流的操作对象。数据源中的元素被依次输送到流水线上，然后我们就可以对这些流水线上的元素进行各种操作，一旦元素走到了流水线的尽头，那么该元素也被“消费掉了”，之后在此次流水线上我们便无法再对该元素进行任何操作。平常我们是赢得for循环、增强for等一些遍历操作都是显示的操作数据源，而stream流的遍历过程对我们来说是不可见
java中各种类型用Stream流求最大值最小值
githubcurry
12-20 3175
java中各种类型用Stream流求最大值最小值。
lambda表达式二之Stream流
weixin_43213064的博客
01-16 696
Stream流 是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。 集合讲的是数据，流讲的是计算 Stream自己不会存储元素 Stream不会改变源对象，会返回一个持有结果的新Stream。 Stream操作是延迟执行的，意味着会等待需要结果的时候才执行。 操作步骤 一、创建Stream 一个数据源，获取一个流 1.可以通过Collection系列集合提供的stream()或者parallelStream() 2.通过Arrays中静态方法stream()获取数组流 3.通过Stream
JAVA8 Stream接口 终端操作 min，max，findFirst，findAny操作
Tomatoes的博客
04-15 569
对于中间操作和终端操作的定义，请看《JAVA8 stream接口 中间操作和终端操作》，这篇主要讲述的是stream的min，max，findFirst，findAny操作，我们先看下函数的定义 Optional<T> min(Comparator<? super T> comparator); Optional<T> max(Comparator<? super T> comparator); Optional<T> f
【Java】Java8 之Stream用法总结（持续更新）
慕白Lee的博客
04-23 1万+
Java8 之Stream用法总结
Java Stream API 操作完全攻略
qq_42748190的博客
05-04 592
mapping()：根据指定的 Function 对 Stream 中的元素进行映射，并返回一个新的 Stream。iterating()：使用指定的种子值创建一个 Stream，并依次对每个元素进行指定的操作。35. 使用 takeWhile()：返回满足指定条件的元素，直到遇到第一个不满足条件的元素。36. 使用 dropWhile()：返回不满足指定条件的元素，直到遇到第一个满足条件的元素。map()：根据指定的 Function 映射每个元素，生成一个新的 Stream。
使用 Stream API 优化你的代码
Java笔记虾
09-23 1386
Java8的新特性主要是Lambda表达式和流，当流和Lambda表达式结合起来一起使用时，因为流申明式处理数据集合的特点，可以让代码变得简洁易读 放大招，流如何简化代码 如果有一个需求，需要对数据库查询到的菜肴进行一个处理： 筛选出卡路里小于400的菜肴 对筛选出的菜肴进行一个排序 获取排序后菜肴的名字 菜肴：Dish.java publicclassD...
stream流的一些使用方法
08-31
stream流的distinct方法是用于去除流中重复元素的方法。它会返回一个新的流，其中包含原始流中的所有元素，但是重复的元素只会出现一次。这个方法使用元素的equals方法来判断元素是否相等。如果流中的元素没有实现...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值