Java8——Stream流操作

最新推荐文章于 2024-01-21 13:56:41 发布
最新推荐文章于 2024-01-21 13:56:41 发布
阅读量413 收藏 2
点赞数 1
分类专栏： JavaSE 项目开发必知知识点 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38737586/article/details/109756959
版权

参考：https://www.cnblogs.com/niujifei/p/11614861.html

文章目录

一、Stream流

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库 使用时存在的弊端。

二、集合的遍历

1、传统的遍历（循环遍历）

几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。

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

传统的集合遍历就是上例的代码；

2、循环遍历的弊端

而Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How）。

试想一下，如果希望对集合中的元素进行筛选过滤：
　　　　　　① 将集合A根据条件一过滤为子集B；
　　　　　　② 然后再根据条件二过滤为子集C；

Java8 之前的做法：

import java.util.ArrayList;
import java.util.List;
    public class DemoNormalFilter {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("张强");
            list.add("张三丰");
            List<String> zhangList = new ArrayList<>();
            for (String name : list) {
                if (name.startsWith("张")) {
                    zhangList.add(name);
                }
            }
            List<String> shortList = new ArrayList<>();
            for (String name : zhangList) {
                if (name.length() == 3) {
                    shortList.add(name);
                }
            }
            for (String name : shortList) {
                System.out.println(name);
            }
        }
    }

这段代码中含有三个循环，每一个作用不同：
　　　　　　 ① 首先筛选出所有姓张的人；
　　　　　　 ② 然后筛选名字有三个字的人；
　　　　　　 ③ 最后进行对结果进行打印输出。
　　　　 每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？
　　　　不是。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。

3、Stream 的更优写法

使用Java8的Stream API，代码实现：

import java.util.ArrayList;
import java.util.List;

    public class DemoStreamFilter {
        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("张"))
                    .filter(s -> s.length() == 3)
                    .forEach(System.out::println);
        }
    }

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。

代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

二、流式思想概述

整体来看，流式思想类似于工厂车间的“生产流水线”。更关注 操作的 元素。

当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。
在这里插入图片描述
这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。

图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。

这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。集合中的元素还是最开始的集合，没有变化。

当终结方法 count执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性 。

注意：Stream（流）是一个来自数据源的元素队列；它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。这个元素队列 会按照我们构造的一个函数模型 依次进行处理。

当使用一个流的时候，通常包括三个基本步骤：

	获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，

每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

三、如何获取Stream流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）

获取一个流非常简单，有以下几种常用的方式：

  • 所有的 Collection 集合都可以通过 stream 默认方法获取流；list.stream();
  • Stream 接口的静态方法 of 可以获取数组对应的流；Stream.of(array);

1、根据 Collection 获取流

java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

			List<String> list = new ArrayList<>();
            // ...
            Stream<String> stream1 = list.stream();

2、根据 Map 获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况：

			Map<String, String> map = new HashMap<>();
            // ...
            Stream<String> keyStream = map.keySet().stream();
            Stream<String> valueStream = map.values().stream();
            Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();

3、根据数组获取流

如果使用的是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法of ，使用很简单：

import java.util.stream.Stream;

    public class DemoGetStream {
        public static void main(String[] args) {
            String[] array = {"张无忌", "张翠山", "张三丰", "张一元"};
            Stream<String> stream = Stream.of(array);
        }
    }

注意： of 方法的参数其实是一个可变参数，所以支持数组。

四、常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

  • 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
  • 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法。

1、逐一处理：forEach

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，是一个消费型接口。会将每一个流元素交给该函数进行处理。

Consumer 接口
java.util.function.Consumer接口是一个消费型接口。
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

基本使用：

import java.util.stream.Stream;
　　public class DemoStreamForEach {
    　　public static void main(String[] args) {
        　　Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
        　　stream.forEach(name‐> System.out.println(name));
　　　　}
　　}

2、过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

Predicate 接口：
boolean test(T t);

该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

import java.util.stream.Stream;
    public class DemoStreamFilter {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.filter(s ‐> s.startsWith("张"));
        }
    }

在这里通过Lambda表达式来指定了筛选的条件：必须姓张.

3、映射：map

如果需要将当前流中的T类型数据转换为另一种R类型的流，可以使用 map 方法。方法签名：
该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Function 接口： 这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。
·R apply(T t);·

	  //直接把元素转换类型
	  public class DemoStreamMap {
	　　　　public static void main(String[] args) {
	　　　　　　Stream<String> original = Stream.of("10", "12", "18");
	　　　　　　Stream<Integer> result = original.map(str‐>Integer.parseInt(str));
	　　　　}
	　　}

		//把集合元素的某个属性进行转换
		List<Person> list = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            Person person = new Person();
            person.setAge(i*10);
            person.setName(i*100+"");
            list.add(person);
        }
        List<Integer> collect = list.stream().map(s-> Integer.valueOf(s.getName())).collect(Collectors.toList());

//把集合元素的属性进行收集
List<String> collect = list.stream().map(Person::getName).collect(Collectors.toList());

这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。

4、统计个数：count

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：
该方法返回一个long值代表元素个数（不再像旧集合那样是int值）
long count();

import java.util.stream.Stream;
　　public class DemoStreamCount {
　　　　public static void main(String[] args) {
　　　　　　Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
　　　　　　Stream<String> result = original.filter(s ‐> s.startsWith("张"));
　　　　　　System.out.println(result.count()); // 2
　　　　}
　　}

5、取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。方法签名
Stream<T> limit(long maxSize);　　　
　
参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。

基本使用：

public class DemoStreamLimit {
        public static void main(String[] args) {
            Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
            Stream<String> result = original.limit(2);
            System.out.println(result.count()); // 2
　　　　}
　　}

6、跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n);
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

import java.util.stream.Stream;
　　public class DemoStreamSkip {
　　　　public static void main(String[] args) {
　　　　　　Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
　　　　　　Stream<String> result = original.skip(2);
　　　　　　System.out.println(result.count()); // 1
　　　　}
　　}

7、组合：concat

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
注意：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

public class DemoStreamConcat {
　　　　　　public static void main(String[] args) {
　　　　　　　　Stream<String> streamA = Stream.of("张无忌");
　　　　　　　　Stream<String> streamB = Stream.of("张翠山");
　　　　　　　　Stream<String> result = Stream.concat(streamA, streamB);
　　　　　　}
　　　　}

8、排序sorted

正常排序

qdmNodeEntities.stream()
	.sorted(Comparator.comparing(ClusterOverviewNodeInfoDTO::getType)  //按照这个排序，
	.thenComparing(ClusterOverviewNodeInfoDTO::getId))		//若有相等的，再按照这个排序
	.collect(Collectors.toList());

倒叙：

sorted(Comparator.comparing(SnapshotDatabaseDTO::getCreateDateTime).reversed())

9、流的收集操作collect

ref: https://blog.csdn.net/qq_38737586/article/details/119530697

案例

方式一：使用传统的for循环（或增强for循环）

public class DemoArrayListNames {
        public static void main(String[] args) {
            List<String> one = new ArrayList<>();
            // ...
            List<String> two = new ArrayList<>();
            // ...

            // 第一个队伍只要名字为3个字的成员姓名；
            List<String> oneA = new ArrayList<>();
            for (String name : one) {
                if (name.length() == 3) {
                    oneA.add(name);
                }
            }

            // 第一个队伍筛选之后只要前3个人；
            List<String> oneB = new ArrayList<>();
            for (int i = 0; i < 3; i++) {
                oneB.add(oneA.get(i));
            }

            // 第二个队伍只要姓张的成员姓名；
            List<String> twoA = new ArrayList<>();
            for (String name : two) {
                if (name.startsWith("张")) {
                    twoA.add(name);
                }
            }

            // 第二个队伍筛选之后不要前2个人；
            List<String> twoB = new ArrayList<>();
            for (int i = 2; i < twoA.size(); i++) {
                twoB.add(twoA.get(i));
            }

            // 将两个队伍合并为一个队伍；
            List<String> totalNames = new ArrayList<>();
            totalNames.addAll(oneB);
            totalNames.addAll(twoB);
            // 根据姓名创建Person对象；
            List<Person> totalPersonList = new ArrayList<>();
            for (String name : totalNames) {
                totalPersonList.add(new Person(name));
            }
            // 打印整个队伍的Person对象信息。
            for (Person person : totalPersonList) {
                System.out.println(person);
            }
        }
    }

方式二：使用 Stream 流式处理方式。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
    public class DemoStreamNames {
        public static void main(String[] args) {
            List<String> one = new ArrayList<>();
            // ...
            List<String> two = new ArrayList<>();
            // ...
            // 第一个队伍只要名字为3个字的成员姓名；
            // 第一个队伍筛选之后只要前3个人；
            Stream<String> streamOne = one.stream().filter(s->s.length() == 3).limit(3);

            // 第二个队伍只要姓张的成员姓名；
            // 第二个队伍筛选之后不要前2个人；
            Stream<String> streamTwo = two.stream().filter(s->s.startsWith("张")).skip(2);

            // 将两个队伍合并为一个队伍；
            // 根据姓名创建Person对象；
            // 打印整个队伍的Person对象信息。
            Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
        }
    }
小码哥222
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK8新特性---下篇---Stream
qq_44447372的博客
02-05 1775
目录 4.1 简单介绍 4.2Stream的组成部分 4.2.1 数据源 4.2.2 中间操作 4.2.2.1 filter 4.2.2.2 map 4.2.2.3 distinct 4.2.2.4 sort 4.2.2.5 flatMap 4.2.3 终止操作 4.2.3.1 forEach 4.2.3.2 allMatch && anyMatch && noneMatch 4.2.3.3 findFirst和findAny 查找， 4.2.3.
【Java】Stream 流常见写法总结
yuxiangdeming的博客
02-03 1030
stream 常见用法总结
Java Stream 的一些常用写法，速查手册
老三的博客
07-26 305
@ Java Stream 的一些常用写法，速查手册 List按属性去重 List<T> uniqueMilk = list.stream().collect(collectingAndThen( toCollection(() -> new TreeSet<>(comparing(n->n.getXxx()))),ArrayList::new) ); 持续更新…
JDK8 常用的Stream流操作 方法
肥宅友的博客
06-18 2040
Stream流操作、Stream流map方法、Stream流排序、Stream流map和peek的区别、Stream流过滤filter、Stream创建集合、Stream和迭代器遍历集合。
Java8 Stream流操作最强详解版
qq_42003527的博客
08-18 2830
Java8 Stream流操作最强详解版
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
Collectors 是 Java 8 加入的操作类，主要用于对 Stream 流进行终结操作派生出基于各种策略的结果集。我们可以借助于 Stream 来熟悉一下 Collectors。 2. Collectors 的方法 Collectors 提供了一系列的静态方法供...
java8stream源码-java8:Java8——函数式编程
06-04
java8流源码java8 Java 8 —— 函数式编程 介绍 该存储库包含例如 Java 8 In Action 和 Java 8 Lambdas Pragmatic Functional Programming 一书中的源代码。 同时自己也做了一些扩展使用，修复了源码中的bug。 例如 ...
JAVA学习笔记2020/4/27——Stream流、方法引用
01-20
在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 引言 传统集合的多步遍历代码几乎所有的集合（如Collection接口或Map接口等）都支持直接或间接的...
Java8新特性之方法引用&Stream流应用实例md，学习代码
最新发布
06-21
接下来，我们转向另一个核心特性——Stream API。Stream API提供了一种全新的处理数据的方式，它支持链式操作，使得代码更加简洁且易于理解。Stream可以来源于集合、数组或其他数据源，可以执行过滤、映射、排序等...
Java————二次方程求解.doc
09-30
在 Java 中，输入输出是通过流（Stream）来实现的。InputStream 和 OutputStream 分别对应输入流和输出流。BufferedReader 是一个输入流，用于从命令行读取用户输入。在本例中，我们使用 BufferedReader 读取用户...
JDK8特性（Stream API）
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
01-21 416
这些示例演示了Stream API在不同场景下的使用方式。Stream API的强大之处在于它提供了一种声明性的、函数式的处理方式，使得代码更具表达力和可读性。根据具体的业务需求，可以使用不同的中间操作和终端操作来构建复杂的数据处理流程。在Java中，Stream API可以应用于集合（Collection）类，数组以及其他数据源。
JAVA stream流
songkunupc的博客
09-25 260
3.Stream流 JDK1.8后出现的，用于解决集合和数组现有的弊端。 关注做什么而不是怎么做 stream并不存储元素，而是按需计算 两个特性： 1. pipelining（只能被消费一次） 2. 内部迭代 3.1 获取Stream * 所有的Collection可以通过stream默认方法 * Stream接口的of方法 // 1.集合转换为Stream list<String&g...
JDK8新特性之stream流
m0_74315688的博客
06-23 353
欢迎关注辉辉，持续更新中~
Java8 使用 stream().filter()过滤List对象
qq_33240556的博客
01-10 1876
方法时，需要提供一个Lambda表达式作为参数，该表达式指定了过滤的条件。在上面的示例中，我们使用了一个简单的Lambda表达式。，表示只保留数字大于等于3的元素。可以根据具体的需求，使用不同的Lambda表达式来过滤不同的数据。在上面的代码中，我们首先创建了一个包含一些数字的List对象。方法将过滤后的元素收集到一个新的List对象中，并输出结果。方法将List对象转换为一个Stream对象，并使用。方法过滤出数字大于等于3的元素。在Java 8中，可以使用。需要注意的是，在使用。
stream JDK8使用大全
qq_58746475的博客
10-12 219
jdk8 大全
获取List中的元素ID（某属性）然后返回新的List集合(stream写法）
坐等夕阳落time的博客
11-20 8380
获取List中的元素ID（某属性）然后返回新的List集合
JAVA的Stream流操作 简单总结
l10711097061的博客
10-14 4174
JAVA的Stream流操作 简单总结
jdk8的特性stream().map()
可小辉的博客
08-22 2786
在Java 8中stream().map()，您可以将对象转换为其他对象 1.大写字符串列表 package com.mkyong.java8; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class TestJava8 { public static void main(String
如何在Java 8中使用filter（）方法
热门推荐
最佳 Java 编程
06-10 1万+
Java 8 Stream接口引入了filter()方法，该方法可用于根据特定条件从对象集合中过滤掉某些元素。 应将此条件指定为filter()方法接受为参数的谓词 。 java.util.function.Predicate接口定义了一个名为test()的抽象方法，该方法接受通用类型T的对象并返回一个布尔值。 让我们进行一些编码以更清楚地了解过滤器方法。 请看以下菜式。 publ...
Java 8中处理集合的优雅姿势——Stream
05-19
Java 8中新增的Stream是一种处理集合的优雅姿势。 Stream是对集合（Collection）对象功能的增强，它能以一种声明的方式来处理数据，实现类似于SQL语句的操作。Stream不会改变原有的数据结构，它会生成一个新的Stream，同时支持并行化操作。 Stream的核心思想是将数据看作是流，而流上可以进行各种操作，比如过滤、排序、映射等。这样可以将数据处理过程变得非常简洁和灵活。 下面是一些Stream的常用操作： 1. filter：过滤符合条件的元素 ``` List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.stream().filter(i -> i % 2 == 0).forEach(System.out::println); //输出2, 4 ``` 2. map：将元素转换成另一种类型 ``` List<String> list = Arrays.asList("apple", "banana", "orange"); list.stream().map(s -> s.toUpperCase()).forEach(System.out::println); //输出APPLE, BANANA, ORANGE ``` 3. sorted：对元素进行排序 ``` List<Integer> list = Arrays.asList(5, 2, 1, 4, 3); list.stream().sorted().forEach(System.out::println); //输出1, 2, 3, 4, 5 ``` 4. distinct：去重 ``` List<Integer> list = Arrays.asList(1, 2, 3, 2, 1); list.stream().distinct().forEach(System.out::println); //输出1, 2, 3 ``` 5. limit：限制元素个数 ``` List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.stream().limit(3).forEach(System.out::println); //输出1, 2, 3 ``` 6. skip：跳过元素 ``` List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.stream().skip(2).forEach(System.out::println); //输出3, 4, 5 ``` 7. reduce：对元素进行聚合操作 ``` List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); int sum = list.stream().reduce(0, (a, b) -> a + b); System.out.println(sum); //输出15 ``` Stream的操作可以组合起来形成一个流水线，每个操作都会返回一个新的Stream对象，这样就可以形成一个操作序列。最后调用终止操作（如forEach、findAny等）才会触发所有中间操作的执行。 使用Stream处理集合的代码通常比使用传统的循环更简洁，同时也更易于并行化处理，提高了程序的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值