首页 > 编程语言 >Java8的stream流让操作集合更容易

Java8的stream流让操作集合更容易

时间：2024-06-17 19:56:49浏览次数：27  
标签：stream Stream 流让 System println new Java8 out

概述

好久不见，最近忙于工作，好久没有发文章了，入职大公司，发现有些同事更喜欢使用stream流操作集合，故而自己也研究学习一下。事先声明：我并非原创，我只是学习并整理的大佬们的文章，原文章放在最后，有兴趣的可以去看看
Java8提供了Stream（流）处理集合的关键抽象概念，Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。它可以对集合进行操作，可以执行非常复杂的查找、过滤和映射数据等操作。Stream API 借助于同样新出现的Lambda表达式，极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

stream流的三个过程

  • 创建Stream
  • Stream中间处理
  • 终止Steam
    image

  1. 开始管道
    主要负责新建一个Stream流，或者基于现有的数组、List、Set、Map等集合类型对象创建出新的Stream流。
    image

  2. 中间管道
    负责对Stream进行处理操作，并返回一个新的Stream对象，中间管道操作可以进行叠加。
    image

  3. 终止管道
    顾名思义，通过终止管道操作之后，Stream流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。
    image

常用示例

开始管道

  1. 通过集合
 public static List<Employee> getEmployeeDataList(){
    List<Employee> list = new ArrayList<>();
     list.add(new Employee(1,"张三",20,8500D,1));
     list.add(new Employee(2,"李四",18,600D,1));
     list.add(new Employee(3,"王五",21,5500D,3));
     list.add(new Employee(4,"小白",30,8500D,2));
     return list;
 }

public static void main(String[] args) {
    List<Employee> employees = getEmployeeDataList();
    // 返回一个顺序流 （按照集合顺序获取）
    Stream<Employee> stream = employees.stream();
    // 返回一个并行流 （类似于线程去获取数据，无序）
    Stream<Employee> parallelStream = employees.parallelStream();
}
  1. 通过数组
public static void main(String[] args) {
    int[] arr = new int[]{1,2,3,4,5,6};
    IntStream intStream = Arrays.stream(arr);

    Employee e1 = new Employee(1, "张三", 20, 8500D, 1);
    Employee e2 = new Employee(2, "李四", 18, 600D, 1);
    Employee[] employees = new Employee[]{e1,e2};
    Stream<Employee> stream = Arrays.stream(employees);
}
  1. 通过Stream的of方法
public static void main(String[] args) {
 Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
}
  1. 通过无限流
public static void main(String[] args) {
    // 生成偶数
    Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);
    // 10个随机数
    Stream.generate(Math::random).limit(10).forEach(System.out::println);
}

中间管道

  1. filter：按照条件过滤符合要求的元素， 返回新的stream流

image

筛选工资大于8000的员工：

public static void main(String[] args) {
    List<Employee> employees = getEmployeeDataList();
    Stream<Employee> stream = employees.stream();
    stream.filter(e -> e.getSalary() > 8000).forEach(t->{
        System.out.println("工资大于八千的员工->>>"+t);
    });
}

image

  1. map：将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流

大小写转换：

public static void main(String[] args) {
    List<String> list = Arrays.asList("a", "b", "c", "d");
    list.stream().map(str -> str.toUpperCase(Locale.ROOT)).forEach(t-> System.out.println("大小写转换->>>"+t));
}

image

获取员工姓名大于3的员工姓名：
image

public static void main(String[] args) {
    // 获取员工姓名大于3的员工姓名
    List<Employee> list = getEmployeeDataList();
    Stream<String> nameStream = list.stream().map(Employee::getName);
    nameStream.filter(name -> name.length() > 3).forEach(t-> System.out.println("获取员工姓名大于3的员工->>>"+t));
}

image

  1. flatMap：将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为1个或者多个新类型的元素，返回新的stream流

使用flatMap()将流中的每一个元素链接成为一个流：

public class flatMapTest {
    public static void main(String[] args) {
        //创建用户列表
        List<String> userList = new ArrayList<String>();
        userList.add("康熙爷、莫愁、颜如玉");
        userList.add("纪晓岚、杜小月、和珅");
 
        //分割用户列表，使用flatMap()将流中的每一个元素链接成一个流。
        userList = userList.stream()
                .map(city -> city.split("、"))
                .flatMap(Arrays::stream)
                .collect(Collectors.toList());
 
        //遍历用户列表
        userList.forEach(System.out::println);
    }
}

image

  1. limit：仅保留集合前面指定个数的元素，返回新的stream流
  2. skip：跳过集合前面指定个数的元素，返回新的stream流

获取用户列表，要求跳过第1条数据后的前3条数据：

public class limitAndSkipTest {
    public static void main(String[] args) {
 
        List<User> userList = new ArrayList<User>();
        userList.add(new User(1, "康熙爷", "男", 32, "总裁办", BigDecimal.valueOf(3000)));
        userList.add(new User(2, "和珅", "男", 30, "财务部", BigDecimal.valueOf(1800)));
        userList.add(new User(3, "颜如玉", "女", 20, "人事部", BigDecimal.valueOf(1700)));
        userList.add(new User(4, "纪晓岚", "男", 29, "研发部", BigDecimal.valueOf(2000)));
        userList.add(new User(5, "杜小月", "女", 23, "人事部", BigDecimal.valueOf(1500)));
 
        List<User> limitAndSkipList = userList.stream().skip(1).limit(3).collect(Collectors.toList());
        limitAndSkipList.forEach(System.out::println);
 
    }
}

image

  1. concat：将两个流的数据合并起来为1个新的流，返回新的stream流
  2. distinct：对Stream中所有元素进行去重，返回新的stream流
public static void main(String[] args) {
    List<Employee> list = new ArrayList<>();
    list.add(new Employee(1,"张三",20,8500D,1));
    list.add(new Employee(1,"张三",20,8500D,1));
    list.add(new Employee(1,"张三",20,8500D,1));
    list.add(new Employee(1,"张三",20,8500D,1));
    list.add(new Employee(1,"张三",20,8500D,1));
    list.stream().distinct().forEach(t-> System.out.println("集合去重->>>"+t));
}

image

  1. sorted：对stream中所有的元素按照指定规则进行排序，返回新的stream流

image

先按照年龄从小到大排序，当年龄一样的时候，按照工资高低进行排序：

public static void main(String[] args) {
   List<Employee> list = getEmployeeDataList();
   list.stream().sorted((e1,e2)->{
       int age = Integer.compare(e1.getAge(),e2.getAge());
       if(age != 0){
           return age;
       }else {
           return Double.compare(e1.getSalary(),e2.getSalary());
       }
   }).forEach(System.out::println);
}
  1. peek：对stream流中的每个元素进行逐个遍历处理，返回处理后的stream流

peek方法可以不调整元素顺序和数量的情况下消费每一个元素，然后产生新的流，按文档上的说明，主要是用于对流执行的中间过程做debug的时候使用，因为Stream使用的时候一般都是链式调用的，所以可能会执行多次流操作，如果想看每个元素在多次流操作中间的流转情况，就可以使用这个方法实现

Stream.of("one", "two", "three", "four")
     .filter(e -> e.length() > 3)
     .peek(e -> System.out.println("Filtered value: " + e))
     .map(String::toUpperCase)
     .peek(e -> System.out.println("Mapped value: " + e))
     .collect(Collectors.toList());
     
输出：
Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR

终止管道

  1. count：返回stream处理后最终的元素个数
  2. max： 返回stream处理后的元素最大值
  3. min：返回stream处理后的元素最小值
  4. findFirst：找到第一个符合条件的元素时则终止流处理
  5. findAny：找到任何一个符合条件的元素时则退出流处理，这个对于串行流时与findFirst相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑
  6. anyMatch：返回一个boolean值，类似于isContains(),用于判断是否有符合条件的元素
  7. allMatch：返回一个boolean值，用于判断是否所有元素都符合条件
  8. noneMatch：返回一个boolean值， 用于判断是否所有元素都不符合条件
    使用 anyMatch()、allMatch()、noneMatch() 进行判断：
public class matchTest {
    public static void main(String[] args) {
 
        List<User> userList = new ArrayList<User>();
        userList.add(new User(1, "康熙爷", "男", 32, "总裁办", BigDecimal.valueOf(3000)));
        userList.add(new User(2, "和珅", "男", 30, "财务部", BigDecimal.valueOf(1800)));
        userList.add(new User(3, "颜如玉", "女", 20, "人事部", BigDecimal.valueOf(1700)));
        userList.add(new User(4, "纪晓岚", "男", 29, "研发部", BigDecimal.valueOf(2000)));
        userList.add(new User(5, "杜小月", "女", 23, "人事部", BigDecimal.valueOf(1500)));
 
        //判断用户列表中是否存在名称为“杜小月”的数据
        boolean result = userList.stream().anyMatch(user -> user.getName().equals("杜小月"));
 
        //判断用户名称是否都包含“杜小月”字段
        boolean result2 = userList.stream().allMatch(user -> user.getName().equals("杜小月"));
 
        //判断用户名称是否存在不包含“杜小月”字段
        boolean result3 = userList.stream().noneMatch(user -> user.getName().equals("杜小月"));
 
        //打印结果
        System.out.println("result=" + result);
        System.out.println("result2=" + result2);
        System.out.println("result3=" + result3);
 
    }
}

image

  1. collect： 将流转换为指定的类型，通过Collectors进行指定
  2. toArray：将流转换为数组
  3. iterator：将流转换为Iterator对象
  4. foreach：无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑

stream细节区分与避坑点

细节区分

  1. map与flatMap

    map与flatMap都是用于转换已有的元素为其它元素，区别点在于：
    - map 必须是一对一的，即每个元素都只能转换为1个新的元素
    - flatMap 可以是一对多的，即每个元素都可以转换为1个或者多个新的元素
    image
    比如：有一个字符串ID列表，现在需要将其转为User对象列表。可以使用map来实现

/**
 * 演示map的用途：一对一转换
 */
public void stringToIntMap() {
    List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");
    // 使用流操作
    List<User> results = ids.stream()
            .map(id -> {
                User user = new User();
                user.setId(id);
                return user;
            })
            .collect(Collectors.toList());
    System.out.println(results);
}

执行之后，会发现每一个元素都被转换为对应新的元素，但是前后总元素个数是一致的：

[User{id='205'}, 
 User{id='105'},
 User{id='308'}, 
 User{id='469'}, 
 User{id='627'}, 
 User{id='193'}, 
 User{id='111'}]

再比如：现有一个句子列表，需要将句子中每个单词都提取出来得到一个所有单词列表。这种情况用map就搞不定了，需要flatMap上场了：


public void stringToIntFlatmap() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 使用流操作
    List<String> results = sentences.stream()
            .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
            .collect(Collectors.toList());
    System.out.println(results);
}

执行结果如下，可以看到结果列表中元素个数是比原始列表元素个数要多的：

[hello, world, Jia, Gou, Wu, Dao]

flatMap操作的时候其实是先每个元素处理并返回一个新的Stream，然后将多个Stream展开合并为了一个完整的新的Stream

  1. peek和foreach方法

peek和foreach，都可以用于对元素进行遍历然后逐个的进行处理：
但根据前面的介绍，peek属于中间方法，而foreach属于终止方法。这也就意味着peek只能作为管道中途的一个处理步骤，而没法直接执行得到结果，其后面必须还要有其它终止操作的时候才会被执行；而foreach作为无返回值的终止方法，则可以直接执行相关操作

public void testPeekAndforeach() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 演示点1： 仅peek操作，最终不会执行
    System.out.println("----before peek----");
    sentences.stream().peek(sentence -> System.out.println(sentence));
    System.out.println("----after peek----");
    // 演示点2： 仅foreach操作，最终会执行
    System.out.println("----before foreach----");
    sentences.stream().forEach(sentence -> System.out.println(sentence));
    System.out.println("----after foreach----");
    // 演示点3： peek操作后面增加终止操作，peek会执行
    System.out.println("----before peek and count----");
    sentences.stream().peek(sentence -> System.out.println(sentence)).count();
    System.out.println("----after peek and count----");
}

输出结果可以看出，peek独自调用时并没有被执行、但peek后面加上终止操作之后便可以被执行，而foreach可以直接被执行：

----before peek----
----after peek----
----before foreach----
hello world
Jia Gou Wu Dao
----after foreach----
----before peek and count----
hello world
Jia Gou Wu Dao
----after peek and count----
  1. reduce
    reduce 是 Stream 的一个聚合方法，它可以把一个 Stream 的所有元素按照聚合函数聚合成一个结果。reduce 方法传入的对象是BinaryOperator 接口，它定义了一个 apply 方法，负责把上次累加的结果和本次的元素进行运算，并返回累加的结果。

举个例子，数组求和：

Optional<Integer> optional = Stream.of(1, 2, 3, 4, 5).reduce((a, b) -> a + b);
System.out.println(optional);
System.out.println(optional.orElse(-1));

结果如下：

Optional[15]
15 Optinal<T> 对象是一种包装器对象，它在值不存在的情况下会产生一个可替代物，二只有在值存在的情况下才会使用这个值。

避坑点

这里需要补充提醒下，一旦一个Stream被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错，看下面示例：

public void testHandleStreamAfterClosed() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    Stream<String> stream = ids.stream().filter(s -> s.length() > 2);
    // 统计stream操作后剩余的元素个数
    System.out.println(stream.count());
    System.out.println("-----下面会报错-----");
    // 判断是否有元素值等于205
    try {
        System.out.println(stream.anyMatch("205"::equals));
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("-----上面会报错-----");
}

执行的时候，结果如下：

6
-----下面会报错-----
java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
	at java.util.stream.ReferencePipeline.anyMatch(ReferencePipeline.java:449)
	at com.veezean.skills.stream.StreamService.testHandleStreamAfterClosed(StreamService.java:153)
	at com.veezean.skills.stream.StreamService.main(StreamService.java:176)
-----上面会报错-----

结果收集终止方法

因为Stream主要用于对集合数据的处理场景，所以除了上面几种获取简单结果的终止方法之外，更多的场景是获取一个集合类的结果对象，比如List、Set或者HashMap等。

这里就需要collect方法出场了，它可以支持生成如下类型的结果数据：

  • 一个集合类，比如List、Set或者HashMap等
  • StringBuilder对象，支持将多个字符串进行拼接处理并输出拼接后结果
  • 一个可以记录个数或者计算总和的对象（数据批量运算统计）

生成集合

public void testCollectStopOptions() {
    List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));
    // collect成list
    List<Dept> collectList = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toList());
    System.out.println("collectList:" + collectList);
    // collect成Set
    Set<Dept> collectSet = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toSet());
    System.out.println("collectSet:" + collectSet);
    // collect成HashMap，key为id，value为Dept对象
    Map<Integer, Dept> collectMap = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toMap(Dept::getId, dept -> dept));
    System.out.println("collectMap:" + collectMap);
}

结果如下：

collectList:[Dept{id=22}, Dept{id=23}]
collectSet:[Dept{id=23}, Dept{id=22}]
collectMap:{22=Dept{id=22}, 23=Dept{id=23}}

生成拼接字符串

使用collect实现：

public void testCollectJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    String joinResult = ids.stream().collect(Collectors.joining(","));
    System.out.println("拼接后：" + joinResult);
}

结果：

拼接后：205,10,308,49,627,193,111,193

数据批量数学运算

还有一种场景，实际使用的时候可能会比较少，就是使用collect生成数字数据的总和信息，也可以了解下实现方式：

public void testNumberCalculate() {
    List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
    // 计算平均值
    Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
    System.out.println("平均值：" + average);
    // 数据统计信息
    IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
    System.out.println("数据统计信息： " + summary);
}

上面的例子中，使用collect方法来对list中元素值进行数学运算，结果如下：

平均值：30.0
总和： IntSummaryStatistics{count=5, sum=150, min=10, average=30.000000, max=50}

总结

Stream相较于传统的foreach的方式处理stream，到底有啥优势？

根据前面的介绍，我们应该可以得出如下几点答案：

  • 代码更简洁、偏声明式的编码风格，更容易体现出代码的逻辑意图
  • 逻辑间解耦，一个stream中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可
  • 并行流场景效率会比迭代器逐个循环更高
  • 函数式接口，延迟执行的特性，中间管道操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行，可以避免一些中间不必要的操作消耗

当然了，Stream也不全是优点，在有些方面也有其弊端：

  • 代码调测debug不便
  • 程序员从历史写法切换到Stream时，需要一定的适应时间

参考：
全面吃透JAVA Stream流操作，让代码更加的优雅
Java8使用Stream流实现List列表的遍历、统计、排序等
Java8 Stream 用法大全
Java 8中 Stream 流详解

标签：stream,Stream,流让,System,println,new,Java8,out
From： https://www.cnblogs.com/beijie/p/18252372

相关文章

  • WPF StreamGeometry
    usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Net.Http;usingSystem.Text;usingSystem.Threading.Tasks;usingSystem.Windows;usingSystem.Windows.Controls;usingSystem.Windows.Data;usingSystem.Windows.Documents;usin......
  • java8之后为神马舍弃Date拥抱LocalDateTime
    在Java开发中，我们经常需要处理与时间和日期相关的任务。多年来，java.util.Date类一直是处理日期和时间的主要工具。然而，随着Java8的发布，我们有了更好的选择：java.time包中的LocalDateTime类。在本文中，我们将探讨为什么在现代Java开发中，推荐使用LocalDateTime而不是Date。1.不可变......
  • Angular 集成 StreamSaver 大文件下载
    应用场景:实现目标:在网页端实现大文件(文件大小>=2G)断点续传实际方案:发送多次请求,每次请求一部分文件数据,然后通过续写将文件数据全部写入.难点:无法实现文件续写,最后采用 StreamSaver来解决这个问题. 1.首先从github将 StreamSaver拉取下来.Strea......
  • Stream API用好了效率倍增，优缺点对比
    https://mp.weixin.qq.com/s/Oc-WpS2hdMgPtHWuhwgzCw 既然JDK的大神们，设计出StreamAPI，肯定是优点大于缺点，程序汪必须拥抱变化，下面我列出了他的优缺点，后面还有常见函数的例子。优点:代码简洁：StreamAPI使用Lambda表达式，使得集合操作的代码更加简洁易读，减少了传统的for循环......
  • FFmpeg结构体：AVStream
    1.描述AVStream是存储每一个视频/音频流信息的结构体，位于avformat.h文件中。2.结构体定义1typedefstructAVStream{2intindex;/**<streamindexinAVFormatContext*/3/**4*Format-specificstreamID.5*decoding:setbyli......
  • 使用foreach和stream遍历并修改List列表
    使用foreach和stream遍历并修改List列表1.使用foreachimportjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.stream.Collectors;publicclassTestList{publicstaticvoidmain(String[]args......
  • c++ stringstream
    转载：https://blog.csdn.net/jllongbell/article/details/79092891v前言：  以前没有接触过stringstream这个类的时候，常用的字符串和数字转换函数就是sscanf和sprintf函数。开始的时候就觉得这两个函数应经很叼了，但是毕竟是属于c的。c++中引入了流的概念，通过流来实现字......
  • Java8 Stream完全使用指南
    什么是StreamStream是Java1.8版本开始提供的一个接口，主要提供对数据集合使用流的方式进行操作，流中的元素不可变且只会被消费一次，所有方法都设计成支持链式调用。使用StreamAPI可以极大生产力，写出高效率、干净、简洁的代码。如何获得Stream实例Stream提供了静态构建方法，可以基......
  • 腾讯冷启动论文阅读《Enhancing User Interest based on Stream Clustering and Memor
    背景用户冷启动一直是推荐系统中的一个难题，新用户（或非活跃用户）由于缺少行为数据，模型预估不准确。为了改善用户冷启动，腾讯提出了UserInterestEnhancement(UIE)模型（论文中提到也可以用于item的冷启动）。基本思想是先对用户聚类，然后用userembedding检索最相似的k个聚类中心来表示......
  • Stream流
    目录Stream流的作用Stream流的使用步骤:获取Stream流： 单列集合双列集合数组一堆零散的数组Stream流的中间方法filter过滤limit获取前几个元素 skip跳过前几个元素 distinct元素去重，依赖(hashcode和equal法) concat(Streama,Streamb)   合并a和b两个......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99