lambda表达式用法超详细介绍（一篇文章足以学会lambda）

已于 2023-11-01 17:59:27 修改
阅读量861 收藏 3
点赞数 2
分类专栏： java基础 文章标签： java servlet 开发语言
于 2022-08-23 22:29:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45925197/article/details/126494051
版权

关于Lambda表达式的详细用法

重点：别只看不动手，脑子明白了，手可不一定。
本文来自于B站博主：倜傥的雷哥 的视频讲解总结

视频链接： 视频链接

文章目录

1. Lambda表达式

Lambda表达式起初是为了取代匿名内部类的使用，写出更优雅的代码，尤其是在集合的遍历和操作中，可以极大的简化代码的结构。

Jdk也提供了大量的内置函数式接口供我们使用。

缺点：代码更加难懂。

匿名内部类，以线程为例（没有名字的内部类）

    new Thread(new Runnable(){
        public void run(){
            
        }
    }).start();
1.1 Lambda表达式对接口的要求

虽然lambda表达式可以对某些接口进行简单的实现，但是不是所有的接口都可以用lambda表达式来实现，

Lambda表达式规定接口中只能有一个需要被实现的方法，但不是规定接口中只能有一个方法。其他方法可以使用default进行默认的实现，进而不影响Lambda表达式的使用。

1.2 @FunctionalInterface注解

修饰函数式接口的，要求被修饰的接口抽象方法只能有一个，这个注解往往和lambda表达式一起使用。

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/16:35
 * @Description:    @FunctionalInterface注解用来验证此接口中有且只能有一个被实现的方法
 */
@FunctionalInterface
public interface MyInterface {
//    只加a方法注解不会报错 再加上b接方法就会报错  除非把b方法用default进行默认实现
//    (注意被default修饰实现的方法得加上大括号方法体默认实现，抽象方法不用加方法体)
    void a();

    default void b() {
        
    }
}
1.3 lambda表达式的基础语法

首先准备未使用Lambda表达式简写的接口 ，方便后续作对比~别偷懒 认真点看！

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/16:41
 * @Description:   测试未使用lambda的接口
 */
public class LambdaInterface {
//无返回无参数
}
interface NoReturnNoParam{
        void method();
}
//无返回有一个参数
@FunctionalInterface
interface NoReturnOneParam{
        void method(int a);
}
//无返回有多个参数
@FunctionalInterface
interface NoReturnMultiParam{
        void method(int a,int b);
}
//有返回无参数
@FunctionalInterface
interface ReturnNoParam{
         int method();
}
//有返回有一个参数
@FunctionalInterface
interface ReturnOneParam{
    int method(int a);
}
//有返回有多个参数

interface ReturnMultiParam{
    int method(int a,int b);
}

真正强大的人能耐得住寂寞~认真看完!

1，重点如果方法体里面只有一句话可以直接省略去掉方法体。

2，参数类型也可以省略，即时是多个参数而且参数的类型不一样！

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/17:04
 * @Description: 使用Lambda 语法简化6种接口的表达
 */
public class LambdaTest01 {
    public static void main(String[] args) {
        //    无参无返回(未使用Lambda表达式调用语法较麻烦)
        NoReturnNoParam noReturnNoParam = new NoReturnNoParam() {
            @Override
            public void method() {
                System.out.println("未使用Lambda表达式!");
                System.out.println("未使用Lambda表达式!");
            }
        };
        noReturnNoParam.method();

//        无参无返回 使用Lambda表达式简化
        NoReturnNoParam noReturnNoParam0 = () -> {
            System.out.println("未使用Lambda表达式!");
            System.out.println("未使用Lambda表达式!");
        };
        noReturnNoParam0.method();
        // 无参无返回 使用Lambda表达式再次简化(这样写的前提是方法体里只有一句话)
        NoReturnNoParam noReturnNoParam1 = () -> System.out.println("未使用Lambda表达式!");
        noReturnNoParam1.method();


//       一个参数无返回值 使用Lambda表达式简化(打印10)
        NoReturnOneParam noReturnOneParam0 = (int a) -> System.out.println(a);
        noReturnOneParam0.method(10);

        //一个参数无返回值 使用Lambda表达式简化 也可以省略参数类型(打印12)
        NoReturnOneParam noReturnOneParam1 = (a) -> System.out.println(a);
        noReturnOneParam1.method(12);

//        多个参数无返回值(输出1和2)
        NoReturnMultiParam noReturnMultiParam = (int a, int b) ->
        {
            System.out.println(a);
            System.out.println(b);
        };
        noReturnMultiParam.method(1, 2);

//无参数有返回值  此时如果只有一条语句就可以去掉大括号(两种写法都是打印返回值110)
        ReturnNoParam returnNoParam0 = () -> {
            return 110;
        };
        ReturnNoParam returnNoParam1 = () -> 110;
        System.out.println(returnNoParam0.method());
        System.out.println(returnNoParam1.method());


        //    一个参数有返回值(输出6)
        ReturnOneParam returnOneParam = (a) -> a;
        System.out.println(returnOneParam.method(6));

       //多个参数有返回值(输出30)
        ReturnMultiParam returnMultiParam =(int a,int b)->a+b;
        System.out.println(returnMultiParam.method(10,20));



    }
}

2.方法引用

  • 如果一个类中的实现方法，其参数列表和返回值类型与某个函数式接口中的方法一致，那么可以使用方法引用的方式来代替Lambda表达式
  • Java编译器会利用函数式接口中的方法的参数来调用引用的方法，并将该方法的返回值（如果有的话）作为接口方法的返回值
  • 方法引用使用操作符：：将对象或者类的名字与方法名隔开。

Java中的方法引用有六种形式，可以根据情况选择使用：

  1. 静态方法引用： Class::staticMethodName。引用静态方法，例如：Math::max。

  2. 实例方法引用：

    • object::instanceMethodName，引用特定对象的实例方法。
    • Class::instanceMethodName，引用抽象类型的实例方法。

  3. 特定类的任意对象的方法引用： Class::instanceMethodName，引用特定类型的任意对象的实例方法。

  4. 构造方法引用： Class::new，引用构造函数。例如：ArrayList::new。

  5. 数组构造方法引用： Type[]::new，引用数组构造函数。例如：int[]::new。

  6. 超类的实例方法引用： super::instanceMethodName，引用超类的实例方法。

这些方法引用可根据上下文更清晰地表示Lambda表达式的操作，并且可以提高代码的可读性和简洁性。根据情况，选取合适的方法引用可以让代码更加简洁易懂。

Lambda 表达式方法引用格式如下：（结合例子看）

1，静态方法

​ 接口 对象名 =类名：：静态方法名；

2，实例方法

​ 接口 对象名 = 对象：：实例方法名；

​ BiFunction<类名, Integer, Integer> 对象名 = 类名：：实例方法名；

3，成员方法

（实例方法属于成员方法 ，实例方法是未使用static修饰的方法，成员方法是类中声明的方法）

​ 接口 对象名 = new 类名.成员方法名；

package com.zmz.lambda;

import java.util.function.BiFunction;
import java.util.function.ToIntBiFunction;

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/18:03
 * @Description:  Lambda表达式简化的写法(实现接口调用类的方法)
 */
public class Lambda02 {

    /*
     * @Description  这是一个静态方法
     * @Param
     * @return
     **/
    public static  int num(int n){
        return n+100;
    }
    /*
     * @Description 这是一个成员方法，也是一个实例方法
     * @Param
     * @return
     **/
    public int row(int a){
        return a+200;
    }


    public static void main(String[] args){
        //静态方法使用----------------------------------------
        //使用有一个参数,并带返回值(输出结果是20)
        ReturnOneParam returnOneParam = (a)->  a+10;
        System.out.println(returnOneParam.method(10));

        //使用有一个参数,并带返回值(输出结果是120) 调用本类静态方法直接调用
        ReturnOneParam returnOneParam0 = (a)->num(a);
        System.out.println(returnOneParam0.method(20));

        //使用有一个参数,并带返回值(输出结果是120) 调用某个类的静态方法格式如下 不需要箭头(此格式只支持方法不支持成员属性)
        ReturnOneParam returnOneParam1 = Lambda02::num;
        System.out.println(returnOneParam1.method(20));
        
        //成员方法使用------------------------------------------
        //使用有一个参数,并带返回值(输出结果是202)调用其他类或者本类的成员方法的另一种写法(其实就是实现了接口里的抽象方法)
        ReturnOneParam returnOneParam2 = (int b)->{
            return new Lambda02().row(b);};
        System.out.println(returnOneParam2.method( 2));
        
        
        //实例方法使用--------------------------------------------------
        //使用有一个参数,并带返回值(输出结果是201)因为row方法也属于实例方法 ，也可以用 对象::实例方法 方式调用
        Lambda02 lambda = new Lambda02();
        ReturnOneParam returnOneParam3 =  lambda::row;
        System.out.println(returnOneParam2.method(1));

        //使用有一个参数,并带返回值(输出结果是202)因为row方法也属于实例方法 ，也可以用 类名::实例方法 方式调用(目前测试该实例方法只允许一个参数一个返回值，如果多个参数可采用成员方法的方式调用)
        // 第一个参数是类名 第二个参数是传入的值  第三个参数是返回值
        /*
            public interface BiFunction<T, U, R> {
                R apply(T t, U u);
        */
         BiFunction<Lambda02, Integer, Integer> row = Lambda02::row;
         System.out.println(returnOneParam2.method(2));

    }

}
4.构造方法
/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/18:41
 * @Description:  lambda 实现接口调用类的构造方法
 */
class Item {
    int id;
    String name;
    double price;
    public Item(int id,String name,double price){
        this.id=id;
        this.name=name;
        this.price=price;
    }
    public Item(){

    }

}



public class Lambda03 {
    public static void main(String[] args) {
        //使用无参的构造方法来引用  输出对象com.zmz.lambda.Item@404b9385
        ItemCreatorBlankConstruct construct = () -> new Item();
        Item item1 = construct.getItem();
        System.out.println(item1);

        //使用无参的构造方法来引用  输出对象com.zmz.lambda.Item@404b9385
        ItemCreatorBlankConstruct construct2 =Item::new;
        Item item2 = construct2.getItem();
        System.out.println(item2);

        //使用有参构造方法来引用  输出对象com.zmz.lambda.Item@404b9385
        ItemCreatorParamConstruct construct3 =Item::new;
        Item item3 = construct3.getItem(1,"手机",9999);
        System.out.println(item3);
    }


}

    interface ItemCreatorBlankConstruct {
        Item getItem();
    }

    interface ItemCreatorParamConstruct {
        Item getItem(int id, String name, double price);
    }
5.Stream.map()中的引用(在后续的Stream流中会经常用到)
List<DocumentFile> fileList =new ArrayList<>();
//取出fileList中的fileUrl字段值再重新规约成一个集合
List<String> objectNames = fileList.stream().map(documentFile -> documentFile.getFileUrl()).collect(Collectors.toList());
//由于 Func1<DocumentFile, String> getFileUrls = DocumentFile::getFileUrl; Func1的第一个参数是参数类型第二个是返回值类型，源码如下
/**
public interface Func1<P, R> extends Serializable {
	R call(P parameter) throws Exception;
*/
//所以上面的.map的表达式等价于下面的
List<String> objectNames = fileList.stream().map(documentFile::getFileUrl).collect(Collectors.toList());
//或者以成员方法的方式考虑，类名::成员方法名

3,lambda表达式创建线程

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/19:04
 * @Description:    Lambda 表达式创建线程对象
 */
public class Lambda04 {
    public static  void mian(String [] args){
//        Runnable执行run方法无返回值  Callable执行call方法有返回值
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("创建线程");
            }
        }).start();
        
        //使用lambda表达式简化 因为上面的run没有参数没有返回值 new Runnable()可写为()->{}
        new Thread(
                ()->System.out.println("使用Lambda创建线程")
        ).start();

        ExecutorService executorService = Executors.newCachedThreadPool();
        //Runnable
        executorService.submit(()->{
            System.out.println("提交Runnable");
        });
        //Callable
        executorService.submit(()->{
            System.out.println("提交Callable");
            return "a";
        });
    }
     
}

4.遍历简单集合


/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/19:22
 * @Description:  使用Lambda表达式遍历简单集合
 */
public class Lmbda05 {
    public static  void main (String[] args){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
//        List<Integer> list2 =new ArrayList<>();
//        list2.add(1);
//        list2.add(2);
//        list2.add(3);
//        list2.add(4);
//        list2.add(5);
        //第一种for循环遍历
        for(Integer integer: list){
            System.out.println(integer+"\t");
        }
        //i++循环遍历
        for(int i=0 ;i<list.size();i++){
            System.out.println(list.get(i)+"\t");
        }
        //lambda表达式遍历  先看forEach源码其实就是个增强for 往forEach里面传入了一个接口参数Consumer
        // Consumer里面的方法有一个参数  无返回值

//        default void forEach(Consumer<? super T> action) {
//            Objects.requireNonNull(action);
//            for (T t : this) {
//                action.accept(t);
//            }
//        }
//        @FunctionalInterface
//        public interface Consumer<T> {
//
//            void accept(T t);
//        }
        list.forEach((t)->{
            System.out.println(t);
        });

        //进一步优化
        list.forEach(System.out::println);
    }
}

5，遍历复杂集合


/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/19:43
 * @Description:     构建一个实体类
 */
public class Item2 {
    int id;
    String name;
    double price;
    Item2(){
        
    }
    Item2(int id ,String name,double price){
        this.id= id;
        this.name =name;
        this.price =price;
    }
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Item2{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}


/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/19:47
 * @Description:  用lambda表达式遍历复杂集合
 */
public class Lambda06 {
    public static  void main(String [] args){
        List<Item2>  list = new ArrayList<>();
        list.add(new Item2(1,"阿萨",12.22));
        list.add(new Item2(2,"撒旦",12.21));
        list.add(new Item2(3,"答案",11.22));

        //以前的遍历方法
        for(int i =0 ;i<list.size() ;i++){
            System.out.println(list.get(i).id);
        }

        for(Item2 item2 :list){
            System.out.println(item2.getName());
        }

        list.forEach(i->System.out.println(i.getPrice()));

        list.forEach(System.out::println);
    }
}

6，集合元素删除

package com.zmz.lambda;

import java.util.ArrayList;
import java.util.List;

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/19:57
 * @Description: 用lambda表达式删除集合
 */
public class Lambda07 {
    public static  void main(String [] args) {
        List<Item2> list = new ArrayList<>();
        list.add(new Item2(1, "阿萨", 12.22));
        list.add(new Item2(2, "撒旦", 12.21));
        list.add(new Item2(3, "答案", 11.22));


        //以前的方法 删除id=3的元素
        for(Item2 item2:list){
            if(item2.id==3){
                list.remove(item2);
                break;
            }
        }
        list.forEach(t->System.out.println(t));

        //使用lambda移除id=3的元素
        list.removeIf(t->{
         return t.getId() ==3;
        });
        list.forEach(t->System.out.println(t));
        
        list.removeIf(t-> t.getId() ==3);
        list.forEach(t->System.out.println(t));
    }
}

7，集合排序


/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/07/30/20:17
 * @Description:  使用lambda进行集合排序
 */
public class Lambda08 {
    public static  void main(String [] args) {
        List<Item2> list = new ArrayList<>();
        list.add(new Item2(1, "阿萨", 10.22));
        list.add(new Item2(2, "撒旦", 20.21));
        list.add(new Item2(3, "答案", 22.22));


//        Collections.sort(list, new Comparator<Item2>() {
//            @Override
//            public int compare(Item2 o1, Item2 o2) {
//                return (int)(o1.getPrice()-o2.getPrice());
//            }
//        });
        list.forEach(t->System.out.println(t));

        Collections.sort(list,(a,b)->(int)(a.getPrice()-b.getPrice()));
        list.forEach(t->System.out.println(t));
    }
}

ps：一定要多学多练 ，语法知识只能熟能生巧L

下一篇文章有我对Stream流的详细介绍：
博客链接：Stream流的详细用法介绍

厌世小晨宇yu.
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
lambda表达式用法
枫影竹韵的博客
09-16 1038
Lambda 表达式实际上是一个函数，只是它没有名字，叫匿名函数。C++11新增了lambda函数，其基本格式如下 [捕捉列表] (参数) mutable -> 返回值类型 {函数体} "捕捉列表"，也叫“外部变量访问方式说明符”，可以是=或&，表示{}中用到的、定义在{}外面的变量在{}中是否允许被改变。=表示不允许，&表示允许。当然，在{}中也可以不使用定义在外面的变量。“-> 返回值类型”可以省略。 []是lambda的引出符，捕捉列表能够捕捉上下文中的变量，来供
Lambda 表达式使用详解，一篇文章手把手教会你
m0_70325779的博客
10-11 640
记住一句话就可以了，"有且仅有一个抽象方法的接口叫函数式接口，接口上可以添加@FunctionalInterface注解"。例如我们刚才使用的 Compartor 接口，它就是一个函数式接口，我们看一下它的源码就可以知道，如下图所示，接口上就标注有 @FunctionalInterface 注解。
Lambda表达式使用教程
最新发布
guanglihuan的专栏
03-21 288
Lambda表达式是Java 8引入的一种简洁的表示匿名方法的方式，它可以用更少的代码实现功能接口的实例。Lambda表达式特别适合创建简单的实现，并且经常与Java的流API（Stream API）一起使用。
Lambda表达式的用法（函数式接口、方法引用）
weixin_43872993的博客
04-10 3197
1、Lambda 表达式——Java 8 发布的最重要新特性 2、使用 Lambda 表达式可以使代码变的更加简洁紧凑
Lambda表达式：简介、语法和用法
沉淀、分享、成长，让自己和他人都能有所收获！
04-14 9391
Lambda表达式是一种匿名函数，它主要用于表示简单的行为或代码块，并可以在需要时传递到其他函数中。Lambda表达式可以看作是一个函数式接口的实例，它由三个部分组成：参数列表、箭头符号和表达式体。");在这个示例中，Lambda表达式包含一个空参数列表，箭头符号"->"和一个输出"Hello, World!"的表达式体。它可以通过调用Lambda表达式的函数式接口来执行。
Lambda表达式的使用介绍
Littewood的博客
03-10 1733
lambda表达式的使用
C#基础之Lambda表达式用法实例教程
09-04
主要介绍了C#中Lambda表达式用法,并与之前所述的匿名方法做一比较,详细的讲述了Lambda表达式的定义及具体用法,需要的朋友可以参考下
Java8新特性Lambda表达式的一些复杂用法总结
08-29
lambda表达式是JAVA8中提供的一种新的特性，它支持Java也能进行简单的“函数式... 下面这篇文章主要给大家介绍了关于Java8新特性Lambda表达式的一些复杂用法的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
python中的lambda表达式用法详解
01-20
本文实例讲述了python中的lambda表达式用法。分享给大家供大家参考，具体如下： 这里来为大家介绍一下lambda函数。 lambda 函数是一种快速定义单行的最小函数，是从 Lisp 借用来的，可以用在任何需要函数的地方 。...
Python学习笔记之lambda表达式用法详解
12-26
本文实例讲述了Python学习笔记之lambda表达式用法。分享给大家供大家参考，具体如下： Lambda 表达式 使用 Lambda 表达式创建匿名函数，即没有名称的函数。lambda 表达式非常适合快速创建在代码中以后不会用到的函数...
深入底层原理—带你看透Lambda表达式的本质
weixin_57907028的博客
05-28 1740
前言 嗨咯，大家好，今天给带大家深入底层原理看透Lambda表达式的本质，如果本文对你有帮助，记得一键三连一下！！ 知识点 Lambda的原理 Java 8支持动态语言，看到很酷的Lambda表达式，对一直以静态类型语言自居的Java，让人看到了Java虚拟机可以支持动态语言的目标。 Lambda的案例 import java.util.function.Consumer; public class Lambda { public static void main(String[] args) {
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
Lambda表达式总结
zxzxin的博客~
09-05 2万+
Lambda表达式总结 使用范例 使用范例 使用匿名内部类: Comparator&amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;Integer&amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;com = new Comparator&amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;Integer&amp;amp;amp;a
Lambda表达式使用
DYZ的博客
05-31 451
一、Lambda表达式是什么？ Lambda表达式有两个特点：一是匿名函数，二是可传递。 匿名函数的应用场景是： 通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用Lambda表达式。lambda表达式所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。 可传递使用场景是： 就是将Lambda表达式传递给其他的函数，它当...
Lambda表达式使用整理总结
盛夏温暖流年
08-30 3480
Lambda 表达式的基础语法 : Java8 中引入了一个新的操作符 “-&amp;gt;“， 该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分 : 左侧 : Lambda 表达式的参数列表； 右侧 : Lambda 表达式中所需执行的功能， 即 Lambda 体； 基本语法: (parameters) -&amp;gt; expression 或 (p...
Java 8 官方教程翻译——Lambda表达式
coderock
12-26 1843
使用匿名类的一个问题是，如果匿名类的实现过于简单，例如实现的接口只包含一个方法，那么匿名类的语法就显得笨拙和不清晰。在这种情况下，你要做的事情通常是向某方法传递一些功能代码块，例如在响应按钮被点击时应该执行什么操作。Lambda表达式能简化这项工作，它将功能代码块作为参数，或者说将代码当数据。 在前一节中讲述匿名类时，我们向你展示了如何在不指定类名的情况下实现一个类。即使这样要比
java8 手把手教你学会写lambda表达式
热门推荐
bitcarmanlee的博客
04-16 7万+
Java8发布已经有一段时间了，这次发布的改动比较大，很多人将这次改动与Java5的升级相提并论。Java8其中一个很重要的新特性就是lambda表达式，允许我们将行为传到函数中。想想看，在Java8 之前我们想要将行为传入函数，仅有的选择就是匿名内部类。Java8发布以后，lambda表达式将大量替代匿名内部类的使用，简化代码的同时，更突出了原来匿名内部类中最重要的那部分包含真正逻辑的代码。尤其
Lambda表达式详解
weixin_33866037的博客
06-30 426
前言         1、天真热，程序员活着不易，星期天，也要顶着火辣辣的太阳，总结这些东西。         2、夸夸lambda吧：简化了匿名委托的使用，让你让代码更加简洁，优雅。据说它是微软自c#1.0后新增的最重要的功能之一。 lambda简介      lambda运算符：所有的lambda表达式都是用新的lambda运算符 " =&gt; ",可以叫他，“转到”或者 “成为”。...
lambda表达式拿泛型T的真实类型
hotpots--火锅技术栈
04-18 5305
1、通过接口类型stringConsumer的class是没有泛型T的 2、应该从匿名内部类的class(也就是实现类)获取：解决办法1)自己实现接口2)通过lambda生成的匿名类class对象获取 /** * 拿泛型的T 类型 * interface Consumer<T> * @when 2019...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

厌世小晨宇yu.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值