lambda 表达式的使用

最新推荐文章于 2022-09-27 16:52:44 发布
最新推荐文章于 2022-09-27 16:52:44 发布
阅读量222 收藏
点赞数
分类专栏： JAVA基础 文章标签： lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nian_chen/article/details/103886326
版权

一、什么是 lambda 表达式

Java8 是我们使用最广泛的稳定 Java 版本，lambda 就是其中最引人瞩目的新特性。lambda 是一种闭包，它允许把函数当做参数来使用，是面向函数式编程的思想，可以使代码看起来更加简洁。是不是听得一脸懵逼？我举个例子你就明白了。

package com.nianchen.lambda;

import org.junit.Test;

public class InitialExample {
    @Test
    public void innerClassMain() {

        //匿名内部类写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("内部类写法");
            }
        }).start();
    }

    @Test
    public void lambdaMain() {

        //lambda表达式 写法
        new Thread(() -> System.out.println("lambda 写法")).start();
    }
}

我们应该知道，实现线程有两种方法，一是继承 Thread 类，二是实现 Runnable 接口。那这里采用的就是后者，后者是一个函数式接口。

1.1 函数式接口

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

从 Runnable 源码可以看到，它是一个函数式接口。这类接口的特点是：用 @FunctionalInterface注解修饰（主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错），有且只有一个抽象方法。在原生 JDK 中的这类接口就可以使用 lambda 表达式。

上面的概念提到，把函数当做参数来使用。上面的 lambda 例子中，Thread 类的参数就是一个 Runnable 接口，lambda 就是实现这个接口并把它当做参数使用。所以上面的 () -> System.out.println ("lambda 写法") 就是一个整个 lambda 表达式的参数（注意与后面的方法参数区分开，后面会讲）。细品加粗这句话，可以总结出，lambda 表达式就是创建某个类的函数式接口的实例对象。 如：

Runnable runnable = () -> System.out.println("lambda 写法");

二、为什么需要 lambda 表达式

明白了什么是  lambda 表达式，那为什么要使用它呢？注意到使用 lambda 创建线程的时候，我们并不关心接口名，方法名，参数名。我们只关注他的参数类型，参数个数，返回值。所以原因就是简化代码，提高可读性。

三、如何使用 lambda 表达式

3.1 lambda 语法

// 格式遵循: (接口参数)->表达式(具体实现的方法)
(paramters) -> expression 或 (parameters) ->{ expressions; }

                                                                                       lambda 语法例子

具体解释，如上图。此外，lambda 语法注意点：

  • 可选类型声明：方法参数不需要声明参数类型，编译器可以统一识别参数值。

  • 可选的参数圆括号：一个参数无需定义圆括号，但无参数或多个参数需要定义圆括号。

  • 可选的大括号：如果具体实现方法只有一个语句，就不需要使用大括号 {}。

  • 可选的返回关键字：如果具体实现方法只有一个表达式，则编译器会自动返回值，如果有多个表达式，括号中就需要指定明表达式返回了一个数值。

3.2 使用示例：

package com.nianchen.lambda;

public class Example {

    // 定义函数式接口，只能有一个抽象接口，否则会报错
    // 希望在编译时检测报错，请加 @FunctionalInterface 注解
    @FunctionalInterface
    public interface Hello{
        String hi();
    }

    public interface Hello2{
        String hei(String hello);
    }

    public interface Hello3{
        String greet(String hello, String name);
    }

    public static void main(String[] args) {

        //无参数
        Hello no_param = () -> "hi, no param";
        Hello no_param2 = () -> {
            return "hi, no param2";
        };
        System.out.println(no_param.hi());
        System.out.println(no_param2.hi());

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

        //单个参数，一条语句，可以省略大括号和return
        Hello2 param = name -> name;
        Hello2 param2 = name -> {
            return name;
        };
        System.out.println(param.hei("hei,单个参数"));
        System.out.println(param2.hei("hei,单个参数2"));

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

        //多个参数
        Hello3 multiple = (String hello, String name) -> hello + ", " + name + "省略大括号与return";
        Hello3 multiple2 = (hello, name) -> hello + ", " + name + "省略参数类型定义";
        Hello3 multiple3 = (hello, name) -> {
            System.out.println("多参数内部");
            return hello + ", " +name;
        };

        System.out.println(multiple.greet("hello", "顺利的运行,"));
        System.out.println(multiple2.greet("hello", "顺利的运行,"));
        System.out.println(multiple3.greet("hello", "顺利的运行"));
    }
}

3.3 方法引用

看一个简单的方法引用例子：

Consumer<String> sc = System.out::println;
sc.accept("lambda 示例");

// 等效于
Consumer<String> sc2 = (x) -> System.out.println(x);
sc2.accept("lambda 实例");

Consumer 函数式接口源码：

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

你可能有点懵，为什么可以这样写？别急我们分析一波：Consumer是一个函数式接口，抽象方法是 void accept (T t)，参数是 T。那我们现在有这样一个需求，我想利用这个接口的抽象方法，做一下控制台打印。正常情况下，我们需要实现这个接口，实现它的抽象方法，来实现这个需求：

public class ConsumerImpl implements Consumer<String> {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
}

实现之后，这个抽象方法变具体了。作用就是控制台打印，那就意味着抽象方法刚好可以用实际方法：System.out.println (s) 来实现，所以我们可以使用方法引用。

总结：函数式接口的抽象方法实现恰好可以通过调用一个实际方法来实现时，就可以用方法引用。

方法引用的三种形式：

// 将抽象方法参数当做实际方法的参数使用
对象：：实例方法 objectName::instanceMethod
// 将抽象方法参数当做实际方法的参数使用
类：：静态方法 ClassName::staticMethod
// 将方法参数的第一个参数当做方法的调用者，其他的参数作为方法的参数
类：：实例方法  ClassName::instanceMethod

我们来自定义一个方法类：

package com.nianchen.lambda;

public class Method {
    //静态方法
    public static void StaticMethod(String name){
        System.out.println(name);
    }

    //实例方法
    public void instanceMethod(String name){
        System.out.println(name);
    }

    //无参构造
    public Method(){}

    //有参构造
    public Method(String methodName){
        System.out.println(methodName);
    }
}

测试用例：

package com.nianchen.lambda;

import java.util.function.BiPredicate;
import java.util.function.Consumer;

public class MethodExample {
    public static void main(String[] args) {
        //静态方法引用 -- 通过类名调用
        Consumer<String> consumerStatic = Method::StaticMethod;
        consumerStatic.accept("静态方法");

        //等价于
        Consumer<String> consumerStatic2 = (x) -> Method.StaticMethod(x);
        consumerStatic2.accept("静态方法2");

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

        //非静态方法引用 -- 通过实例调用
        Method method = new Method();
        Consumer<String> consumerInstance = method::instanceMethod;
        consumerInstance.accept("对象的实例方法");

        //等价于
        Consumer<String> consumerInstance2 = (x) -> method.instanceMethod(x);
        consumerInstance2.accept("对象的实例方法2");

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

        // ClassName::instanceMethod 类的实例方法：把表达式的第一个参数当成 instanceMethod 的调用者，其他参数作为该方法的参数
        BiPredicate<String, String> sbp = String::equals;
        System.out.println("类的实例方法：" + sbp.test("a", "A"));

        //等效于
        BiPredicate<String, String> sbp2 = (x,y) -> x.equals(y);
        System.out.println("类的实例方法2：" + sbp2.test("a", "A"));


    }
}

输出结果：

静态方法
静态方法2
================
对象的实例方法
对象的实例方法2
================
类的实例方法：false
类的实例方法2：false

3.4 构造器引用

package com.nianchen.lambda;

import java.util.function.Function;
import java.util.function.Supplier;

public class ConstructMethodExample {
    public static void main(String[] args) {

        //构造方法方法引用 -- 无参数（可以使用方法引用）
        Supplier<Method> supplier = Method::new;
        System.out.println(supplier.get());

        //等价于
        Supplier<Method> supplier2 = () -> new Method();
        System.out.println(supplier2.get());

        //构造方法方法引用 -- 有参
        Function<String, Method> uf = name -> new Method(name);
        Method method = uf.apply("有参构造");
        System.out.println(method.toString());
        System.out.println(uf.apply("直接输出"));
    }
}

参考：https://www.cnblogs.com/kingsonfu/p/11047116.html

3.5 变量作用域

lambda 表达式只能引用 final 或隐性的具有final(不用声明为 final，但是必须不可被后面的代码修改)的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

package com.nianchen.lambda;

public class VariableScopeTest {
    //定义一个接口
    public interface Converter<T1,T2>{
        void convert(int i);
    }

    public static void main(String[] args) {

        //定义为final 强制不能修改
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        //输出结果为3
        s.convert(2);
    }
}

变量不声明为 final ，修改变量后，导致可以修改外部变量报错：

int num = 1;
num++;
//表达式中num会报错（Variable used in lambda expression should be final or effectively final）
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);

此外，在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量

String str= "";
// 同为 str 变量名，编译会出错
Comparator<String> comparator = (str, str1) -> Integer.compare(str.length(), str1.length());

四、十大 lambda 表达式示例

 

nian_chen
关注
专栏目录
推荐系统Lambda架构算法（九）：基于内容的电影推荐——用户画像
汪雯琦的博客
03-08 1495
文章目录基于内容的电影推荐：用户画像用户画像建立 基于内容的电影推荐：用户画像 用户画像构建步骤： 根据用户的评分历史，结合物品画像，将有观影记录的电影的画像标签作为初始标签反打到用户身上 通过对用户观影标签的次数进行统计，计算用户的每个初始标签的权重值，排序后选取TOP-N作为用户最终的画像标签 用户画像建立 import pandas as pd import numpy as np fr...
＜Zhuuu_ZZ＞HIVE(十一)函数
Zhuuu_ZZ的博客
09-22 2570
Hive内置函数一 Hive函数分类二 字符函数二 类型转换函数和数学函数三 日期函数四 集合函数五 条件函数六 聚合函数和表生成函数6.1 聚合函数6.2 表生成函数：输出可以作为表使用 一 Hive函数分类 从输入输出角度分类 标准函数：一行数据中的一列或多列为输入，结果为单一值 聚合函数：多行的零列到多列为输入，结果为单一值 表生成函数：零个或多个输入，结果为多列或多行 从实现方式分类 内置函数 自定义函数 UDF：自定义标准函数 UDAF：自定义聚合函数 UDTF：自定义表生成函数
简化正则化 Lambda
stone_tomcate的博客
07-22 460
模型开发者通过以下方式来调整正则化项的整体影响：用正则化项的值乘以名为lambda（又称为正则化率）的标量。也就是说，模型开发者会执行以下运算： minimize(Loss(Data|Model)+λcomplexity(Model)) 执行L2正则化对模型具有以下影响 使权重值接近于 0（但并非正好为 0） 使权重的平均值接近于 0，且呈正态（钟形曲线或高斯曲线）分布。 增加 lambda 值将增强正则化效果。 例如，lambda 值较高的权重直方...
lambda :: 和计算list中某个字段值的总和
热门推荐
qq_35642849的博客
12-11 2万+
用lambda表达式计算一个list中的某个字段值的总和 int total = List.stream().mapToInt(entity::getDistance).sum(); 解释：List是要计算的list，mapToInt是将实体类entity中的属性转换为int，最后是sum求总共，lambda的stream可以理解为时做了一个循环 其中:: 也是匿名函数的一种 转自：http...
Lambda表达式
qq_42313904的博客
03-22 609
Lambda表达式是JDK8推出一个重要的新特性，是一种语法糖，其主要目的是可以代替匿名类，简化代码，此外还可以用于foreach和对象生成器接口。为了便捷开发，JDK 提供了大量的内置函数式接口供我们使用。
C#连接数据库 —— （二）Linq To EF 的 lambda表达式使用 ，增删查改、判断、分组、排序
12-14
在本篇文章中，我们将深入探讨如何使用Linq To EF结合Lambda表达式进行数据库操作。 首先，为了开始使用Linq To EF，我们需要创建一个数据库实体对象。在示例中，我们创建了一个名为`DbTrainEntities`的对象： ```...
Java的lambda表达式讲解代码（各种lambda表达式使用方式：无参、一个参数、多参数、简化形式...）
06-27
适用人群 本源码资源适用于具备一定Java编程基础的开发人员和学习者。...2、函数式接口与Lambda表达式：学习如何使用Lambda表达式与不同类型的函数式接口进行交互，并了解如何通过Lambda表达式实现函数的传递和组合
C++ Lambda表达式使用详解
01-20
　对于一次性的，带参数表达式，用LB可以节省不必要的class定义和维护，简化程序的设计-维护代价。 　比如下面的vector处理代码，简洁明了： 　vector<int> v1(10， 1); 　int sum = 0; 　for_each (v1.begin()...
Java语法之 Lambda表达式使用
liucy007的博客
09-27 807
匿名内部类，就是没有名字的一种嵌套类。它是Java对类的定义方式之一，最本质的还是一个类该类没有名字（但是系统会分配一个代号在内存中）
python基础教程之lambda表达式使用方法
01-20
Python中，如果函数体是一个单独的return expression语句，开发者可以选择使用特殊的lambda表达式形式替换该函数： 复制代码 代码如下:lambda parameters: expression lambda表达式相当于函数体为单个return语句的...
Lambda 表达式之从 foreach(out::println) 到自定义输出
howeres的博客
08-16 1925
List<String> str1 = new ArrayList<>(); str1.add("hello"); str1.add("world"); //下面就是lambda表达式之“::”的应用了 str1.forEach(System.out::println); //两种方式等效 str1.forEach((item)->{ System.out.println(item); }); 这个双冒号的原理就是将左边的System.out类联合forEach的参数传入，
Lambda 实现算术计算
科技之星==================>Future
01-20 714
1.编写函数式接口 @FunctionalInterface private interface Test2<T>{ public T getResult(int a,int b); } 2编写测试类 @Test public void addTest(){ Test2<Integer> test2 = ...
JavaWeb——多线程的五种创建方法（继承Thread类、匿名内部类、Runnable接口、匿名内部类重写runnable、lambda表达式），Thread类的常见构造方法、属性
char_m的博客
06-16 948
多线程创建继承Thread类查看线程 创建 一个进程包含一个主线程main，如果要新建线程就需要，使用线程中的start（）方法，此时内核中出现了一个pcb对象，这个pcb就会让cpu执行对应的代码， 继承Thread类 创建线程需要使用Thread 类，来创建一个Thread 的实例，另一方面还需要给这个线程指定，要执行哪些指令/代码，指定指令的方式有很多种方式，此处先用种简单的，直接继承 Thread 类，重写Thread类中的run方法. public class Create { stati
python里三种等待元素的方法
weixin_34265814的博客
02-27 299
在做web或app的自动化测试经过会出现找不到元素而报错的情况，很多时候是因为元素 还没有被加载出来，查找的代码就已经被执行了，自然就找不到元素了。那么我可以用等待 元素加载完成后再执行查找元素的code。 Python里有三种等待的方式：一、 强制等待 Sleep(54) 这个方法在time模块，使用时通过from time import sleep导入比如： Sleep(10) #表示强行等...
python之使用lambda定义匿名函数实现计算器功能
HelloWorld小码农的博客
10-13 2018
文章地址： python之使用lambda定义匿名函数实现计算器功能 更多精彩内容，敬请扫码关注（HelloWorld小码农）：  
lambda表达式的使用详解
peiyuWang_2015的博客
05-22 2万+
首先我们来看一段简单的代码： interface ILambdaTest1{ void print(String s); } public class LambdaTest1 { public static void main(String[] args) { //传统内部类的实现 LambdaUse(new ILambdaTest1() { @Override publ
c语言盒子接球游戏源码.rar
11-15
c语言盒子接球游戏源码
YOLOv8-streamlit-app软件，使用yolov8做的物体识别语义分割姿态检测，使用streamlit做的显示界面
11-15
YOLOv8-streamlit-app软件，使用yolov8做的物体识别语义分割姿态检测，使用streamlit做的显示界面。下载即可运行，可做毕业设计。
MATLAB与计算物理课程 （第十周）第三章线性方程组的迭代法 共70页.pptx
最新发布
11-15
MATLAB与计算物理课程 （第十周）第三章线性方程组的迭代法 共70页.pptx
lambda表达式使用
08-11
当你想要在某个地方定义一个简短的匿名函数时，可以使用C++中的lambda表达式。lambda表达式是C++11引入的一种特性，它允许你在需要函数对象的地方定义一个函数，而不必显式地创建一个函数对象。 下面是一个lambda...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值