Lambda表达式、函数式思想、Stream流_函数式思想:值类型,和类型-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44365508/article/details/119360901

本文详细介绍了Java 8中的Lambda表达式及其优化方法，解释了Lambda表达式的格式和前提条件。此外还介绍了函数式接口如Consumer、Predicate、Function等的使用方法，并深入探讨了Stream流的概念、获取方式及常用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Lambda表达式

一、Lambda表达式

1.1 函数式编程思想概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrSvXiJJ-1628001413170)(images/image30.png)]

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——

强调做什么，而不是以什么形式做。

做什么，而不是怎么做

我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。

传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

1.2 Lambda的优化

当需要启动一个线程去完成任务时，通常会通过 java.lang.Runnable 接口来定义任务内容，并使用java.lang.Thread 类来启动该线程。

public class Demo01ThreadNameless { 
    public static void main(String[] args) { 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                System.out.println("多线程任务执行！"); 
            }
        }).start();
    }
}

本着“一切皆对象”的思想，这种做法是无可厚非的：首先创建一个 Runnable 接口的匿名内部类对象来指定任务内容，再将其交给一个线程来启动。

代码分析:

对于 Runnable 的匿名内部类用法，可以分析出几点内容：

Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，似乎只有方法体才是关键所在。

Lambda表达式写法,代码如下：

public class Demo02LambdaRunnable { 
    public static void main(String[] args) {
        new Thread(() -> System.out.println("多线程任务执行！")).start();
        // 启动线程
    } 
}

这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！

1.3 Lambda的格式

标准格式：

Lambda省去面向对象的条条框框，格式由3个部分组成

一些参数
一个箭头
一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明：

小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
-> 是新引入的语法格式，代表指向动作。
大括号内的语法与传统方法体要求基本一致。

匿名内部类与lambda对比

new Thread(new Runnable() { 
    @Override 
    public void run() {
        System.out.println("多线程任务执行！"); 
    } 
}).start();

仔细分析该代码中， Runnable 接口只有一个 run 方法的定义：

public abstract void run();

即制定了一种做事情的方案（其实就是一个方法）：

无参数：不需要任何条件即可执行该方案。
无返回值：该方案不产生任何结果。
代码块（方法体）：该方案的具体执行步骤。

同样的语义体现在 Lambda 语法中，要更加简单：

() -> System.out.println("多线程任务执行！")

前面的一对小括号即 run 方法的参数（无），代表不需要任何条件；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码。

参数和返回值

实际上，只有参数和方法体才是关键。

省略格式:

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

可推导即可省略

Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。

Runnable接口简化: 
() -> System.out.println("多线程任务执行！")

1.4 Lambda的前提条件

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

二、函数式接口(了解-扩展知识点)

2.1.函数式接口的定义

package com.itheima.demo05FunctionalInterface;

/*
    函数式接口:接口中有且只有一个抽象方法的接口
    注意:
        1.接口中没有抽象方法不行
        2.接口有多个抽象方法不行
        3.接口中可以包含其他的方法(默认,静态)
   注解:
    @FunctionalInterface:可以检测一个接口是否为函数式接口
    @Override:可以检测一个方法是否为重写的方法     
 */
@FunctionalInterface
public interface MyInter {
    //定义抽象方法
    public abstract void show01(int a);
    
    //定义默认方法
    public default void show02(){
        System.out.println("接口中的默认show02方法!");
    }

    //定义静态方法
    public static void show03(){
        System.out.println("接口中的静态show03方法!");
    }

    public static void show04(){
        System.out.println("接口中的静态show04方法!");
    }
}

2.2.函数式接口的使用

记住:方法的参数和返回值类型使用函数式接口,可以传递和返回Lambda表达式==>简化匿名内部类

package com.itheima.demo05FunctionalInterface;

/*
    函数式接口的使用
    在工作中,一般都使用接口作为方法的参数和返回值==>多态==>可以接收任意的子类对象,可以返回任意的子类对象
    使用函数式接口作为方法的参数和返回值
    记住:方法的参数和返回值类型使用函数式接口,可以传递和返回Lambda表达式==>简化匿名内部类

    Lambda表达式(接口的实现类对象)==匿名内部类(接口的实现类对象)
 */
public class Demo01 {
    public static void main(String[] args) {
        //method方法的参数类型是MyInter接口,所以我们可以传递一个匿名内部类,给接口变量赋值
        method(new MyInter() {
            @Override
            public void show01(int a) {
                System.out.println(a);
            }
        });

        //method方法参数MyInter是一个函数式接口,所以我们可以使用Lambda表达式简化匿名内部类,给接口变量赋值
        method((int a)->{
            System.out.println(a);
        });

        //Lambda表达式的简化格式
        method(a-> System.out.println(a));

        //MyInter my = getInstance();= a-> System.out.println(a);
        MyInter my = getInstance();
        my.show01(100);
    }
    
    /*
        定义一个方法,方法的返回值类型使用MyInter
     */
    public static MyInter getInstance(){
        //返回值类型是一个接口,可以返回接口的实现类对象
        /*return new MyInter() {
            @Override
            public void show01(int a) {
                System.out.println(a);
            }
        };*/

        //返回值类型是一个函数式接口,可以返回Lambda表达式,作为接口的实现类对象
        return a-> System.out.println(a);
    }

    /*
        定义一个方法,方法的参数使用函数式接口MyInter
        多态:  接口   =      实现类对象
            MyInter my = a-> System.out.println(a);
     */
    public static void method(MyInter my){
        my.show01(10);
    }
}

2.3.函数式接口:Consumer

java.util.function.Consumer<T>:函数式接口    接口中唯一的抽象方法:        void accept(T t) :消费一个指定泛型类型的数据    Consumer接口的泛型使用什么类型,就可以使用accept方法消费(使用)一个什么类型的数据    至于我们怎么使用这个数据,看心情(想怎么使用就怎么使用,可以计算,可以输出...)

package com.itheima.demo05FunctionalInterface;import java.util.function.Consumer;/*    java.util.function.Consumer<T>:函数式接口    接口中唯一的抽象方法:        void accept(T t) :消费一个指定泛型类型的数据    Consumer接口的泛型使用什么类型,就可以使用accept方法消费(使用)一个什么类型的数据    至于我们怎么使用这个数据,看心情(想怎么使用就怎么使用,可以计算,可以输出...) */public class Demo02Consumer {    public static void main(String[] args) {        //调用method方法,方法的参数Consumer是一个接口,那么我们就可以传递接口的实现类对象给接口变量赋值        method(new Consumer<String>() {            @Override            public void accept(String s) {                System.out.println(s);            }        },"hello");        //调用method方法,方法的参数Consumer是一个函数式接口,那么我们就可以使用Lambda表达式作为接口的实现类对象,给接口变量赋值        method((String s)->{            System.out.println(s);        },"你好");        //简化Lambda表达式        method(s-> System.out.println(s),"大家好");    }    /*        定义一个方法,方法的参数            使用Consumer类型,泛型使用String            使用String类型        在方法中使用Consumer接口中的方法accept对传递的字符串进行消费(使用)     */    public static void method(Consumer<String> con,String s){        con.accept(s);    }}

2.4.函数式接口:Predicate

java.util.function.Predicate<T>:函数式接口   接口中唯一的抽象方法:       boolean test(T t) 用于对接口指定泛型类型的数据进行判断   Predicate接口的泛型使用什么类型,就可以使用test方法判断数据是否满足要求       满足要求:返回true       不满足安全:返回false

package com.itheima.demo05FunctionalInterface;import java.util.function.Predicate;/*    java.util.function.Predicate<T>:函数式接口   接口中唯一的抽象方法:       boolean test(T t) 用于对接口指定泛型类型的数据进行判断   Predicate接口的泛型使用什么类型,就可以使用test方法判断数据是否满足要求       满足要求:返回true       不满足安全:返回false */public class Demo03Predicate {    public static void main(String[] args) {        //调用method方法,方法的参数Predicate是一个接口,那么我们就可以传递接口的实现类对象给接口变量赋值        method(new Predicate<String>() {            @Override            public boolean test(String s) {                //判断字符串的长度是否大于5                return s.length()>5;            }        },"aaaa1a");        //调用method方法,方法的参数Predicate是一个函数式接口,那么我们就可以使用Lambda表达式作为接口的实现类对象,给接口变量赋值        method((String s)->{            return s.startsWith("张");        },"张三");        //简化Lambda表达式        method(s->s.startsWith("张"),"李四");    }    /*        定义一个方法,方法的参数            使用Predicate类型,泛型使用String            使用String类型        在方法中使用Predicate接口中的方法test对字符串参数进行判断        Predicate<String> pre = s->s.startsWith("张");     */    public static void method(Predicate<String> pre,String s){        boolean b = pre.test(s);        System.out.println(b);    }}

2.5.函数式接口:Function

java.util.function.Function<T,R>:函数式接口   接口中唯一的抽象方法:       R apply(T t) 根据参数类型T获取类型R类型的返回值,用于类型转换 T转换R   例如:       Function<String,Integer>:根据传递String类型的数据,获取Integer类型的结果  "123"==>123 = Integer.parseInt("123")       Function<String,Person>:根据传递String类型的数据,获取Person类型的结果   "小明"==>Person p = new Person("小明")       ...

package com.itheima.demo05FunctionalInterface;import java.util.function.Function;/*    java.util.function.Function<T,R>:函数式接口   接口中唯一的抽象方法:       R apply(T t) 根据参数类型T获取类型R类型的返回值,用于类型转换 T转换R   例如:       Function<String,Integer>:根据传递String类型的数据,获取Integer类型的结果  "123"==>123 = Integer.parseInt("123")       Function<String,Person>:根据传递String类型的数据,获取Person类型的结果   "小明"==>Person p = new Person("小明")       ... */public class Demo04Function {    public static void main(String[] args) {        //调用method方法,方法的参数Function是一个接口,那么我们就可以传递接口的实现类对象给接口变量赋值        method(new Function<String, Integer>() {            @Override            public Integer apply(String s) {                return Integer.parseInt(s);            }        },"123");        //调用method方法,方法的参数Function是一个函数式接口,那么我们就可以使用Lambda表达式作为接口的实现类对象,给接口变量赋值        method((String s)->{            return Integer.parseInt(s);        },"100");        //简化Lambda表达式        method(s -> Integer.parseInt(s),"80");    }    /*        定义一个方法,方法的参数            使用Function类型,泛型使用<String,Integer>            使用String类型        在方法内部使用Function接口中的方法apply把String类型的整数,转换为Integer类型返回     */    public static void method(Function<String,Integer> fun,String s){        Integer in = fun.apply(s);        System.out.println(in+10);    }}

2.6.函数式接口:Supplier

 java.util.function.Supplier<T>:函数式接口   接口中唯一的抽象方法:       T get() 用来获取接口指定泛型类型的数据   Supplier接口使用什么泛型,就可以使用get方法获取一个什么类型的数据

package com.itheima.demo05FunctionalInterface;import java.util.Random;import java.util.function.Supplier;/*    java.util.function.Supplier<T>:函数式接口   接口中唯一的抽象方法:       T get() 用来获取接口指定泛型类型的数据   Supplier接口使用什么泛型,就可以使用get方法获取一个什么类型的数据 */public class Demo05Supplier {    public static void main(String[] args) {        //调用method方法,方法的参数Supplier是一个接口,那么我们就可以传递接口的实现类对象给接口变量赋值        method(new Supplier<Integer>() {            @Override            public Integer get() {                return 10;            }        });        //调用method方法,方法的参数Supplier是一个函数式接口,那么我们就可以使用Lambda表达式作为接口的实现类对象,给接口变量赋值        method(()->{            //return 100;            //Random r = new Random();            //int n = r.nextInt(100)+1;            //return n;            return new Random().nextInt(100)+1;        });        //简化Lambda表达式        method(()->10);    }    /*        定义一个方法,方法的参数            使用Supplier接口类型,泛型使用Integer        在方法内部使用Supplier接口中的方法get,获取一个Integer类型的数据     */    public static void method(Supplier<Integer> sup){        Integer in = sup.get();        System.out.println(in);    }}

三、Stream流

3.1 流式思想的概述

整体来看，流式思想类似于工厂车间的“生产流水线”。当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DZnwJMov-1628001413175)(images/image35.png)]

这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。

这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 count 执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

备注：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

3.2 获取流的方式

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）获取一个流非常简单，有以下几种常用的方式：

所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

方式1 : 根据Collection获取流

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

public class Main01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();
        HashSet<String> set = new HashSet<>();
        Stream<String> stream1 = set.stream();
    }
}

方式2 : 根据Map获取流

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

public class Main01 {
    public static void main(String[] args) {
        HashMap<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 ，使用很简单：

public class Main01 {
    public static void main(String[] args) {
        String[] array = {"乔峰", "虚竹", "段誉", "天山童姥"};
        Stream<String> stream = Stream.of(array);
    }
}

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

3.3 常用方法

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

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

函数拼接与终结方法

凡是返回值仍然为 Stream 接口的为函数拼接方法，它们支持链式调用；而返回值不再为 Stream 接口的为终结方法，不再支持链式调用。部分方法如下所示：

方法名	方法作用	方法种类	是否支持链式调用
count	统计个数	终结	否
forEach	逐一处理	终结	否
filter	过滤	函数拼接	是
limit	取用前几个	函数拼接	是
skip	跳过前几个	函数拼接	是
map	映射	函数拼接	是
concat	组合	函数拼接	是

forEach：逐一处理

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的。

void forEach(Consumer<? super T> action)

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。例如：

public class Main01 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("乔峰", "虚竹", "段誉", "天山童姥");
        stream.forEach(s -> System.out.println(s));
    }
}

count：统计个数

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

public class Main01 {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("乔峰", "虚竹", "段誉", "天山童姥");
        Stream<String> result = original.filter(s -> s.startsWith("乔"));
        System.out.println(result.count());
    }
}

filter：过滤

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

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

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

基本使用

public class Main01 {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("乔峰", "虚竹", "段誉", "天山童姥");
        Stream<String> result = original.filter(s -> s.startsWith("乔"));
    }
}

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

limit：取用前几个

limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(Long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

public class Main01 {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("乔峰", "虚竹", "段誉", "天山童姥");
        Stream<String> limit = original.limit(2L);
        limit.forEach(s -> System.out.println(s));// 乔峰，虚竹 
    }
}

skip：跳过前几个

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

Stream<T> skip(Long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

public class Main01 {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("乔峰", "虚竹", "段誉", "天山童姥");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 2    
    }
}

map：映射

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

基本使用

public class Main01 {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("12", "23", "45", "23");
        Stream<Integer> result = original.map(s -> Integer.parseInt(s));
        result.forEach(s -> System.out.println(s));
    }
}

concat：组合

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

public class Main01 {
    public static void main(String[] args) {
        Stream<String> original1 = Stream.of("乔峰", "虚竹");
        Stream<String> original2 = Stream.of("段誉", "天山童姥");
        Stream<String> concat = Stream.concat(original1, original2);
        concat.forEach(s -> System.out.println(s));
    }
}

3.4 收集Stream结果【重点】

收集到集合中

Stream流提供 collect 方法，其参数需要一个 java.util.stream.Collector<T,A, R> 接口对象来指定收集到哪种集合中。幸运的是， java.util.stream.Collectors 类提供一些方法，可以作为Collector 接口的实例：

public static Collector<T, ?, List> toList() ：转换为 List 集合。
public static Collector<T, ?, Set> toSet() ：转换为 Set 集合。

public class Main {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("乔峰", "虚竹", "段誉", "天山童姥");
        List<String> list = stream.collect(Collectors.toList());
        Set<String> set = stream.collect(Collectors.toSet());
    }
}

收集到数组中

Stream提供 toArray 方法来将结果放到一个数组中，返回值类型是Object[]的：

public class Main {
    public static void main(String[] args) {
        String[] strings = {"10", "20", "30", "40"};
        Stream<String> stringStream = Stream.of(strings);
        Object[] objects = stringStream.toArray();
    }
}