Java8之stream

最新推荐文章于 2022-12-03 23:14:13 发布
最新推荐文章于 2022-12-03 23:14:13 发布
阅读量254 收藏
点赞数
分类专栏： java 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38686500/article/details/115287147
版权

前言：

  Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

1、特点：

  1. 不是数据结构，不会保存数据。
  2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
  3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。即延迟执行。

2、Stream的操作步骤

在这里插入图片描述

3、创建流：（几种方法如下）

/**
* 创建流
*/
@Test
public void test01(){
    /**
    * 集合流
    *  - Collection.stream() 穿行流
    *  - Collection.parallelStream() 并行流
    */
    List<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream();

    //数组流
    //Arrays.stream(array)
    String[] strings = new String[10];
    Stream<String> stream2 = Arrays.stream(strings);

    //Stream 静态方法
    //Stream.of(...)
    Stream<Integer> stream3 = Stream.of(1, 2, 3);

    //无限流
    //迭代
    Stream<Integer> stream4 = Stream.iterate(0, (i) -> ++i+i++);
    stream4.forEach(System.out::println);

    //生成
    Stream.generate(() -> Math.random())
        .limit(5)
        .forEach(System.out::println);
}

4、筛选 / 切片

中间操作：

  • filter：接收 Lambda ，从流中排除某些元素
  • limit：截断流，使其元素不超过给定数量
  • skip(n)：跳过元素，返回一个舍弃了前n个元素的流；若流中元素不足n个，则返回一个空流；与 limit(n) 互补
  • distinct：筛选，通过流所生成的 hashCode() 与 equals() 取除重复元素
List<Employee> emps = Arrays.asList(
    new Employee(101, "Z3", 19, 9999.99),
    new Employee(102, "L4", 20, 7777.77),
    new Employee(103, "W5", 35, 6666.66),
    new Employee(104, "Tom", 44, 1111.11),
    new Employee(105, "Jerry", 60, 4444.44)
);

@Test
public void test01(){
    emps.stream()
        .filter((x) -> x.getAge() > 35)
        .limit(3) //短路？达到满足不再内部迭代
        .distinct()
        .skip(1)
        .forEach(System.out::println);

}

在这里插入图片描述

小知识:
   内部迭代：迭代操作由 Stream API 完成
   外部迭代：我们通过迭代器完成

5、映射

  • map：接收 Lambda ，将元素转换为其他形式或提取信息；接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
  • flatMap：接收一个函数作为参数，将流中每一个值都换成另一个流，然后把所有流重新连接成一个流

map：

@Test
public void test02(){
    List<String> list = Arrays.asList("a", "b", "c");
    list.stream()
        .map((str) -> str.toUpperCase())
        .forEach(System.out::println);
}

flatMap：

public Stream<Character> filterCharacter(String str){
    List<Character> list = new ArrayList<>();
    for (char c : str.toCharArray()) {
        list.add(c);
    }

    return list.stream();
}

@Test
public void test03(){
    List<String> list = Arrays.asList("a", "b", "c");
    Test02 test02 = new Test02();
    list.stream()
        .flatMap(test02::filterCharacter)
        .forEach(System.out::println);
}

6、排序

  • sorted()：自然排序
  • sorted(Comparator c)：定制排序

Comparable：自然排序

@Test
public void test04(){
    List<Integer> list = Arrays.asList(1,2,3,4,5);
    list.stream()
        .sorted() //comparaTo()
        .forEach(System.out::println);
}

Comparator：定制排序

@Test
public void test05(){
    emps.stream()
        .sorted((e1, e2) -> { //compara()
            if (e1.getAge().equals(e2.getAge())){
                return e1.getName().compareTo(e2.getName());
            } else {
                return e1.getAge().compareTo(e2.getAge());
            }
        })
        .forEach(System.out::println);
}

7、查找 / 匹配

终止操作：

  • allMatch：检查是否匹配所有元素
  • anyMatch：检查是否至少匹配一个元素
  • noneMatch：检查是否没有匹配所有元素
  • findFirst：返回第一个元素
  • findAny：返回当前流中的任意元素
  • count：返回流中元素的总个数
  • max：返回流中最大值
  • min：返回流中最小值
public enum Status {
    FREE, BUSY, VOCATION;
}

@Test
public void test01(){
    List<Status> list = Arrays.asList(Status.FREE, Status.BUSY, Status.VOCATION);

    boolean flag1 = list.stream()
        .allMatch((s) -> s.equals(Status.BUSY));
    System.out.println(flag1);

    boolean flag2 = list.stream()
        .anyMatch((s) -> s.equals(Status.BUSY));
    System.out.println(flag2);

    boolean flag3 = list.stream()
        .noneMatch((s) -> s.equals(Status.BUSY));
    System.out.println(flag3);

    // 避免空指针异常
    Optional<Status> op1 = list.stream()
        .findFirst();
    // 如果Optional为空 找一个替代的对象
    Status s1 = op1.orElse(Status.BUSY);
    System.out.println(s1);

    Optional<Status> op2 = list.stream()
        .findAny();
    System.out.println(op2);

    long count = list.stream()
        .count();
    System.out.println(count);
}

8、归约 / 收集

  • 归约：reduce(T identity, BinaryOperator) / reduce(BinaryOperator) 可以将流中的数据反复结合起来，得到一个值
  • 收集：collect 将流转换成其他形式；接收一个 Collector 接口的实现，用于给流中元素做汇总的方法

reduce：

/**
* Java：
*  - reduce：需提供默认值（初始值）
* Kotlin：
*  - fold：不需要默认值（初始值）
*  - reduce：需提供默认值（初始值）
*/
@Test
public void test01(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Integer integer = list.stream()
        .reduce(0, (x, y) -> x + y);
    System.out.println(integer);
}

collect：
在这里插入图片描述

List<Employee> emps = Arrays.asList(
    new Employee(101, "Z3", 19, 9999.99),
    new Employee(102, "L4", 20, 7777.77),
    new Employee(103, "W5", 35, 6666.66),
    new Employee(104, "Tom", 44, 1111.11),
    new Employee(105, "Jerry", 60, 4444.44)
);

@Test
public void test02(){
    //放入List
    List<String> list = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toList()); 
    list.forEach(System.out::println);
    
	//放入Set
    Set<String> set = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toSet());
    set.forEach(System.out::println);

    //放入LinkedHashSet
    LinkedHashSet<String> linkedHashSet = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.toCollection(LinkedHashSet::new));
    linkedHashSet.forEach(System.out::println);
}

@Test
public void test03(){
    //总数
    Long count = emps.stream()
        .collect(Collectors.counting());
    System.out.println(count);

    //平均值
    Double avg = emps.stream()
        .collect(Collectors.averagingDouble(Employee::getSalary));
    System.out.println(avg);

    //总和
    Double sum = emps.stream()
        .collect(Collectors.summingDouble(Employee::getSalary));
    System.out.println(sum);

    //最大值
    Optional<Employee> max = emps.stream()
        .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
    System.out.println(max.get());

    //最小值
    Optional<Double> min = emps.stream()
        .map(Employee::getSalary)
        .collect(Collectors.minBy(Double::compare));
    System.out.println(min.get());
}

@Test
public void test04(){
    //分组
    Map<Integer, List<Employee>> map = emps.stream()
        .collect(Collectors.groupingBy(Employee::getId));
    System.out.println(map);

    //多级分组
    Map<Integer, Map<String, List<Employee>>> mapMap = emps.stream()
        .collect(Collectors.groupingBy(Employee::getId, Collectors.groupingBy((e) -> {
            if (e.getAge() > 35) {
                return "开除";
            } else {
                return "继续加班";
            }
        })));
    System.out.println(mapMap);
    
    //分区
    Map<Boolean, List<Employee>> listMap = emps.stream()
        .collect(Collectors.partitioningBy((e) -> e.getSalary() > 4321));
    System.out.println(listMap);
}

@Test
public void test05(){
    //总结
    DoubleSummaryStatistics dss = emps.stream()
        .collect(Collectors.summarizingDouble(Employee::getSalary));
    System.out.println(dss.getMax());
    System.out.println(dss.getMin());
    System.out.println(dss.getSum());
    System.out.println(dss.getCount());
    System.out.println(dss.getAverage());
    
    //连接
    String str = emps.stream()
        .map(Employee::getName)
        .collect(Collectors.joining("-")); //可传入分隔符
    System.out.println(str);
}

9、案例

案例一： 给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？(如：给定【1，2，3，4，5】，返回【1，4，9，16，25】)

@Test
public void test01(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    list.stream()
        .map((x) -> x * x)
        .forEach(System.out::println);
}

案例二： 怎样使用 map 和 reduce 数一数流中有多少个 Employee 呢？

List<Employee> emps = Arrays.asList(
    new Employee(101, "Z3", 19, 9999.99),
    new Employee(102, "L4", 20, 7777.77),
    new Employee(103, "W5", 35, 6666.66),
    new Employee(104, "Tom", 44, 1111.11),
    new Employee(105, "Jerry", 60, 4444.44)
);

@Test
public void test02(){
    Optional<Integer> result = emps.stream()
        .map((e) -> 1)
        .reduce(Integer::sum);
    System.out.println(result.get());

10、并行流

  • 并行流：就是把一个内容分成几个数据块，并用不同的线程分别处理每个数据块的流
  • Java 8 中将并行进行了优化，我们可以很容易的对数据进行操作；Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与串行流之间切换

Fork / Join 框架：
在这里插入图片描述
Fork / Join 框架与传统线程池的区别：
在这里插入图片描述
Fork / Join 实现：

public class ForkJoinCalculate extends RecursiveTask<Long> {

    private static final long serialVersionUID = 1234567890L;

    private long start;
    private long end;

    private static final long THRESHPLD = 10000;

    public ForkJoinCalculate(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long length = end - start;

        if (length <= THRESHPLD) {
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            long middle = (start + end) / 2;

            ForkJoinCalculate left = new ForkJoinCalculate(start, end);
            left.fork(); //拆分子任务 压入线程队列

            ForkJoinCalculate right = new ForkJoinCalculate(middle + 1, end);
            right.fork();

            return left.join() + right.join();
        }

        return null;
    }
}

public class TestForkJoin {

    /**
     * ForkJoin 框架
     */
    @Test
    public void test01(){
        Instant start = Instant.now();

        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinCalculate task = new ForkJoinCalculate(0, 100000000L);

        Long sum = pool.invoke(task);
        System.out.println(sum);

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).getNano());
    }

    /**
     * 普通 for循环
     */
    @Test
    public void test02(){
        Instant start = Instant.now();

        Long sum = 0L;
        for (long i = 0; i < 100000000L; i++) {
            sum += i;
        }

        Instant end = Instant.now();
        System.out.println(Duration.between(start, end).getNano());
    }
}

Java 8 并行流 / 串行流：

@Test
public void test03(){
    //串行流(单线程)：切换为并行流 parallel()
    //并行流：切换为串行流 sequential()
    LongStream.rangeClosed(0, 100000000L)
        .parallel() //底层：ForkJoin
        .reduce(0, Long::sum);

}

11、Optional

定义： Optional 类 (java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在用 Optional 可以更好的表达这个概念；并且可以避免空指针异常。

常用方法：

  • Optional.of(T t)：创建一个 Optional 实例
  • Optional.empty(T t)：创建一个空的 Optional 实例
  • Optional.ofNullable(T t)：若 t 不为 null，创建 Optional 实例，否则空实例
  • isPresent()：判断是否包含某值
  • orElse(T t)：如果调用对象包含值，返回该值，否则返回 t
  • orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值
  • map(Function f)：如果有值对其处理，并返回处理后的 Optional，否则返回 Optional.empty()
  • flatmap(Function mapper)：与 map 相似，要求返回值必须是 Optional

Optional.of(T t)：

@Test
public void test01(){
    Optional<Employee> op = Optional.of(new Employee());
    Employee employee = op.get();
}

Optional.empty(T t)：

@Test
public void test02(){
    Optional<Employee> op = Optional.empty();
    Employee employee = op.get();
}

Optional.ofNullable(T t)：

@Test
public void test03(){
    Optional<Employee> op = Optional.ofNullable(new Employee());
    Employee employee = op.get();
}

isPresent()：

@Test
public void test03(){
    Optional<Employee> op = Optional.ofNullable(new Employee());
    if (op.isPresent()) {
        Employee employee = op.get();
    }
}
吼吼权
关注
专栏目录
java8学习笔记
weixin_45484128的博客
09-24 269
本文内容编辑主要是对lambda表达式、函数式接口、引用、stream api的学习记录等，后续会逐渐更新，作者本人是在其他平台编译，拷贝过来的
java8中Stream的使用以及分割list案例
08-24
Java8中的Stream使用和分割List案例 Java8中Stream的使用可以大大提高编程效率，代码简洁易懂。Stream api可以用来处理大规模的数据，提高性能。下面将详细介绍Java8中Stream的使用和分割List案例。 一、Stream的...
Java8 学习笔记
weixin_33882443的博客
05-14 258
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 8 学习笔记
qq_32078397的博客
03-12 209
1. Java 8 1.1 生态 Lambda 表达式 函数式接口 方法引用 / 构造器引用 Stream API 接口中的默认方法 / 静态方法 新时间日期 API 其他新特性 1.2 新特性 速度更快 代码更少 强大的 Stream API 便于并行 最大化减少空指针异常 Optional (Kotlin ?) 1.3 温故而知新 Hashmap 底层结构/原理 老话题不再阐述 … 并发hashmap … Java虚拟机 … Java内存模型 … 2. Lambda 2.
Java8学习笔记
Jaybo
06-06 1577
—学习于尚硅谷视频— 写在前面： 2014年，Oracle发布了Java8新版本。对于Java来说，这显然是一个具有里程碑意义的版本。 但我在2017年6月这个时候才学习了下Java8，而且Java9也要在今年出来，时间好像推迟了一点，随便找了篇关于Java9的公众文章：http://mp.weixin.qq.com/s/3HlAFLxuxGEU8XlLY1wTvw 然后Ja
Java 8系列之Stream中万能的reduce用法说明
08-24
Java 8系列之Stream中万能的reduce用法说明 在 Java 8 中，Stream API 提供了一个强大的方法reduce，用于从 Stream 中生成一个值。这个值不是随意的，而是根据指定的计算模型。reduce 操作可以实现从 Stream 中生成...
Java8中Stream使用的一个注意事项
08-28
Java 8 中的 Stream 是一个强大的工具，它引入了一种新的数据处理方式，特别是对于集合对象的操作。Stream 不是存储数据的数据结构，而是用于处理数据的 API，它提供了丰富的操作，如过滤、映射、聚合等，使得代码...
如何在java 8 map中使用stream
08-19
Java 8 中使用 Stream 遍历 Map Java 8 中引入了 Stream 概念， Stream 是一种非常强大的功能，可以使我们更加简单的操作 Map 对象。Map 是 Java 中非常常用的一个集合类型，我们通常也需要去遍历 Map 去获取某些值...
JAVA笔记 | JAVA8简单又详细的快速入门笔记
qq_37630282的博客
01-12 1515
public interface Demo { void test(String a); } 一个功能接口作为参数进行传递的简化（原始->lambda） public class TestMethod { public static void main(String[] args) { //原始：一个功能接口的实现 Demo demo = new Demo() { @Override public .
Java8学习简要笔记
点滴之路
08-07 318
Java8学习概要笔记 内存结构的改变 堆中没有了永久区的部分，取而代之为原空间 java8之前的永久区存储类加载信息，几乎不会被垃圾回收机制回收；Java8之后对应为元空间，使用物理内存（RAM） 原来的PremGenSize、MaxPremGenSize在1.8之后删除，取而代之的式MetaSpaceSize、MaxMetaSpaceSize 一、Lambda表达式 左侧：Lambda表达式的参数列表 右侧：Lambda表达式中所需执行的功能，即Lambda体 1.1 语法格式 无参数
《Java8学习笔记》读书笔记(8)
默然说话
04-28 1025
摘要：花了差不多一个月的时间，写完了第8章异常处理，这章讲述了try-catch-finally的Java异常处理机制，讲述了throw和throws的抛出异常机制。还介绍了assert语法，JDK 7开始出现的一些变化，比如try-with-resource语法蜜糖。对于Java异常的介绍还是比较全面的，希望大家喜欢。欢迎留言提问，欢迎分享，欢迎关注。 第8章 异常处理 学习目标 ...
java8新特性学习笔记
weixin_42032770的博客
08-21 942
1、速度更快 jdk1.8对底层做了优化，使得速度更快了。jdk1.8取消了永久区，取而代之的是增加了元空间（MetaSpace），元空间直接使用了物理内存（RAM），因此运行速度会更快。 jdk1.8之后对哈希表做了优化，在jdk1.8之前，哈希表的结构是数组+链表，jdk1.7使用的是头插法，jdk1.7用的单链表是纵向延伸的。jdk1.8之后，增加了红黑树，jdk1.8之后的哈希表的结构是数组+链表+红黑树。jdk1.8的哈希表用的是尾插法，当哈希表容量达到总容量的3/4的时候（负载因子0..
《Java学习笔记(第8版)》学习指导
weixin_33936401的博客
02-04 680
《Java学习笔记(第8版)》学习指导 目录 图书简况 学习指导 第一章 Java平台概论 第二章 从JDK到IDE 第三章 基础语法 第四章 认识对象 第五章 对象封装 第六章 继承与多态 第七章 接口与多态 第八章 异常处理 第九章 Collection与Map 第十章 输入/输出 第十一章 线程与并行API 第十二章 Lambda 第十三章 时间与日期 第十四章 NIO与NIO2 第十五...
Java8从入门到精通 笔记
最新发布
qq_35448165的博客
12-03 642
java8新特性 lambda表达式，stream 用Lambda表达式就可以用更简洁的代码实现这一功能 使用 Lambda 表达式结合 Stream API， 只要给出相应的集合， 我们就可以完成对集合的各种过滤并输出结果信息。Lambda 表达式在 Java 语言中引入了 “->” 操作符， “->” 操作符被称为 Lambda 表达式 的操作符或者箭头操作符， 它将 Lambda 表达式分为两部分：只包含一个抽象方法的
java8 学习笔记
狭小的巷子深处
06-02 199
引言：几乎每个java应用都会创建和处理集合，但是集合的传统CollectionAPI处理需要写一堆代码，使用起来不尽人意还会使代码变得臃肿，这个时候java8提供的StreamAPI(内部迭代)会让一切变得简单的.java8最大的特性是引入了Lambda表达式，函数式编程，使用不可变值和函数，函数对不可变值进行处理，映射成另一个值。 1.函数式接口 使用@FunctionalInter...
Java8之Stream与快速排序算法
"这篇文档是关于Java8的Stream特性的学习笔记，主要涵盖了Stream的介绍、Fork-Join机制、快速排序算法以及如何在实际中使用Stream。文档作者通过实例和理论相结合的方式，深入浅出地讲解了Java8的新特性。" 在Java8...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值