精华内容
下载资源
问答
  • 文章目录1.lambda表达式:1.1向lambda表达式传递参数1.2 使用捕获列表1.3 捕获形式:1.4 修改捕获值 mutable:1.5 指定返回类型:1.6 lambda主要使用场合:1. lambda表达式基本使用2 lambda捕获块2.1 捕获的简单使用2.4 ...

    1.lambda表达式:

    一个lambda表达式表示一个可调用的代码单元,可以将其理解为一个未命名的内联函数.
    lambda表达的格式如下:

    [capture-lists](parameter-lists)->return type{function body}
    capture-lists:捕获列表,可以用来捕获lambda表达式所在函数中定义的局部变量;可以为空,不可以省略;
    parameter-lists:参数列表,同普通函数;可以为空,也可以省略;
    return type:返回类型,一般可以省略,在lambda不能自动推算指定类型时,需要指定返回类型;可以省略;
    function body:函数体,同一般函数体.

    所以最简单的lambda表达式如下:
    [capture-lists]{function body}

    int a=100;
    
    //在此处调用一个可调用对象fun,接收一个参数,返回一个int类型值(此处->int 可以省略)
    auto fun=[](int a)->int {   
      return a;
    };//此处有';'
    
    cout<<fun(a)<<endl;//lambda的调用方式和普通函数的调用方式相同,都是使用调用运算符;
    

    1.1向lambda表达式传递参数

    与普通函数传递形参的方式是相同的,调用一个lambda表达式时给定的实参被用来初始化lambda的形参,实参和形参类型要相同,但是,lambda表达式不能使用默认参数

    1.2 使用捕获列表

    虽然一个lambda表示可以出现在一个函数中,使用其局部变量,但它只能使用那些明确指明的变量,一个lambda表达式通过将局部变量包含在其捕获列表中来指出将会使用的这些变量,捕获列表指引lambda表达式在其内部包含访问局部变量所需要的信息;

    #include <iostream>
    #include <functional>
    using namespace std;
    int main()
    {
        int a = 100;
        //a是一个局部变量,按理说在其生命周期内,在{}是可以访问的,但是在lambda表达式是不允许的,
        //所以需要通过捕获列表将a传到lambda表示式中;
        {
            cout << a << endl; //合法
        }
        // auto func = []
        // {
        //     cout << a << endl; //非法
        // };
    
        //需要捕获a,值传递(复制),在{}中不可修改a的值;
        auto func = [a] {cout << a << endl;}; //合法
        func();
        //引用传递,在{}中可修改a的值
        auto func1 = [&a] {cout << a << endl;}; //合法
        func1();
        //或者通过参数列表
        auto func2 = [](int a) {cout << a << endl;}; //合法
        func2(a);
        return 0;
    }
    

    1.3 捕获形式:

    1. 值捕获(显示):即采用实参复制到形参,采用值捕获的前提是变量可以拷贝,与参数不同的是,被捕获的变量的值是在lambda创建时拷贝,而不是调用时拷贝.值捕获参考上面代码.
    2. 引用捕获(显示):同一般引用;
    3. 隐式捕获(隐式):
    4. 隐式+显示:混合使用隐式与显示捕获时,捕获列表中的第一个元素必须是一个=或&
    捕获格式含义
    [ ]空捕获列表.lambda不会使用所在函数中的变量.一个lambda只有捕获变量后才能使用他们
    [names]names是一个用逗号分隔的名字列表,这些名字都是lambda表达式所在函数的局部变量.默认情况下,捕获列表中的变量都是被拷贝,名字前如果使用了&则采用引用捕获的方式
    &隐式捕获列表采用引用捕获方式.lambda表达式中所使用的来自所在函数的实体都采用引用方式
    =隐式捕获列表,采用值捕获方式,lambda体将拷贝所使用的来自所在函数的实体的值
    [&,identifier_list]identifier_list是一个逗号分隔开的列表,包含0个或多个来自所在函数的变量.这些变量采用值捕获方式,而任何隐藏式捕获的变量都采用引用方式捕获.identifier_list的名字前面不能在使用&
    [=,identifier_list]identifier_list的变量都采用引用方式捕获,而任何隐式捕获的变量都采用值捕获.identifier_list中的名字不能包含this,且这些名字前面必须使用&
    //a,前面不能使用&
    auto func3=[&,a](int x){cout<<a<<" "<<b<<endl;};
    func3(b);
    
    //a,前面必须使用&
    auto func3=[=,&a](int x){cout<<a<<" "<<b<<endl;};
    func3(b);
    

    1.4 修改捕获值 mutable:

    默认情况下,对于一个值被拷贝的变量,lambda不会改变其值.如果我们希望能改变一个被捕获的变量的值,就必须在参数的列表首加上关键字mutable

    //值被拷贝不能直接改变a的值
    int a=100;
    auto func4=[a](int b) mutable{
            a++;
            cout<<"a= "<<a<<" b="<<b<<endl;//
        };
        func4(b);//输出a=101
                            
        cout<<"[] :"<<a<<endl;//输出100
                                //由于采用的拷贝构造,所以原来的值不会被改变;
    

    1.5 指定返回类型:

    一般情况下,lambda表达式会推断出返回值,但是在某些时候,lambda表达式推断的类型与返回类型不符,此时就需要指定返回类型.默认情况下,如果一个lambda的体包含return之外的任何语句,则编译器假定此lambda返回void,与其他返回void的函数类似,被推断返回void的lambda不能返回值

    transform(vi.begin(),vi.end(),vi.begin(),[](int i){return i>0 ? i: -i;});
    

    函数transform接受三个迭代器和一个可调用对象,前两个迭代器表示输入序列,第三个迭代器表示目的位置.算法对输入序列中每个元素调用对象,并将结果写到目的位置.如本例中,目的位置迭代器与表示输入序列开始位置的迭代器可以是相同的.当输入迭代器和目的迭代器相同时,transform将输入序列中每一个元素替换为可调用对象操作该元素得到的结果;
    在本例中,我们传递个transform一个lambda,它返回其参数的绝对值.lambda体是单一的return语句,返回一个条件表达式的结果,我们无需指定返回类型,因为可以根据条件运算符的类型推断出来.
    如果将上式等价转换:

    transform(vi.begin(),vi.end(),vi.begin(),[](int i){if(i<0)return -i;else return i;});;//编译出错;(在linux没有报错?)
    

    编译器推断这个版本lambda返回类型为void,但他返回一个int;
    所以我们需要指定返回类型

    transform(vi.begin(),vi.end(),vi.begin(),[](int i)->int {if(i<0)return -i;else return i;});
    

    1.6 lambda主要使用场合:

    1. 简单函数
    2. lambda表达式作为回调函数;
    #include <iostream>
    #include <array>
    #include <algorithm>
    
    int main()
    {
        int x = 8;
        std::array<int, 999> arr;
        for (int i =1; i< 1000; i++)
        {
            arr[i] = i;
        }
        int cnt = std::count_if(arr.begin(), arr.end(), [x](int a){ return a%x == 0;});
        std::cout << "cnt=" << cnt << std::endl;
        return 0;
    }
    
    

    这里很明显,我们指定了一个lambda表达式来作为一个条件,更多时候,是使用排序函数的时候,指定排序准则,也可以使用lambda表达式。


    此部分内容来自知乎:https://zhuanlan.zhihu.com/p/373745326

    lambda表达式是C++11中引入的一项新技术,利用lambda表达式可以编写内嵌的匿名函数,用以替换独立函数或者函数对象,并且使代码更可读。

    所谓函数对象(仿函数),其实就是对operator()进行重载进而产生的一种行为,比如,我们可以在类中,重载函数调用运算符(),此时类对象就可以直接类似函数一样,直接使用()来传递参数,这种行为就叫做函数对象,同样的,它也叫做仿函数

    1. lambda表达式基本使用

    lambda表达式基本语法如下:

    [ 捕获 ] ( 形参 ) -> ret { 函数体 };

    lambda表达式一般都是以方括号[]开头,有参数就使用(),无参就直接省略()即可,最后结束于{},其中的ret表示返回类型

    我们先看一个简单的例子,定义一个可以输出字符串的lambda表达式,完整的代码如下:

    #include <iostream>
    
    int main()
    {
        auto atLambda = [] {std::cout << "hello world" << std::endl;};
        atLambda();
        return 0;
    }
    
    

    上面定义了一个最简单的lambda表达式,没有参数。如果需要参数,那么就要像函数那样,放在圆括号里面,如果有返回值,返回类型则要放在->后面,也就是尾随返回类型,当然你也可以忽略返回类型,lambda会帮你自动推导出返回类型,下面看一个较为复杂的例子:

    #include <iostream>
    
    int main()
    {
        auto print = [](int s) {std::cout << "value is " << s << std::endl;};
        auto lambAdd = [](int a, int b) ->int { return a + b;};
        int iSum = lambAdd(10, 11);
        print(iSum);
    
        return 0;
    }
    
    

    lambAdd有两个入参a和b,然后它的返回类型是int,我们可以试一下把->int去掉,结果是一样的。

    2 lambda捕获块

    2.1 捕获的简单使用

    在第1节中,我们展示了lambda的语法形式,后面的形参和函数体之类都好理解,那么方括号里面捕获是啥意思呢?

    其实这里涉及到lambda表达式一个重要的概念,就是闭包。

    这里我们需要先对lambda表达式的实现原理做一下说明:当我们定义一个lambda表达式后,编译器会自动生成一个匿名类,这个类里面会默认实现一个public类型的operator()函数,我们称为闭包类型。那么在运行时,这个lambda表达式就会返回一个匿名的闭包实例,它是一个右值。

    所以,我们上面的lambda表达式的结果就是一个一个的闭包。闭包的一个强大之处是可以通过传值或者引用的方式捕获其封装作用域内的变量,前面的方括号就是用来定义捕获模式以及变量,所以我们把方括号[]括起来的部分称为捕获块。

    看这个例子:

    #include <iostream>
    
    int main()
    {
        int x = 10;
        auto print = [](int s) {std::cout << "value is " << s << std::endl;};
        auto lambAdd = [x](int a) { return a + x;};
        auto lambAdd2 = [&x](int a, int b) { return a + b + x;};
        auto iSum = lambAdd(10);
        auto iSum2 = lambAdd2(10, 11);
        print(iSum);
        print(iSum2);
    
        return 0;
    }
    
    

    当lambda块为空时,表示没有捕获任何变量,不为空时,比如上面的lambAdd是以复制的形式捕获变量x,而lambAdd2是以引用的方式捕获x。那么这个复制或者引用到底是怎么体现的呢,我们使用gdb看一下lambAdd和lambAdd2的具体类型,如下:

    (gdb) ptype lambAdd
    type = struct <lambda(int)> {
        int __x;
    }
    (gdb) ptype lambAdd2
    type = struct <lambda(int, int)> {
        int &__x;
    }
    (gdb)
    

    前面我们说过lambda实际上是一个类,这里得到了证明,在c++中struct和class除了有少许区别,其他都是一样的,所以我们可以看到复制形式捕获实际上是一个包含int类型成员变量的struct,引用形式捕获实际上是一个包含int&类型成员变量的struct,然后在运行的时候,会使用我们捕获的数据来初始化成员变量。

    既然有初始化,那么必然有构造函数啊,然后捕获生成的成员变量,有operator()函数,暂时来讲,一个比较立体的闭包类型就存在于我们脑海中啦,对于lambda表达式类型具体组成,我们暂时放一放,接着说捕获。

    捕获的方式可以是引用也可以是复制,但是到底有哪些类型的捕获呢?

    捕获类型如下:

    • [ ]:默认不捕获任何变量;
    • [=]:默认以复制捕获所有变量
    • [&]:默认以引用捕获所有变量
    • [x]:仅以复制捕获x,其它变量不捕获;
    • [x…]:以包展开方式复制捕获参数包变量;
    • [&x]:仅以引用捕获x,其它变量不捕获;
    • [&x…]:以包展开方式引用捕获参数包变量;
    • [=, &x]:默认以复制捕获所有变量,但是x是例外,通过必须引用捕获;
    • [&, x]:默认以引用捕获所有变量,但是x是例外,通过复制捕获;
    • [this]:通过引用捕获当前对象(其实是复制指针);
    • [*this]:通过复制方式捕获当前对象;

    可以看到,lambda是可以有多个捕获的,每个捕获之间以逗号分隔,另外呢,不管多少种捕获类型,万变不离其宗,要么以复制方式捕获,要么以引用方式捕获。

    那么复制捕获和引用捕获到底有什么区别呢?

    标准c++规定,默认情况下,在lambda表达式中,对于operator()的重载是const属性的,也就意味着如果以复制形式捕获的变量,是不允许修改的,看这段代码:

    #include <iostream>
    
    int main()
    {
        int x = 10;
        int y = 20;
        auto print = [](int s) {std::cout << "value is " << s << std::endl;};
        auto lambAdd = [x](int a) { 
        //  x++;  此处x是只读,不允许自增,编译会报错
            return a + x;
        };
        auto lambAdd2 = [&x](int a, int b) { 
            x = x+5;
            return a + b + x;
        };
        auto iSum = lambAdd(10);
        auto iSum2 = lambAdd2(10, 11);
        print(iSum);
        print(iSum2);
    
        return 0;
    }
    
    

    从代码可以看出,复制捕获不允许修改变量值,而引用捕获则允许修改变量值,为什么呢,这里我理解,&x实际上是一个int*类型的指针,所以我们可以修改x的值,因为我们只是对这个指针所指向的内容进行修改,并没有对指针本身进行修改,且与我们常规声明的引用类型入参一样,修改的值在lambda表达式外也是有效的。

    解决方法:那么如果我想使用复制捕获,又想修改变量的值呢,这时我们就想起来有个关键字,叫做mutable,它允许在常成员函数中修改成员变量的值,所以我们可以给lambda表达式指定mutable关键字,如下:

    #include <iostream>
    
    int main()
    {
        int x = 10;
        int y = 20;
        auto print = [](int s) {std::cout << "value is " << s << std::endl;};
        auto lambAdd = [x](int a) mutable { 
            x++;
            return a + x;
        };
        auto iSum = lambAdd(10);
        print(iSum);
        print(x);
    
        return 0;
    }
    
    

    所以加上mutable以后就可以对复制捕获进行修改,但有一点,它的修改出了lambda表达式以后就无效了

    2.4 捕获的作用

    我再看lambda的捕获的时候一直很奇怪,初看的话,这个捕获跟传参数有什么区别呢,都是把一个变量值传入lambda表达式体供使用,但仔细思考的话,它是有作用的,假设有这么一个案例,一个公司有999名员工,每个员工的工号是从1~999,我们现在想找出工号是8的整数倍的所有员工,一个可行的代码如下:

    #include <iostream>
    #include <array>
    
    int main()
    {
        int x = 8;
        auto t = [x](int i){
            if ( i % x == 0 )
            {
                std::cout << "value is " << i << std::endl;
            }
        };
        auto t2 = [](int i, int x){
            if ( i % x == 0 )
            {
                std::cout << "value is " << i << std::endl;
            }
        };
        for(int j = 1; j< 1000; j++)
        {
            t(j);
            t2(j, x);
        }
        return 0;
    }
    

    表达式t使用了捕获,而表达式t2没有使用捕获,从代码作用和量来看,它们其实区别不大,但有一点,对于表达式t,x的值只复制了一次,而对于t2表达式,每次调用都要生成一个临时变量来存放x的值,这其实是多了时间和空间的开销,不过,对于这段代码而言,这点消耗可以忽略不计呢,但一旦数据上了规模,那就会有比较大的区别了?

    对于捕获,还是**尽量不要使用=或者&**这样全捕获的形式,因为不可控,你不能确保哪些变量会被捕获,容易发生一些不测的行为。

    4. lambda表达式赋值

    lambda表达式既然生成了一个类对象,那么它是否可以像普通类对象那样,进行赋值呢?

    我们写一段代码试一下:

    #include <iostream>
    using namespace std;
    
    int main()
    {
        auto a = [] { cout << "A" << endl; };
        auto b = [] { cout << "B" << endl; };
    
        //a = b; // 非法,lambda无法赋值
        auto c(a); // 合法,生成一个副本
        auto d=b;  // 合法,生成一个副本
        
        a();
        b();
        c();
        d();
        return 0;
    }
    

    很显然赋值不可以,而拷贝则可以,结合编译器自动生成构造函数规则,很明显,赋值函数被禁用了,而拷贝构造函数则没有被禁用,所以不能用一个lambda表达式给另外一个赋值,但可以进行初始化拷贝。

    2.正则表达式:

    正则表达式(regular expression)描述了一种字符串匹配的模式(pattern),可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
    推荐使用该网站:在线生成所需正则表达式;

    展开全文
  • Lambda表达式使用具备条件

    千次阅读 2019-09-17 10:36:19
    1.有一个接口且只有一个A方法 2.把该接口对象充当B方法参数,灵活使用A方法 3.调用B方法,使用Lambda表达式实现A方法,充当匿名对象

    1.有一个接口且只有一个A方法

    2.把该接口对象充当B方法参数,灵活使用A方法

    3.调用B方法,使用Lambda表达式实现A方法,充当匿名对象

    展开全文
  • Lambda表达式简化过程

    2021-04-26 17:30:01
    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录 前言 ...LambdaLambda可以分为表达式Lambda和语句lamda 示例: Lambda //(parameters) -> expression L..

    目录

    前言

    一、关于Lambda和Lamda区别

    二、Lambda的推导(简化过程)

    1.可以成为Lambda表达式前提条件

    2.复现推导过程

    总结



    前言

    提示:记一次关于学习Lambda表达式简化过程


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、关于Lambda和Lamda区别

    Lambda:Lambda可以分为表达式Lambda和语句lamda

    示例:

    Lambda

    //(parameters) -> expression    Lambda表达式
    (x, y) -> x == y

    Lamda

    //(parameters) -> {method;}      Lamda语句
    (x, y) -> {return x == y;}

    个人理解主要就是写法上的不同。

    二、Lambda的推导(简化过程)

    1.可以成为Lambda表达式前提条件

    函数式接口:有且只有一个抽象方法,可以有其他方法,单抽象方法只能有一个

    示例:

    interface A{
        void study();
    }

    2.复现推导过程

    1. 普通方式实现接口方法的调用
    2. 由普通方式实现接口方法的调用转变为静态内部类的调用
    3. 再静态内部类的调用方式简化为局部内部类的调用
    4. 局部内部类简化为匿名内部类
    5. 最后形成Lambda表达式的简化
    /**
     * @author ly
     * @since 2021-04-26 17:59
     * Lambda 简化过程
     */
    public class DeductionLambda {
        /**
         * 静态内部类
         */
        static class Flower1 implements Lambda{
            @Override
            public void study() {
                System.out.println("2.静态内部类");
            }
        }
    
        public static void main(String[] args) {
            /**
             * 局部内部类
             */
            class Flower2 implements Lambda{
                @Override
                public void study() {
                    System.out.println("3.局部内部类");
                }
            }
    
            //普通方式调用接口方法
            Lambda flower=new Flower();
            flower.study();
            //静态内部类
            flower=new Flower1();
            flower.study();
            //局部内部类
            flower=new Flower2();
            flower.study();
            //匿名内部类:没有类的名称,必须借助接口或者父类
            flower= new Lambda() {
                @Override
                public void study() {
                    System.out.println("4.匿名内部类");
                }
            };
            flower.study();
            //Lambda 表达式
            flower=()->{
                System.out.println("5.lambda表达式");
            };
            flower.study();
        }
    }
    /**
     * 1.定义一个函数式接口
     */
    interface Lambda{
        void study();
    }
    
    /**
     * 2.实现类
     */
    class Flower implements Lambda{
        @Override
        public void study() {
            System.out.println("1.普通方法");
        }
    }
    

    总结

    以上就是本次要记述内容,本文简单介绍了Lambda的简化过程,(学习自【狂神说】)

    展开全文
  • Java8的Lambda表达式

    2020-12-05 02:56:34
    2017年参加工作以后一直都在使用JDK8的lambda风格方式进行Java编程。最直观的感受就是,代码更加简洁,清晰!其次在进行并发编程的时候,真的是太方便了!本次开篇,借鉴了一本我特别喜欢,逢人必推荐的书籍《Java 8...

    2017年参加工作以后一直都在使用JDK8的lambda风格方式进行Java编程。最直观的感受就是,代码更加简洁,清晰!其次在进行并发编程的时候,真的是太方便了!
    本次开篇,借鉴了一本我特别喜欢,逢人必推荐的书籍《Java 8 函数式编程》(原版:《Java 8 Lambdas: Functional Programming For The Masses》)

    本人打算围绕着这一本书,对自己这些年的一些Java8特性做一次完善的总结。写给自己看,再用自己的理解讲给别人听。

    Java老矣,尚能饭否

    随着硬件的发展,CPU从单核时代快进到多核时代,也意味着未来的编程语言的趋势一定是对多线程编程的支持愈发友好!这也是为什么Jdk8推出Lambda表达式的重要原因。Lambda表达式未出现以前,Java程序员在面对大数据集合的并行操作,编码上往往非常麻烦且不够高效,易用性低,可读性也不一定高。而Lambda的出现无疑是在Java语言层面上增加了支持。

    我个人觉得,Java8的推出可以说挽回了很多准备弃坑Java的程序员的心。如果没有Lambda这种更加友好的编程风格的支持,我相信诸如Go,Scala这类的语言会挑战Java的王者地位。(可以去了解一下Go语言中的goroutine关键字对多线程的支持的友好性)

    引用书籍中的一段文字

    当然,这样做是有代价的,程序员必须学习如何编写和阅读使用Lambda表达式的代码。但是这不是一桩赔本的买卖。与手写一大段复杂,线程安全的代码相比,学习一点新语法和一些新习惯容易很多。开发企业级应用时,好的类库和框架极大降低了开发事件和成本,也为开发易用且高效的类库扫清了障碍

    Lambda表达式

    给出如下的实现Runnable的代码示例,直观感受一下lambda表达式的魅力。

    public class DemoMain {

    /**
    * 编写Runnable的实现类
    */
    private static class RunnableImpl implements Runnable{
    @Override
    public void run() {
    System.out.println("Java7-编写Runnable方式");
    }
    }

    public static void main(String[] args) {
    Thread thread0=new Thread(new RunnableImpl());
    Thread thread1=new Thread(new Runnable() {
    @Override
    public void run() {
    System.out.println("Java7-匿名内部类方式");
    }
    });
    Thread thread2=new Thread(()-> System.out.println("Java8的Lambda风格"));

    thread0.start();
    thread1.start();
    thread2.start();
    }
    }

    匿名内部类与匿名函数

    thread0,编写一个Runnable实现类来实现多线程,不难看出这种方式的代码量更多(当然我们也也经常需要这样的一个实现类)
    thread1,通过匿名内部类的方式实现多线程。匿名内部类的本质是一个继承该类或者实现该类接口的子类实例
    thread2,通过lambda表达式实现多线程。

    相信大家对thread0是十分了解的,这里不展开说。关注点在于thread1和thread2的比较。

    从thread1的创建方式中,我们不难看出来,本质上我们是在Thread构造器中传递了一个对象作为参数,只不过这个对象是匿名内部类的实例。而thread2则看起来,更像是传递了一段可执行的代码作为“参数”。这样的一段定义了执行方式的代码,不就是Java中的函数嘛!只不过这个方法有些函数,“匿名函数”。

    函数式编程和Lambda表达式

    在面向对象的Java编程中,我们往往给定的参数是数据,而函数式编程则希望传入的是一个函数,即将函数“参数化”。相信看到这句话,你大致明白了函数式编程是怎么一回事。Lambda表达式是一个匿名函数,将行为像数据一样进行传递。

    函数接口

    在Java中,所有的方法参数都有固定的类型,入thread0的例子,参数类型是RunnableImpl。那么在thread2中,参数的类型是什么?

    ()->System.out.println(“Java8的Lambda风格”)。如果你用的是idea开发工具,你可以按住ctrl鼠标点“()”,跳转到Runnable接口类中,这个Runnable接口就是lambda表达式的类型。我们来看看Runnable的源码。

    如下图所示:

    runnable.jpg

    不难看出有两个点。1:Runnable是一个接口类,2:只有一个抽象方法。我们把这样的一个接口类称为函数接口,lambda表达式的作为方法参数的时候,它的类型一定是函数接口。

    @FunctionalInterface注解

    Runnable接口采用了FunctionalInterface注解进行标注。该注解会强制Javac编译的时候检查当前的接口是否满足函数接口的标准。如果该注释标注给一个不符合条件的接口,枚举类等,编译的时候将会报错。相当于一种类型检查机制,所以当我们自己实现函数接口的时候,一定要规范的加上这个注解!它能够帮助我们提前发现风险。

    Java中重要的函数接口
    接口参数返回类型常用场景
    Predicate Tboolean用于条件判断
    Consumer Tvoid用于对一个给定参数进行处理
    Function<T,R>TR用于将给定参数T处理成R类型返回
    Supplier NoneT工厂方法获取一个T类型对象
    UnaryOperator TT逻辑非
    BinaryOperator (T,T)T对两个同类型对象进行合并操作,比如数值运算

    类型推断

    类型推断,它本质上是javac根据程序的上下文(方法签名,变量类型)推断出数据类型。所以我们在编写Java代码的时候,能够在一些不言而明的前提写,省掉对类型的显式指定。在JDK7的时候,我们可以通过菱形操作符来推断类型

    public class DemoMain {
    public static void main(String[] args) {
    //显式指定类型
    HashMap<String,String> testMap=new HashMap<String,String>();
    //使用菱形操作符,根据变量类型进行推断
    HashMap<String,String> testMap1=new HashMap<>();
    //使用菱形操作符,根据方法签名进行推断。方法签名由方法名称+形参列表构成。重载的方法,方法签名是一样的,但是返回类型不同。
    testMethod(new HashMap<>());
    }

    private static void testMethod(HashMap<String, String> objectObjectHashMap) {
    System.out.println("根据方法签名推断");
    }
    }

    Java8中的类型推断是对Java7类型推断机制的一个扩展。如下示例,Predicate只有一个泛型参数的函数接口,Lambda表达式实现了该接口。
    javac会根据上下文中的参数推断出参数类型是Integer,也就是x是Integer类型的!

    Predicate<Integer> atLeast5 = x -> x > 5;

    @FunctionalInterface
    public interface Predicate<T> {
    boolean test(T t);
    }

    引用值,而非变量

    我把threa1的代码修改成如下:

    final String method="匿名内部类方式";
    Thread thread1=new Thread(new Runnable() {
    @Override
    public void run() {
    System.out.println("Java7-"+method);
    }
    });

    如果是在内部类中,引用了一个外部对象,那么需要把是这个变量声明成final,这也意味着被引用的变量必须是一个不会再改变值。Java8中,已经不需要显式的指定final关键字,但是被引用的变量必须是“既定已成事实”的变量。我对“既定已成事实的变量”的理解就是,一旦定义且初始化,则后续都不会改变的变量。

    lambda引用之前发生改动,无法编译

    引用前发生改动.jpg

    lambda引用时发生改动,无法编译

    引用时发生改动.jpg

    lambda引用之后发生改动,无法编译

    引用后发生改动.jpg

    使用了非“既定已成事实”的变量,则无法编译通过。这也解释了为什么Java中的Lambda表达式被称为闭包。因为闭包的本质是一个定义在函数中的函数。

    Lambda.png
    展开全文
  • Lambda表达式 3.1 函数式编程思想概述 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S4mxZT6r-1614232071649)(C:/Users/ThinkPad/Desktop/md/img/03-Overview.png)] 在数学中,函数就是...
  • Lambda 表达式(使用前提、“类型推断”、作用、优缺点、Lambda还能省略的情况)【java8新特性------Lambda 表达式
  • Java 8 的 Lambda 表达式和流处理

    千次阅读 2019-06-26 11:27:00
    Java 8 的 Lambda 表达式和流处理Lambda 表达式引入 Lambda 表达式的动机函数式接口目标类型名称解析流顺序执行和 并行执行相遇顺序Spliterator有状态和无状态操作流水线源中间操作终结操作总结 原文地址 Lambda ...
  • 我对java中lambda表达式的看法是相当纠结的:一个我这么想:lambda表达式降低了java程序的阅读体验。java程序一直不以表现力出众,正相反使Java流行的一个因素正是它的安全和保守——即使是初学者只要注意些也能写出...
  • Java中的Lambda表达式 1. 函数式编程 强调做什么,而不是以什么形式做。 函数式编程思想和面向对象编程思想的区别: 面向对象:解决某个问题需找到某个类的某个方法完成 函数式:只要能获取到结果,不重视得到结果...
  • 什么是Lambda表达式呢? 有人把它称之为“闭包的替代品”,也有人把它称之为**匿名函数**,它究竟是何方神圣,它在Java中到底充当了什么样的角色?一起关注今晚8点“程序员有话说”,我们不见不散! 哈哈,开个...
  • lambda表达式

    2020-11-10 08:49:15
    一个lambda表达式表示一个可调用的代码单元,可以将其理解为一个未命名的内联函数。与任何函数类似,一个lambda具有一个返回类型、一个参数列表和一个函数体。但与函数不同,lambda可能定义在函数内部。 lambda...
  • 使用lambda表达式对数组进行排序

    千次阅读 2020-08-09 21:13:10
    最近做题,总是看到大佬们使用lambda表达式秀操作,之前一次周赛中,我疯狂排序hhh大佬一行代码5555~ 什么是lambda表达式? Java Lambda表达式的一个重要用法是简化某些匿名内部类(Anonymous Classes)的写法。 ...
  • Lambda表达式的标准格式为: (参数类型 参数名称) ‐> { 代码语句 } 格式说明: ()内的语法与传统方法参数列表一致:无参数则留空;多个参数则用逗号分隔。 -> 是新引入的语法格式,代表指向动作。 ...
  • 屡试不爽的lambda表达式 一、lambda表达式的概述 lambda表达式时java8中新增的内容,也时语法糖,它和stream流,接口中的default等都是Java8的新特性,虽然Java都已经有14版本了,但是Java依旧是开发式的主流,所以...
  • 简单使用lambda表达式

    2021-07-24 00:32:25
    什么是lambda表达式Lambda 是一个 匿名函数,我们可以把 Lambda 表达式理解为是 一段可以传递的代码(将代码像数据一样进行传递)。 使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的...
  • 文章目录一、Lambda表达式1.1 函数式编程思想1.2 体验Lambda表达式(1)匿名内部类方式启动线程(2)Lambda表达式启动线程1.3 格式及使用(1)Lambda表达式格式(2)Lambda的使用前提(3)函数式接口(4)Lambda基本...
  • Java 8 Lambda表达式的理解与使用

    千次阅读 2019-09-16 22:25:15
    Java 8 Lambda表达式的理解与使用Java 8 Lambda表达式的理解与使用新的改变 Java 8 Lambda表达式的理解与使用 新的改变 在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿什么东西做什么事情”。相对而...
  • public class DemoLambda { public static void main(String[] args) { //用实现Runnable接口来创建多线程要重新创一个实现类的话有点麻烦 //于是我们用匿名内部类 new Thread(new Runnable() { @Override ...
  • Lambda表达式

    2021-03-02 14:40:30
    Lambda的使用前提 Lambda的语法非常简洁,完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意: 1.使用Lambda必须具有接口,且要求接口中有且仅有一个抽象方法。 无论是JDK内置的Runnable、Comparator...
  • 1、概述在这篇教程里,我们将要去了解下即将到来的JDK 8(译注,现在JDK 8已经发布了)中的Lambda表达式——特别是怎样使用它来编写Comparator和对集合(Collection)进行排序。首先,让我们先定义一个简单的实体类:...
  • Java Lambda 表达式

    2020-12-05 08:32:07
    Lambda匿名内部类的格式:new 父类或接口() {​重写的方法;​}在匿名内部类中,有很多内容都是冗余的。比如在使用匿名内部类实现多线程的代码中。因为 Thread 构造方法中需要传递 Runnable 接口类型的参数,所以我们...
  • Lambda表达式是JDK1.8引入的特性,它是一个优雅的语法,使得代码更加简洁明了。 引言 设此时存在一个接口Interface01,如果想要调用其中的show()方法,我们需要怎么做? 方法一:使用实现类 我们创建一个对应的...
  • Lambda的使用前提 Lambda的语法非常简洁,完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意: 使用Lambda必须具 有接口 ,且要求 接口中有且仅有一个抽象方法 。 无论是JDK内置的 Runnable 、 ...
  • 使用Lambda标准格式(无参无返回)题目解答8 Lambda的参数和返回值传统写法代码分析Lambda写法9 练习:使用Lambda标准格式(有参有返回)题目解答10 Lambda省略格式可推导即可省略省略规则11 练习:使用Lambda省略...
  • 1、前提条件:实现接口的入参、返回值类型与接口的抽象方法一致 创建内部接口 LambdaInterface51 添加加法interfaceSum抽象方法 LambdaInterface52添加减法interfaceSub抽象方法、 可以添加@Functional...
  • C++11中Lambda表达式之捕获

    万次阅读 2018-12-06 21:42:20
    捕获是指一个lambda表达式将局部变量包含在捕获列表,在捕获列表中的参数则可以被lambda函数体使用。举一个最简单的例子: std::string str(&amp;amp;amp;amp;amp;amp;amp;amp;quot;this is captured value&...
  • 匿名内部类、lambda和方法引用其实是相通的,从匿名内部类到lambda到方法引用是一个进化的过程,是一个简化的过程,更加是一个从抽象的过程。 作用都是实现接口方法,换句话说就是实现接口;只是这个接口只有一个...
  • Lambda前提条件 Lambda的语法非常简洁,完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意: 使用Lambda必须具有接口,且要求接口中有且仅有一个抽象方法。 无论是JDK内置的Runnable、Comparator...
  • 关于Java Lambda表达式看这一篇就够了

    千次阅读 2019-10-28 14:11:14
    JavaLambda表达式的一个重要用法是简化某些匿名内部类(Anonymous Classes)的写法。实际上Lambda表达式并不仅仅是匿名内部类的语法糖,JVM内部是通过invokedynamic指令来实现Lambda表达式的。具体原理放到下一篇。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,307
精华内容 3,322
关键字:

lambda的前提条件表达式