Java 8：Stream流详细案例学习

最新推荐文章于 2023-07-10 20:35:45 发布
最新推荐文章于 2023-07-10 20:35:45 发布
阅读量444 收藏 2
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43230007/article/details/108422663
版权

Java 8：Stream流详细案例学习

文章目录

前言

Stream流是jdk 1.8 引入的新特性，极大地方便了我们对集合的处理(特别是一些对于一些集合的查询操作)。而且减少了我们的代码量，而且在数据量大的时候支持并行处理提升效率，我们可以学习一下其中常用的方法和一些注意点以及原理。

常用方法

过滤方法

返回目录

1.1 filter(Predicate<? super T>):Stream

根据规则过滤元素，参数中返回true就会留在Stream流中。

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A",23),
                new Person("B",22),
                new Person("C",28),
                new Person("D",25),
                new Person("E",13)
        );
        list.stream()
                .filter(person -> person.getAge() > 20)
                .forEach(person -> System.out.println(person));
    }
}

Person(name=A, age=23)
Person(name=B, age=22)
Person(name=C, age=28)
Person(name=D, age=25)

1.2 distinct():Stream

根据对象的equals方法去除重复元素

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A",23),
                new Person("A",23),
                new Person("B",22),
                new Person("C",28),
                new Person("C",28),
                new Person("D",25),
                new Person("E",13)
        );
        list.stream()
                .distinct()
                .forEach(s -> System.out.println(s));
    }
}

Person(name=A, age=23)
Person(name=B, age=22)
Person(name=C, age=28)
Person(name=D, age=25)
Person(name=E, age=13)

1.3 limit(long maxSize):Stream

返回流中的n个元素，注意这个流是无序流还是有序流。

1.4 skip(long n):Stream

跳过流中的前n个元素，注意这个流是无序流还是有序流。

映射方法

返回目录

1.1 map(Function<? super T,? extends R>):Stream

给出一个对象T，然后根据逻辑返回对象R作为Stream流中的元素。

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A",23),
                new Person("B",22),
                new Person("C",28),
                new Person("D",25),
                new Person("E",13)
        );
        list.stream()
                .map(Person::getName)
                .forEach(s -> System.out.println(s));
    }
}

A
B
C
D
E

排序方法

返回目录

1.1 sorted():Stream

需要元数据实现Comparable接口有着排序规则

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A",23),
                new Person("B",22),
                new Person("C",28),
                new Person("C",28),
                new Person("D",25),
                new Person("E",13)
        );
        list.stream()
                .sorted()
                .forEach(s -> System.out.println(s));
    }
}

@Data
@Builder
class Person implements Comparable{
    private String name;
    private Integer age;

    @Override
    public int compareTo(Object o) {
        Person o1 = (Person) o;
        return this.getAge() - o1.getAge();
    }
}

Person(name=E, age=13)
Person(name=B, age=22)
Person(name=A, age=23)
Person(name=D, age=25)
Person(name=C, age=28)
Person(name=C, age=28)

1.2 sorted(Comparator<? super T> comparator):Stream

Stream流也提供了非常方便的使用方法，我们可以灵活的定义排序方法。

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A",23),
                new Person("B",22),
                new Person("C",28),
                new Person("C",28),
                new Person("D",25),
                new Person("E",13)
        );
        list.stream()
                .sorted(Comparator.comparingInt(Person::getAge))
                .forEach(System.out::println);
    }
}

Person(name=E, age=13)
Person(name=B, age=22)
Person(name=A, age=23)
Person(name=D, age=25)
Person(name=C, age=28)
Person(name=C, age=28)

帮助Stream流调试方法

返回目录

1.1 peek(Consumer<? super T> action):Stream

这个方法主要用来调试Stream流，可以简单理解为只要流中遍历了一个元素我们就可以通过peek对这个元素进行操作(通常打印这个元素)

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                new Person("B", 22),
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );
        list.stream()
                .peek(person -> System.out.println(person.getName().toUpperCase()))
                .peek(person -> System.out.println(person.getName().toLowerCase()))
                .peek(person -> System.out.println("-----------"))
                .count();
    }
}

A
a
-----------
B
b
-----------
C
c
-----------
C
c
-----------
D
d
-----------
E
e
-----------

遍历方法

返回目录

1.1 forEach(Consumer<? super T>):void

遍历但是不能保证遍历顺序，因为这个方法支持并行操作。

转换方法

返回目录

1.1 toArray():Object[]

直接返回一个Object数组

1.2 toArray(IntFunction<A[]> generator): A[]

返回一个指定对象的数组

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                new Person("B", 22),
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );
        Person[] people = list.stream()
                .filter(person -> person.getAge() > 22)
                .toArray(Person[]::new);

        Stream.of(people).forEach(System.out::println);
    }
}

Person(name=A, age=23)
Person(name=C, age=28)
Person(name=C, age=28)
Person(name=D, age=25)

1.2 reduce(T identity, BinaryOperator accumulator):T

累加器，对流中的元素进行累加逻辑计算并且得出最终的结果

具体使用参考博客

1.3 collect(Supplier supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner): R

比较复杂的集合操作，三个参数的逻辑操作：

  • supplier:容器提供者，主要提供一个新的容器
  • accumulator:累加器，其中函数式方法中提供两个方法，一个是supplier提供的新容器，一个是Stream流中的元素，然后对Stream流中的元素进行过滤放到supplier提供的容器中
  • combiner:合并器，将累加器得到的元素进行二次过滤，然后放到一个新的容器中
public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                new Person("B", 22),
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );
         
    
        list.stream().collect(
                // 1. 创建新的容器一
                HashMap<String, List<Person>>::new,
                // 2. 向我们新的容器里面放置元素成为容器二
                (map1, person) -> {
                    String key = person.getName();
                    List<Person> pList = map1.getOrDefault(key, new ArrayList<>());
                    pList.add(person);
                    map1.put(key, pList);
                },
                // 3. 队容器二进行过滤然后放入新的容器三种
                (map2, map3) -> map3.putAll(map2)
        ).forEach((key, person) -> {
            System.out.println("Key: " + key);
            System.out.println("Value: " + person);
        });
    }
}

Key: A
Value: [Person(name=A, age=23)]
Key: B
Value: [Person(name=B, age=22)]
Key: C
Value: [Person(name=C, age=28), Person(name=C, age=28)]
Key: D
Value: [Person(name=D, age=25)]
Key: E
Value: [Person(name=E, age=13)]

1.4 collect(Collector<? super T, A, R> collector):<R, A> R

通常用作返回一个Collection，常常用来返回Map或者List

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                new Person("B", 22),
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );

        // 直接返回List
        List<String> plist = list.stream().map(Person::getName)
                .collect(Collectors.toList());

        // 返回需要的Collection
        Set<String> set = list.stream().map(Person::getName)
                .collect(Collectors.toCollection(TreeSet::new));

        // 返回字符串
        String joined = list.stream()
                .map(Person::getName)
                .collect(Collectors.joining(", "));

        // 返回总和
        int total = list.stream()
                .collect(Collectors.summingInt(Person::getAge));

        // 返回一个分组Map
        Map<String, List<Person>> groupMap
                = list.stream()
                .collect(Collectors.groupingBy(Person::getName));

        // 返回一个分组Map，并且有其他逻辑分组操作
        Map<String, Integer> totalMap
                = list.stream()
                .collect(Collectors.groupingBy(Person::getName,
                        Collectors.summingInt(Person::getAge)));

        // 自己定义分组逻辑并且获得分组Map
        Map<Boolean, List<Person>> myLogicGroupMap =
                list.stream()
                        // 根据23岁分成两个组别
                        .collect(Collectors.partitioningBy(s -> s.getAge() >= 23));

    }
}

1.5 聚合函数 max() min() count()

判断匹配方法

返回目录

1.1 anyMatch(Predicate<? super T> predicate):boolean allMatch(Predicate<? super T> predicate):boolean

  • 只要元素中有一个元素满足条件就返回true
  • 需要所有元素满足条件就返回true
public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                new Person("B", 22),
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );
        // true
        boolean b = list.stream().anyMatch(person -> person.getAge() > 22);
        System.out.println(b);
        // false
        b = list.stream().allMatch(person -> person.getAge() > 22);
        System.out.println(b);
    }
}

构建生成Stream方法

返回目录

  • of(T …)
  • concat(Stream s1,Stream s2)
public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                new Person("B", 22),
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );

        Stream.concat(list.stream(), list.stream())
                .forEach(System.out::println);

        Stream.of(1, 2, 3, 4).forEach(System.out::println);
    }
}

Person(name=A, age=23)
Person(name=B, age=22)
Person(name=C, age=28)
Person(name=C, age=28)
Person(name=D, age=25)
Person(name=E, age=13)
Person(name=A, age=23)
Person(name=B, age=22)
Person(name=C, age=28)
Person(name=C, age=28)
Person(name=D, age=25)
Person(name=E, age=13)
1
2
3
4

Stream流的特殊特性

支持顺序和并行聚合操作

返回目录

1.1 例子

int sum = widgets.stream()
              .filter(w -> w.getColor() == RED)
              .mapToInt(w -> w.getWeight())
              .sum();

1.2 顺序操作

例子中先是根据顺序首先过滤完毕后得到结果集1，然后对结果集1进行转换得到结果集2，最后进行聚合得到求和结果集3.

1.3 并行聚合操作

在sum()函数中就是Stream流的聚合操作

流的懒加载特性

返回目录

Stream流的操作可以根据是否是终端操作分为两大类，流会根据这两种操作来决定是否执行流中元数据的处理。

  • 情况一：Stream流中没有终端方法执行，那么Stream流就不会执行

  • 情况二：Stream流中有终端方法执行，那么Stream流就会执行

流和集合之间的区别

返回目录

流和集合表面上看起来非常相似，但是两者关注的目标有所不同。集合更加关注高效的管理，比如我们直接可以通过集合对象list的get(n)方法直接获取其中指定位置的元素并且操作管理这个元素，但是stream对象就没有方法直接这么简单的获取数据源目标位置的元素，这里就体现了集合管理的更加高效。Stream流更加关注数据的查询，在查询和过滤转换上的操作来说，Stream的效率和代码量都体现出了巨大的优势，使用Stream就好像写文章，并且这个文章上下文练习非常紧密，这就是流之间的传递性。

以函数式接口作为流的方法需要数据源中不能有null值

返回目录

因为函数式接口往往需要指定一个对象然后进行处理，而Stream流中的元素就是直接对其中的元素进行处理，一旦数据源中出现了null元素，然后我们还使用了函数式接口对null元素进行了处理就会出现问题

public class StreamTest {
    @Test
    public void test01() {
        List<Person> list = Arrays.asList(
                new Person("A", 23),
                // 故意放入null元素
                null,
                null,
                new Person("C", 28),
                new Person("C", 28),
                new Person("D", 25),
                new Person("E", 13)
        );

        list.stream().
                // 这里map中的函数式几口会接收到null元素，会导致异常的发生
                map(Person::getAge).forEach(System.out::println);
    }
}

java.lang.NullPointerException
	at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)
	at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
	at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482)
	at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472)
	at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)

流中资源的关闭

返回目录

  • 由数组、集合产生的流并不需要我们自己关闭，Stream流中继承了AutoCloseable接口会自动关闭资源流
  • 由I/O产生的流需要我们进行特殊的关闭，我们可以将资源声明在 try-with-resource中声明

流可以设置顺序或者并行执行

返回目录

流管道可以依次或者在执行平行 。 该执行模式是流的属性。 流与顺序或并行执行的最初的选择创建。 （例如， Collection.stream()创建了一个连续的流，并且Collection.parallelStream()创建了一个并联的一个。）的执行模式的这种选择可以通过被修改sequential()或parallel()方法，并且可以与被查询所述isParallel()方法。

并行流解析

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。串行流则相反，并行流的底层其实就是ForkJoin框架的一个实现。

小结

  • 如果对集合的操作仅仅只是查询过滤其中的元素，那么推荐使用Stream流，不仅减少了代码量而且提升了效率
  • 并行流的使用需要注意
    • 留意装箱。自动装箱和拆箱操作会大大降低性能。Java8中有原始类型流（IntStream、LongStream、DoubleStream）来避免这种操作
    • 有些操作本身在并行流上的性能就比顺序流差。特别是limit、findFirst等依赖于元素顺序的操作，它们在并行流上执行的代价非常大。
    • 在大数量数据的处理才去使用并行流，否则不要去使用
  • Stream流中关系到函数式接口作为参数的方法，需要注意数据源是否有null对象
神火星跳伞队队长
关注
专栏目录
java8中Stream的使用以及分割list案例
08-24
下面将详细介绍Java8中Stream的使用和分割List案例。 一、Stream的优势 Stream api的优势在于可以配合Lambda表达式极大提高编程效率，代码简洁易懂。使用Stream api可以写出高性能的并发程序，不需要写传统的多...
Stream流常用方法与应用案例大全
u010837355的博客
04-11 1763
        Java8 中添加了一个新的接口类 Stream，相当于高级版的Iterator，通过Lambda 表达式对集合进行各种非常便利、高效的聚合操作（Aggregate Operation），或者大批量数据操作(Bulk Data Operation）。Stream不仅可以通过串行的方式实现数据操作，还可以通过并行的方式处理大批量数据，提高数据的处理效率。      
9张图，32个案例带你轻松玩转Java stream
q66562636的博客
04-01 239
Java8 中增加了 Stream 处理，可以配合 Lambda 表达式来使用，让操作集合非常便利。虽然我们平时经常使用 Stream，但用到的方法其实非常少，这篇文章就来完整的介绍 Stream 的使用。 Stream 提供的方法非常多，按照调用当前方法是否结束流处理，可以分为中间操作和结束操作。 对于中间操作，又可以分为有状态的操作和无状态操作： 无状态的操作是指当前元素的操作不受前面元素的影响。 有状态的操作是指当前元素的操作需要等所有元素处理完之后才能进行。 对于结束操作，又可以分为
Stream快速入门+大量案例（超详细）
最新发布
lll7777773的博客
07-10 1403
stream流快速入门+案例分析
Java8中stream流处理数据21个小案例(学习使用)
七一
02-02 655
案例19：重量大于20的分为一组，重量小于20的分为一组,只要分组的重量最大的。案例14：按颜色分组，挑选出每个分组中重量最大的,重量一样的话，根据城市名字。案例16：按照颜色分组，找出每个分组下的最大值，总数。案例20：按照重量大于20的一组，小于20的一组，找出每组个数。案例2：筛选要么是重量大于23的红苹果，要么是绿苹果的集合。案例17：重量大于20的分为一组，重量小于20的分为一组。案例15：同时找出苹果的总数量，最大值，最小值，平均值。案例12：按照苹果颜色分组，颜色一样按照重量分组。
浅谈java8 stream flatMap流的扁平化操作
08-24
浅谈 Java8 Stream flatMap 流的扁平化操作 Java8 中的 Stream 是一个新概念，它不是输入输出的 Stream 流，而是一种用函数式编程方式在集合类上进行复杂操作的工具。Stream 提供了两种操作：中间操作和终止操作。...
java8 stream 由一个list转化成另一个list案例
08-24
Java8 Stream 由一个 List 转化成另一个 List 案例 Java8 Stream 是一个功能强大的工具，可以将一个 List 转化成另一个 List，今天我们就来探讨这个话题。 什么是 Java8 Stream Java8 Stream 是 Java 语言的一个...
Java8 stream 中利用 groupingBy 进行多字段分组求和案例
09-07
在Java 8中，Stream API引入了许多新的特性，极大地增强了处理集合数据的能力。其中，`groupingBy`方法就是其中一个非常实用的功能，它允许我们根据指定的条件对集合中的元素进行分组。在这个案例中，我们将探讨如何...
Stream_Java8.pdf
01-05
根据提供的文件信息，本文将详细介绍Java 8中Stream API的核心概念、使用方法及其实战案例。Stream API作为Java 8的重要特性之一，极大地简化了集合处理的代码编写过程，提升了程序的可读性和效率。 ### Stream概述...
Stream流综合案例
qq_44948905的博客
12-03 529
Stream流综合案例 现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下 若干操作步骤： \1. 第一个队伍只要名字为3个字的成员姓名； \2. 第一个队伍筛选之后只要前3个人； \3. 第二个队伍只要姓张的成员姓名； \4. 第二个队伍筛选之后不要前2个人； \5. 将两个队伍合并为一个队伍； \6. 根据姓名创建 Person 对象； \7. 打印整个队伍的Person对象信息。 两个队伍（集合）的代码如下 public class
java8(Stream)-案例练习-9
Tiglle的博客
03-16 260
/* * 文件名：StreamTest * 版权：Copyright by 启海云仓 qihaiyun.com * 描述： * 创建人：Administrator * 创建时间：2019/9/29 * 修改理由： * 修改内容： */ package Stream_2.stream案例练习; import Entity.Employee; import org.junit.Before; import org.junit.Test; import java.util.Arrays; im
Stream流的操作案例
我给媳妇儿讲java
10-24 466
asd
Stream实例
stay_the_course的博客
05-29 640
0.接口简述 在对于一个 Stream 进行多次转换操作 (Intermediate 操作)，每次都对 Stream 的每个元素进行转换，而且是执行多次，这样时间复杂度就是 N（转换次数）个 for 循环里把所有操作都做掉的总和吗？其实不是这样的，转换操作都是 lazy 的，多个转换操作只会在 Terminal 操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream 里有个操作函数...
java stream 案例
weixin_41419401的博客
02-05 366
Stream操作分类 中间操作(Intermediate operations) 无状态(Stateless) unordered() filter() map() mapToInt() mapToLong() mapToDouble() flatMap() flatMapToInt() flatMapToLong() flatMapToDouble() peek() 有状态(...
JAVAWeb——response输出流
m0_37934678的博客
01-17 3489
1. response.getOutputStream()  *输出字节流，类型为：ServletOutputStream *只有print（）方法 2. response.getWriter(); *输出字符流，类型为：PrintWriter  *有print（）   write（） **print方法就是调用write方法实现的,也就是将object转换成String了而已。还有...
Java中Stream流综合案例
charismaless的博客
05-07 1138
需求：现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用Stream流,依次进行以下若干操作步骤： 1. 第一个队伍只要名字为3个字的成员姓名； 2. 第一个队伍筛选之后只要前3个人； 3. 第二个队伍只要姓张的成员姓名； 4. 第二个队伍筛选之后不要前2个人； 5. 将两个队伍合并为一个队伍； 6. 根据姓名创建Person对象； 7. 打印整个队伍的Person对象信息。 P...
Java8 Stream使用（超详细案例）
qq_38531706的博客
07-09 1063
目录一、stream是什么？二、stream操作分类三、stream的使用3.1.forEach()3.2.map()3.3.filter()3.3.distinct()3.4.allMatch()3.5.anyMatch()3.6.noneMatch()3.7.sorted()3.7.skip() + limit()分页3.7.分组3.8.统计3.9.字符串拼接3.10.集合转换3.11.reduce()3.12.Optional （扩展）3.13.findFirst()3.14.findAny()3.1
Java中Stream流的运用案例
qq_51438138的博客
03-20 192
Java中Stream流的运用案例
Java Stream流基础教程：简单应用与案例解析
"stream流的简单使用" 在Java中，Stream API是Java 8引入的一个重要特性，它提供了处理集合的新方式，支持函数式编程风格。Stream API可以让我们以声明式方式处理数据，使得代码更加简洁、高效。在这个案例中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值