Java8 新特性 (Lambda表达式、Stream)

最新推荐文章于 2022-08-30 20:38:55 发布
最新推荐文章于 2022-08-30 20:38:55 发布
阅读量235 收藏
点赞数
分类专栏： Java 文章标签： jdk java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39579087/article/details/108870400
版权

Lambda表达式

在这里插入图片描述
在这里插入图片描述
注意和Python中Lambda的区别，在Python中是方法，在Java中是对象。

在这里插入图片描述
在这里插入图片描述

无参，无返回值

 @Test
    public void test() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("1");
            }
        };
        r1.run();

        System.out.println("*************");
        Runnable r2 = () -> System.out.println("2");
        r2.run();
    }

结果：
1
*************
2

有一个参数，无返回值

@Test
    public void test2() {
        Consumer<String> c1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        c1.accept("1");

        System.out.println("************");
        Consumer<String> c2 = (String s) -> {
            System.out.println(s);
        };
        c2.accept("2");
    }

结果：
1
************
2

数据类型可以省略 类型推断

在上面代码的基础上：

@Test
    public void test2() {
        Consumer<String> c1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        c1.accept("1");

        System.out.println("************");
        Consumer<String> c2 = (String s) -> {
            System.out.println(s);
        };
        c2.accept("2");
        System.out.println("********");

        Consumer<String> c3 = (s) -> {
            System.out.println(s);
        };
        c3.accept("3");
    }

结果：
1
************
2
********
3

下图也是类型推断：

在这里插入图片描述

若只有一个参数，参数的小括号可以省略

@Test
    public void test3() {

        Consumer<String> c3 = (s) -> {
            System.out.println(s);
        };
        c3.accept("1");
        System.out.println("*********");

        Consumer<String> c4 = s -> {
            System.out.println(s);
        };
        c4.accept("2");
    }

结果：
1
*********
2

两个参数，且方法体中可能有多条语句和返回值

@Test
    public void test4() {

        Comparator<Integer> c1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(c1.compare(15, 20));

        System.out.println("***********");
        Comparator<Integer> c2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

        System.out.println(c1.compare(25, 20));
    }

结果：
15
20
-1
***********
25
20
1

当Lambda体只有一条语句时，return与大括号若有，都可以省略

@Test
    public void test5() {
        Comparator<Integer> c1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(c1.compare(25, 20));

        System.out.println("***********");

        Comparator<Integer> c2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(c2.compare(20, 25));
    }

结果：
1
***********
-1

Lambda 总结

在这里插入图片描述

函数式接口

如果一个接口中只声明了一个抽象方法，则此接口称为函数式接口。
在这里插入图片描述

Lambda表达式只能用于接口中有一个抽象方法的情况，因此再实现抽象方法时就不必再指定方法名了，反正就那一个。也就是说Lambda表达式作为函数式接口的实例。

在这里插入图片描述

Consumer
 @Test
    public void test6() {
        shopping(1000, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("购物共花费: " + aDouble);
            }
        });

        shopping(1500, money -> System.out.println("购物共花费: " + money) );
    }

    public void shopping(double money, Consumer<Double> con) {
        con.accept(money);
    }

结果：
购物共花费: 1000.0
购物共花费: 1500.0
Predicate

在这里插入图片描述
在这里插入图片描述

其他接口

在这里插入图片描述

方法引用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

使用举例

对象::非静态方法

在这里插入图片描述

在这里插入图片描述

类::静态方法

在这里插入图片描述
在这里插入图片描述

类::非静态方法

在这里插入图片描述
在这里插入图片描述

@Test
    public void test7() {
        Function<Person, String> f = new Function<Person, String>() {
            @Override
            public String apply(Person person) {
                return person.getName();
            }
        };
        System.out.println(f.apply(new Person("Li")));

        System.out.println("******");
        Function<Person, String> f2 = p -> p.getName();
        System.out.println(f2.apply(new Person("Wang")));

        System.out.println("******");
        Function<Person, String> f3 =Person :: getName;
        System.out.println(f3.apply(new Person("Zhao")));
    }

Li
******
Wang
******
Zhao

构造器引用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

数组引用

在这里插入图片描述
在这里插入图片描述

Stream API

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
Stream是延迟执行的，只有在需要结果的时候才会执行

创建Stream对象的方式

通过集合

在这里插入图片描述
在这里插入图片描述

通过数组

在这里插入图片描述

在这里插入图片描述

通过Stream的of()

在这里插入图片描述

在这里插入图片描述

无限流

在这里插入图片描述
在这里插入图片描述

中间操作

筛选与切片

在这里插入图片描述
再次注意，一旦对Stream执行了中止操作(forEach输出也算中止操作)，后续的操作就无法执行了，因此下图会报错：

在这里插入图片描述

因此要重新生成一个stream，就像iterator那样：

在这里插入图片描述

在这里插入图片描述

映射

在这里插入图片描述

Map
 @Test
    public void test() {
        List<String> list = Arrays.asList("AA", "Bb", "aBc");
        list.stream().map(s -> s.toUpperCase()).forEach(System.out::println);
        System.out.println(list);
    }

AA
BB
ABC
[AA, Bb, aBc]
flatmap

接收一个函数作为参数，将流中的每一个值换成另一个流，然后把所有流连接成一个流。

在这里插入图片描述

https://www.bilibili.com/video/BV1Kb411W75N?p=680

排序

在这里插入图片描述

sorted()

要想使用这个方法，相应的类需实现Comparable接口，排序后原集合不变。

调用sorted方法后会自动调用Integer的排序方法：

 @Test
    public void test() {
        List<Integer> list = Arrays.asList(18, 22, -1, 34, 14, 0);
        list.stream().sorted().forEach(x -> System.out.println(x));
        System.out.println(list);  // 验证排序后原list是否改变
    }

结果：
-1
0
14
18
22
34
[18, 22, -1, 34, 14, 0]

但要注意，如果我们想对对象列表进行排序，则相应的类要实现Comparable接口，或者使用另一种sorted()

sorted(Comparator com)

可以在sorted传入Comparator 实现类的对象以实现定制排序：

@Test
    public void test() {
        List<Integer> list = Arrays.asList(18, 22, -1, 34, 14, 0);
        
        list.stream().sorted(new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return - o1.compareTo(o2);
            }
        }).forEach(System.out::println);
    }

结果：
34
22
18
14
0
-1

中止操作

在这里插入图片描述
在这里插入图片描述

匹配和查找
public class StopTest {
    @Test
    public void test1() {
        List<Integer> list = Arrays.asList(10, 5, -1, 32, 44, -11, 57);

        // allMatch 看看stream里面的元素是否都满足参数的条件
        boolean res = list.stream().allMatch(l -> l > -20);  // true
        System.out.println(res);

        // anyMatch stream里有一个满足参数的条件就行
        boolean res2 = list.stream().anyMatch(l -> l > 50); // true
        System.out.println(res2);

        // noneMatch 检查是否没有匹配的元素，若有则返回false
        boolean res3 = list.stream().noneMatch(e -> e.equals(5));  // false
        System.out.println(res3);

        // findfirst 返回第一个元素，注意返回值类型是Optional，后面会说
        Optional<Integer> res4 = list.stream().sorted().findFirst();  // Optional[-11]
        System.out.println(res4);

        // findAny 返回当前流中任意一个元素
        Optional<Integer> res5 = list.stream().findAny();  // Optional[10]
        System.out.println(res5);

        // count 返回流中元素的总个数
        long count = list.stream().count();  // 7
        System.out.println(count);

        // max 返回流中的最大值
//        Optional<Integer> max_num = list.stream().max(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1.compareTo(o2);
//            }
//        });
        Optional<Integer> max_num = list.stream().map(l -> l*l).max((o1, o2) -> o1.compareTo(o2));  // Optional[3249]
        System.out.println(max_num); 

        // min 返回流中的最小值，min的参数可以对流进行处理(升序/降序/...)
        Optional<Integer> min_num = list.stream().min((l1, l2) -> l1.compareTo(l2));  // Optional[-11]
        System.out.println(min_num);

        // forEach 流的迭代
        list.stream().forEach(l -> System.out.println(l));

        System.out.println("***");  // 10 5 -1 32 44 -11 57
        // 集合的迭代
        list.forEach(l -> System.out.println(l));  // 10 5 -1 32 44 -11 57

    }
}
归约
// 归约
    @Test
    public void test2() {
        // T reduce(T identity, BinaryOperator<T> accumulator) 第一个参数是初始值，会附加到最后的结果上，第二个参数是对集合中元素的操作，在这里是相加
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(5, (l1, l2) -> Integer.sum(l1, l2));  // 60
        System.out.println(sum);

        // Optional<T> reduce(BinaryOperator<T> accumulator)
        Optional<Integer> sum2 = list.stream().reduce((l1, l2) -> Integer.sum(l1, l2));  // Optional[55]
        System.out.println(sum2);
    }
收集

在这里插入图片描述
在这里插入图片描述

// 收集
    @Test
    public void test3() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> collect = list.stream().filter(l -> l > 5).collect(Collectors.toList());
        collect.forEach(l -> System.out.println(l));

    }

结果：
6
7
8
9
10

Optional类

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
https://www.bilibili.com/video/BV1Kb411W75N?p=687

其它

还有些新版本的特性，俺是个新手，现在也用不到，等以后再来填坑吧！ ()

路漫漫`
关注
专栏目录
Java8新特性——StreamAPI(一)
大闲人柴毛毛
08-28 9万+
1. 流的基本概念1.1 什么是流？流是Java8引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集合，它就像SQL语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你，无需我们自己手写代码。因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它
Java8新特性——Lambda表达式
m0_64354070的博客
11-28 1244
Java8新特性——Lambda表达式 2.1 什么是Lambda表达式？ 2.2 为什么要使用Lambda表达式？ 2.3 从匿名内部类到 Lambda 的转换 3.1 语法一：无参无返回值，Lambda 体只需要一条语句 3.2 语法二：传递一个参数，无返回值 3.3 语法三：传递一个参数时，参数的小括号可以省略，无返回值 3.4 语法四：传递两个参数，有返回值 3.5 语法五：当 Lambda 体只有一条语句时，return 与大括号可以省略 4.1
Java——jdk8新特性、Lambda表达式、Stream流
程序员阿龙的博客
08-09 762
Java——jdk8新特性、Lambda表达式、Stream流
Java8新特性Stream 和lambda 表达式
shassd的博客
01-14 178
Java8新特性Stream 和lambda 表达式 一：Java8新特性 接口默认方法，lambda 表达式 ，函数式接口，Date API 等特性 Stream 作为java8 的新特性，基于lambda表达式，是对集合对象功能的增强，它专注于对集合对象进行各种高效，遍历的聚合操作或者大批量的数据操作 Stream原理： 将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包...
Java--lambda&Stream
Janemy_的博客
08-30 182
Java--lambda&Stream
Java8的stream().map()用法
C_0010的博客
05-24 4万+
Java8，使用stream流处理map
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
浅析Java8新特性Lambda表达式和函数式接口
08-29
Java 8 新特性 Lambda 表达式和函数式接口 Java 8 中引入的 Lambda 表达式是一种可以传递的代码，旨在简化代码，提高代码的可读性。 Lambda 表达式基于数学中的λ演算得名，直接对应于其中的 lambda 抽象（lambda ...
Java8新特性lambda表达式有什么用(用法实例)
09-04
Java 8 的一个重要特性是引入了 Lambda 表达式，这一改变显著地提升了代码的简洁性和可读性，尤其是在处理集合操作时。Lambda 表达式使得 Java 更加接近函数式编程，允许开发者以一种更简洁的方式定义匿名函数。本文...
JAVA8新特性Lambda表达式、Stream使用
11-19
需要环境：JDK8 下载下来后 直接导入IDE工具中，运行TestLambda、TestLambda2、TestLambda3、PracticeLambda、TestStream中的main方法就可以看见结果
Java8 Stream 流中的匹配查找方法
吖脖（博）
09-29 5万+
findAny：查找任何一个就返回 Optional findFirst：查找到第一个就返回 Optional anyMatch：匹配上任何一个则返回 Boolean allMatch：匹配所有的元素则返回 Boolean
Java Lambda表达式与Stream API小结
一枝韩独秀的博客
03-11 1531
1 Lambda 表达式(Lambda Expressions) Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。 // 匿名内部类 Runnable r = new Runnable(){ @Override ...
List的stream用法
努力改变人生
03-25 4130
package com.glch.test; import com.glch.base.util.StringUtil; import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.stream.Collectors; /** * @author zhongzhilong * @date 2021-03-25 * @description List的stream功能测试 */
java 使用Lambda和filter对对象集合过滤
热门推荐
weixin_40841731的博客
01-09 5万+
1、如下：用户对象 public class User(){ private String name; private int age; private String sex; } 2、构造用户集合 List&lt;User&gt; list = new ArrayList&lt;&gt;(); User user1 = new User("张三",15,"男"); User us...
java8新特性之lambda表达式/stream流常用方法
weixin_42079595的博客
06-01 861
lambda表达式探索 简介 学习lambda表达式就要先知道函数式接口是什么 函数式接口（Functional Interfaces）：如果一个接口定义个唯一一个抽象方法，那么这个接口就成为函数式接口。同时，引入了一个新的注解：@FunctionalInterface。可以把他它放在一个接口前，表示这个接口是一个函数式接口。这个注解是非必须的，只要接口只包含一个方法的接口，虚拟机会自动判断，不过最好在接口上使用注解 @FunctionalInterface 进行声明。在接口中添加了 @Functional
Java-8新特性-通过Stream获取两个List复杂对象的交并差集
10-23 1万+
思路：首先获取两个list的id，通过id比较获取id的交并差集，再通过一次获取list对象里面的交并差集元素 代码直接可运行，个人觉得java8的stream非常类似ES6的集合运算，filter、foreach、map、reduce基本可以一一对应 代码： package com.stream; import java.util.ArrayList; import java.util...
关于Java8新特性探索之Stream接口
haozige888的博客
10-28 296
一、为什么引入Stream流 流是一系列与特定存储机制无关的元素——实际上，流并没有“存储”之说。使用流，无需迭代集合中的元素，就可以从管道提取和操作元素。这些管道通常被组合在一起，形成一系列对流进行操作的管道。 在大多数情况下，将对象存储在集合中是为了处理他们，因此你将会发现你将编程的主要焦点从集合转移到了流上，流的一个核心的好处是，它使得程序更加短小并且更易理解。当Lambda表达式和方法引用和流一起使用的时候会让人感觉自成一体。 二、如何使用Stream流 流操作的类型有三种：创建流，修改流元素（中间
Lambda表达式与Stream流的结合
张家煦的博客
08-27 815
之前我们说过为什么要用函数式接口以及函数式接口的好处，本篇文章我们就开始介绍lambda表达式与stream流。 还是要先跟大家说一下函数式接口的特点： 函数式接口只有一个抽象方法 允许定义静态非抽象方法 允许定义默认default非抽象方法 允许Java.lang.Object中的public方法 FunctionInterface注解不是必须的（当我们把该注解定义在接口上方时，如果接口是函数式接口，编译通过；如果不是，编译失败。），因为只要保证满足函数式接口定义的条件，也照样是函数式接口。但
Java8新特性：Lambda表达式与StreamAPI详解
"Java8新特性概述" Java8是2014年发布的一个重大版本，它为Java语言带来了许多关键改进和创新，旨在提高开发效率、性能和简洁性。以下重点介绍Java8中的两大核心新特性：Lambda表达式和Stream API。 Lambda表达式 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值