Java的Lambda表达式

最新推荐文章于 2023-02-23 13:00:00 发布
最新推荐文章于 2023-02-23 13:00:00 发布
阅读量331 收藏 1
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46049759/article/details/121870466
版权

语雀链接:Lambda表达式

文章目录

1.体验Lambda表达式

1.1函数式编程思想概述

image-20210825143319335

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

面向对象思想强调“必须通过对象的形式来做事情”

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

1.2体验Lambda表达式

需求：启动一个线程，在控制台输出一句话：多线程程序启动了

方式1：

  • 定义一个类MyRunnable实现Runnable接口，重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
  • 启动线程
MyRunable my = new MyRunable();
Thread t = new Thread(my);
t.start();

=====MyRunable.java
@Override
public void run() {
	   System.out.println("多线程程序启动了...");
}
=====

方式2：

  • 匿名内部类的方式改进
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("多线程程序启动了_匿名内部类");
    }
}).start();

方式3：

  • Lambda表达式的方式改进
new Thread(() -> {
    System.out.println("多线程程序启动了_匿名内部类");
}).start();

2.Lambda表达式的标准格式

2.1匿名内部类中重写run()方法的代码分析

  • 方法形式参数为空，说明调用方法时不需要传递参数
  • 方法返回值类型为void，说明方法执行没有结果返回
  • 方法体中的内容，是我们具体要做的事情
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}).start();

2.2Lambda表达式的代码分析

  • ()：里面没有内容，可以看成是方法形式参数为空
  • ->：用箭头指向后面要做的事情
  • {}：包含一段代码，我们称之为代码块，可以看成是方法体中的内容
new Thread(() -> {
    System.out.println("多线程程序启动了_匿名内部类");
}).start();

2.3Lambda表达式的格式

格式(形式参数) -> {代码块}
形式参数如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可
->由英文中划线和大于符号组成.代表指向动作
代码块是我们具体要做的事情,也就是以前我们写的方法体内容

3.Lambda表达式的练习(抽象方法无参无返回值)

Lambda表达式的使用前提

  • 有一个接口
  • 接口中有且仅有一个抽象方法

练习1：

  • 定义一个接口（Eatable），里面定义一个抽象方法：void eat()；
  • 定义一个测试类（EatableDemo），在测试类中提供两个方法
    • 一个方法是：useEatable(Eatable e)
    • 一个方法是主方法，在主方法中调用useEatable方法
package com.study_02;

public interface Eatable {
    void eat();
}

package com.study_02;

public class EatableImpl implements Eatable{

    @Override
    public void eat() {
        System.out.println("一天一个小苹果");
    }
}

package com.study_02;

public class EatableDemo {
    public static void main(String[] args) {
        // 在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        // 匿名内部来
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一个大苹果");
            }
        });

        // Lambda表达式
        useEatable( () -> {
            System.out.println("一天一个毒苹果");
        });

    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

4.Lambda表达式的练习(抽象方法带参无返回值)

练习2:

  • 定义一个接口（Flyable），里面定义一个抽象方法：void fly(String s);
  • 定义一个测试类（FlyableDemo），在测试类中提供两个方法
    • 一个方法是：useFlyable(Flyable f)
    • 一个方法是主方法，在主去中调用useFlyable方法
package com.study_03;

public interface Flyable {
    void fly(String s);
}

package com.study_03;

public class FlyableDemo {
    public static void main(String[] args) {
        // 在主方法中调用userFlyable方法
        // 匿名内部类
        userFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("内部人员");
            }
        });
        System.out.println("------");

        // Lambda
        userFlyable((String s) -> {
            System.out.println(s);
            System.out.println("Lambda");
        });

    }

    private static void userFlyable(Flyable f) {
        f.fly("风和日丽");
    }
}

5.Lambda表达式的练习(抽象方法带参带返回值)

练习3：

  • 定义一个接口（Addable），里面定义一个抽象方法：intadd(intxinty);
  • 定义一个测试类（AddableDemo），在测试类中提供两个方法
    • 一个方法是：useAddable(Addablea)
    • 一个方法是主方法，在主方法中调用useAddable方法
package com.study_04;

public interface Addable {
    int add(int x,int y);
}

package com.study_04;

public class AddableDemo {
    public static void main(String[] args) {
        // 在主方法中调用useAddable方法
        useAddable((int x, int y) -> {
            return x + y;
//            return x-y;
        });

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

6.Lambda表达式的省略模式

省略规则：

  • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
  • 如果参数有且仅有一个，那么小括号可以省略
  • 如果代码块的语句只有一条，可以省略大括号和分号，甚至是retum
package com.study_05;

public interface Addable {
    int add(int x,int y);
}

package com.study_05;

public interface Flyable {
    void fly(String s);
}

package com.study_05;

import com.study_03.Flyable;
import com.study_04.Addable;

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x+y;
//        });
        // 参数的类型可以省略,不能只省略一个
        useAddable((x,y) -> {
            return x + y;
        });

//        userFlyable((String s) -> {
//            System.out.println(s);
//        });
        
//        userFlyable((s) -> {
//            System.out.println(s);
//        });
        
        // 如果参数有且仅有一个,那么小括号可以省略
//        userFlyable(s -> {
//            System.out.println(s);
//        });

        // 如果代码块的语句只有一条,可以省略大括号和分号
        userFlyable(s -> System.out.println(s));

        // 如果有return,return也可省略掉
        useAddable((x,y) -> x + y);

    }

    private static void userFlyable(Flyable f) {
        f.fly("风和日丽");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

7.Lambda表达式的注意事项

注意事项：

  • 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
  • 必须有上下文环境，才能推导出Lambda对应的接口
    • 根据局部变量的赋值得知Lambda对应的接口：Runnabler=()->System.out.printin("Lambda表达式”);
    • 根据调用方法的参数得知Lambda对应的接口：new Thread(()->System.out.println("Lambda表达式")).start();
package com.study_06;

public interface Inter {
    void show();

//    void meth();
}

package com.study_06;

public class LambdaDemo {
    public static void main(String[] args) {
//        useInter(() -> {
//            System.out.println("好好学习天天向上");
//        });

        // 使用Lambda必修要有接口,并且要求接口中有且仅有一个抽像方法
        useInter(() -> System.out.println("好好学习天天向上"));

        // 必须有上下文逻辑,才能推导出Lambda对应的接口
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("匿名内部类");
//            }
//        }).start();

//        Runnable r = () -> System.out.println("Lambda表达式");
//        new Thread(r).start();

        new Thread(() -> System.out.println("Lambda表达式")).start();
    }

    private static void useInter(Inter i) {
        i.show();
    }
}

8.Lambda表达式和匿名内部类的区别

所需类型不同

  • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
  • Lambda表达式：只能是接口

使用限制不同

  • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
  • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

  • 匿名内部类：编译之后，产生一个单独的.class字节码文件
  • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

9.接口组成更新概述

接口的组成

  • 常量
    • public static final
  • 抽象方法
    • public abstract
  • 默认方法（Java 8）
  • 静态方法（Java 8）
  • 私有方法（Java 9）

10.接口中默认方法

接口中默认方法的定义格式:

  • 格式：public default 返回值类型方法名（参数列表）{ }
  • 范例：public default void show3() { }

接口中默认方法的注意事项：

  • 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
  • public可以省略，default不能省略
package com.study_01;

public interface MyInterface {
    void show1();

    void show2();

//        void show3();
    
//    public default void show3() {
//        System.out.println("show3");
//    }

     default void show3() {
        System.out.println("show3");
    }

}

package com.study_01;

public class MyInterfaceImplOne implements MyInterface{
    @Override
    public void show1() {
        System.out.println("one show1");
    }

    @Override
    public void show2() {
        System.out.println("one show2");
    }

    @Override
    public void show3() {
        System.out.println("one show3");
    }
}

package com.study_01;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        // 按照多态的方式创建对象并使用
        MyInterface my = new MyInterfaceImplOne();
        my.show1();
        my.show2();
        my.show3();
    }
}

11.接口中静态方法

接口中静态方法的定义格式：

  • 格式：public static 返回值类型方法名（参数列表）{ }
  • 范例：public static void show() { }

接口中静态方法的注意事项：

  • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
  • public可以省略，static不能省略
package com.study_02;

public interface Inter {
    void show();

    default void method() {
        System.out.println("Inter中默认方法");
    }

//    public static void test() {
//        System.out.println("Inter中静态方法");
//    }

    static void test() {
        System.out.println("Inter中静态方法");
    }
}

package com.study_02;

public interface Flyable {
    public static void test() {
        System.out.println("Flyable");
    }
}

package com.study_02;

public class InterImlpl implements Inter,Flyable{
    @Override
    public void show() {
        System.out.println("show执行了");
    }
}

package com.study_02;

public class InterDemo {
    public static void main(String[] args) {
        Inter i = new InterImlpl();
        i.show();
        i.method();
//        i.test();

        Inter.test();

        Flyable.test();
    }
}

12.接口中私有方法

Java 9中新增了带方法体的私有方法，这其实在Java8中就埋下了伏笔：Java8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java9增加私有方法的必然性

接口中私有方法的定义格式：

  • 格式1：private返回值类型方法名（参数列表）{}
  • 范例1：private void show(){}
  • 格式2：private static返回值类型方法名（参数列表）{}
  • 范例2：private static void method(){}

接口中私有方法的注意事项：

  • 默认方法可以调用私有的静态方法和非静态方法
  • 静态方法只能调用私有的静态方法
package com.study_03;

public interface Inter {
    default void show1() {
        System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        show();
        System.out.println("show1结束执行");
    }

    default void show2() {
        System.out.println("show2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
//        show();
        method();
        System.out.println("show2结束执行");
    }
    private void show() {
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }

    static void method1() {
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method1结束执行");
    }

    static void method2() {
        System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method2结束执行");
    }

    private static void method() {
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }

}

package com.study_03;

public class InterImpl implements Inter{
}

package com.study_03;

public class InterDemo {
    public static void main(String[] args) {
        // 按照多态的方法创建对象并使用
        Inter i = new InterImpl();
        i.show1();
        System.out.println("-----");
        i.show2();

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

        Inter.method1();
        System.out.println("-----");
        Inter.method2();
    }
}

13.体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？

答案肯定是没有必要

那我们又是如何使用已经存在的方案的呢？

这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

package com.study_01;

public interface Printable {
    void printString(String s);
}

package com.study_01;

public class PrintableDemo {
    public static void main(String[] args) {
        // 在主方法中调用usePrintable方法

//        usePrintable((String s) -> {
//            System.out.println(s);
//        });

        usePrintable(s -> System.out.println(s));

//        System.out.println("爱生活很好");

        //方法引用符 ::
        usePrintable(System.out::println);

        // 可推导的就是课省略的

    }

    private static void usePrintable(Printable p) {
        p.printString("爱生活很好");
    }
}

14.方法引用符

package com.study_02;

public interface Printable {
    void printInt(int i);
}

package com.study_02;

public class PrintableDemo {
    public static void main(String[] args) {
        // 在主方法中调用usePrintable方法
//        usePrintable(i -> System.out.println(i));

        // 方法引用
        usePrintable(System.out::println);
    }

    private static void usePrintable(Printable p) {
        p.printInt(666);
    }
}

15.Lambda表达式支持的方法引用

常见的引用方式:

  • 引用类方法
  • 引用对象的实例方法
  • 引用类的实例方法
  • 引用构造器

引用类方法

引用类方法，其实就是引用类的静态方法

  • 格式：类名 : 静态方法
  • 范例：Integer:parselnt
    • Integer类的方法：public static int parselnt(String s);将此String转换为int类型数据

练习：

  • 定义一个接口（Converter）,里面定义一个抽象方法i
    • int convert(Strings);
  • 定义一个测试类（ConverterDemo），在测试类中提供两个方法
    • 一个方法是：useConverter(Converter c);
    • 一个方法是主方法，在主方法中调用useConverter方法
package com.study_03;

public interface Converter {
    int convert(String s);
}

package com.study_03;

public class ConverterDemo {
    public static void main(String[] args) {
        // 在主方法中调用useConverter方法
        // 重写 Converter接口 中的 convert方法 是有返回值的
//        useConverter((String s) -> {
//            return Integer.parseInt(s);
//        });

        useConverter(s -> Integer.parseInt(s));

        // 引用类方法
        useConverter(Integer::parseInt);

        // Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数


    }

    private static void useConverter(Converter c) {
        int number = c.convert("666"); // 将convert方法返回值赋给 number
        System.out.println(number);
    }
}

16.引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

  • 格式：对象::成员方法
  • 范例："HelloWorld"::toUpperCase
    • String类中的方法：public String toUpperCase()将此String所有字符转换为大写

练习

  • 定义一个类（PrintString），里面定义一个方法
    • public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
  • 定义一个接口（Printer），星面定义一个抽象方法
    • void printUpperCase(Strings);
  • 定义一个测试类（PrinterDemo），在测试类中提供两个方法
    • 一个方法是：usePrinter(Printerp);
    • 一个方法是主方法，在主方法中调用usePrinter方法
package com.study_04;

public interface Printer {
    void printUpperCase(String s);
}

package com.study_04;

public class PrintString {
    // 把字符串参数变成大写的数据,然后在控制台输出
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

package com.study_04;

public class PrinterDemo {
    public static void main(String[] args) {
        // 在主方法中调用usePrinter方法
//        usePrinter((String s) -> {
            String resuult = s.toUpperCase();
            System.out.println(resuult);
//            System.out.println(s.toUpperCase());
//        });

        usePrinter(s -> System.out.println(s.toUpperCase()));

        // 引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);

        //Lambda表达被对象实例方法替代的时候,它的形式参数全部传递给该方法作为参数
    }


    private static void usePrinter(Printer p) {
        p.printUpperCase("HelloWorld");
    }
}

17.引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

  • 格式：类名::成员方法

  • 范例：String::substring

    • String类中的方法：public String substring(int beginlndex，int endlndex);
    • 从beginlndex开始到endlndex结束，截取字符串。返回一个子串，子串的长度为endlndex - beginlndex

练习

  • 定义一个接口（MyString），里面定义一个抽象方法：

    • String mySubString(String s，int xinty);

  • 定义一个测试类（MyStringDemo），在测试类中提供两个方法

    • 一个方法是：uselMyString(MyString my);
    • 一个方法是主方法，在主方法中调用useMyString方法
package com.study_05;

public interface MyString {
    String mySubString(String s, int x, int y);
}

package com.study_05;

public class MyStringDemo {
    public static void main(String[] args) {
        // 在主方法中调用useMyString方法

//        useMyString((String s,int x ,int y) -> {
//            return s.substring(x,y);
//        });

        useMyString((s,x,y) -> s.substring(x,y));

        // 引用类的实例方法
        useMyString(String::substring);

        // Lambda表达式被类的实例方法替代的时候
        // 第一个参数作为调用者
        // 后面的参数全部传递给该方法作为参数
    }
    private static void useMyString(MyString my) {
        String s = my.mySubString("HelloWorld",2,5);
        System.out.println(s);
    }
}

18.引用构造器

引用构造器,其实就是引用方法

  • 格式:类名::new
  • 范例:Student::new

练习

  • 定义一个类（Student），里面有两个成员变量（name，age）
    • 并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
  • 定义一个接口（StudentBuilder），里面定义一个抽象方法
    • Student build(String name，int age);
  • 定义一个测试类（StudentDemo），在测试类中提供两个方法
    • 一个方法是：useStudentBuilder(StudentBuilders);
    • 一个方法是主方法，在主方法中调用useStudentBuilder方法
package com.study_06;

public interface StudentBuilder {
    Student build(String name,int age);
}

package com.study_06;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.study_06;

public class StudentDemo {
    public static void main(String[] args) {
//        useStudentBuilder((String name,int age) -> {
            Student s = new Student(name,age);
            return s;
//            return new Student(name,age);
//        });

        useStudentBuilder((name,age) -> new Student(name,age));

        // 引用构造器
        useStudentBuilder(Student::new);

        //Lambda表达式被构造器替代的时候,他是形式参数全部传递给构造器作为参数
    }


    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("林青霞",30);
        System.out.println(s.getName()+","+s.getAge());
    }
}
嘻嘻你好呀
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 4大函数和 Lambda 表达式
u011731053的专栏
07-08 609
java8 lambda表达式
java lambda表达式用法总结
08-25
Java Lambda 表达式用法总结 Java Lambda 表达式是 Java 8 中引入的一种新的编程方式，它允许开发者使用简洁的语法来表示单方法接口的实现。下面是 Java Lambda 表达式的详细用法总结： 一、什么是函数式编程？ ...
java8 lambda表达式详解(一)
kopshome的专栏
12-18 1650
java8除了引入一些时间,Streamming等等新写法或者API,最令人兴奋的应该是lambda表达式了,这个应该是java里程碑式的一件事,就像java5引入泛型一样! lambda表达式,关键的一个操作符就是'->',左侧指定表达式所需要的所有参数,如果不需要参数,则使用空的参数列表,右侧指定了lambda体,即所需要执行的动作,可以简单吧'->'理解为"成了","进去...",java
java8新特性lambda表达式概述
DSAUBDUA的博客
07-13 166
java8新特性lambda表达式概述
关于Java中lambda表达式的序列化
qq_19266669的博客
03-04 881
我在使用mybatis-plus的时候发现有这样一种写法: LambdaQueryWrapper<Board> wrapper = new LambdaQueryWrapper<>(); // lambda方法引用 queryWrapper.eq(User::getName, "小明"); 那么问题来了? 他是怎么通过 User::getName 来获取到字符串name的呢? 通过查阅资料发现, 他是通过类似下面的代码实现的: @Data public class Person {
【java】Maybatis-Plus 数据库查询 lambdaQuery和mapper中EQ、NE、GT、LT、GE、LE、select、like、in、leftjoin的用法及详解
想去码头整点儿薯条儿~
02-23 2万+
【java】Maybatis-Plus 数据库查询 lambdaQuery和mapper中EQ、NE、GT、LT、GE、LE、select、like、in、leftjoin的用法及详解
详细分析Java Lambda表达式
08-18
"详细分析Java Lambda表达式" Java Lambda表达式是Java 8中引入的一种新的编程方式，它允许开发者将函数作为参数传递给其他函数，或者将函数作为返回值返回。Lambda表达式的引入使得Java语言更加函数化，更加简洁。...
Java Lambda表达式详解和实例
09-04
Java Lambda表达式是Java SE 8引入的一项重要特性，它简化了函数式编程，使得代码更加简洁、易读。Lambda表达式本质上是无名函数，可以用作参数传递，或者作为方法体。它允许开发者用更直观的方式来表达那些只需要一...
Java Lambda表达式入门示例
08-25
Java Lambda表达式入门示例 Java Lambda表达式是Java 8中引入的一种新特性，它允许开发者使用更简洁的代码来创建只有一个抽象方法的接口（函数式接口）的实例。Lambda表达式主要作用就是代替匿名内部类的繁琐语法。...
JAVA lambda表达式
09-19
Java Lambda表达式是Java编程语言的一个重要特性，自Java 8开始引入，它极大地简化了函数式编程，尤其是在处理集合和并发操作时。Lambda表达式的主要目标是使代码更加简洁、易读，同时提高程序的可维护性。下面将...
Lambda表达式，示例，快速认识
yunjin0101的博客
05-03 190
文章目录前言一、Lambda表达式是什么？二、示例1.无参数无返回值2.有参数的有返回值的Lambda可省略部分（Lambda的优化）其注意事项 前言 使用工具：IDEA2020版 提示：以下是本篇文章正文内容，下面案例可供参考 一、Lambda表达式是什么？ 1.JAVA面向对象的思想： 做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。 2.函数式编程思想： 只要能获得到结果，谁去做的，怎么做的都不重要，重试的是结果，不重视过程。 Lambda表达式就是函数式编程思想，其作用是为了减省
JDK8新特性——Lambda
lunatic__的博客
05-30 98
JDK8新特性——Lambda 函数式编程：形式参数，箭头，代码块 （s1，s2） -> { s1 += s2; return s1-s2; } 使用前提： 有一个接口，接口中有且仅有一个抽象方法 必须要有上下文对象才能推导出Lambda对应的接口 根据局部变量的赋值的值Lambda对应的接口：Runnable r = （） -> sout(“zzz”) 根据调用方法的参数的值Lambda对应的接口: new Thread(() - > sout(“xxx”))
Java lambda 动态查询
bosaidongmomo的博客
08-04 1392
我在 微软 REST API指南 中 了解到, 微软设计数据查询是按照如下方式来获取数据的。示例：返回所有价格低于 $10.00 的产品示例：名称等于“牛奶”的所有产品示例：名称不等于“牛奶”的所有产品我在MSDN了解到对于这些实体类型中的任何一个，你都需要筛选并仅返回那些在其某个 string 字段内具有给定文本的实体。尽管可以为 IQueryable 编写一个自定义函数，并为 IQueryable 编写另一个自定义函数。......
java8的lambda用法总结(持续更新)
qq_40430380的博客
03-24 1659
从去年开始就经常性用到lambda表达式的代码,部分经常用,部分不太用的总忘记,干脆总结下用法 1.从集合中抽取某一元素的集合 List<String> idList = ProductService.list(new Product().setCreateUserId(nodeUser.getUserId())) .stream().map(t -> t.getProductId()).collect(Collectors.toList()); 2.集合去重 List<Pro
lambdaQuery中EQ、NE、GT、LT、GE、LE的用法
am的博客
05-13 3万+
Maybatis-Plus lambdaQuery中EQ、NE、GT、LT、GE、LE的用法及详解 1.等于当前时间 //EQ 就是 EQUAL等于 taskFlowService.lambdaQuery().eq(TaskFlow::getCreateTime,DateUtil.now()) 2.不等于当前时间 //NE就是 NOT EQUAL不等于 taskFlowService.lambdaQuery().ne(TaskFlow::getCreateTime,DateUtil.now()); 3.
java Lambda表达式详解
m0_57180439的博客
02-28 8621
文章目录一、背景1.1语法二、使用步骤1.引入库2.读入数据总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、背景 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure） 。 换.
Java命令里面的EQ、NE、GT、LT、GE、LE分别代表含义
热门推荐
无名
01-12 14万+
不废话，直接上车:EQ 就是 EQUAL等于 NE就是 NOT EQUAL不等于 GT 就是 GREATER THAN大于　 LT 就是 LESS THAN小于 GE 就是 GREATER THAN OR EQUAL 大于等于 LE 就是 LESS THAN OR EQUAL 小于等于关注博客关注更多文章
java8新特性-lambda表达式入门学习
GalenGao
05-13 5480
定义 jdk8发布新特性中，lambda是一大亮点之一。lambda表达式能够简化我们对数据的操作，减少代码量，大大提升我们的开发效率。Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包。如果...
java lambda表达式
最新发布
04-29
Java lambda表达式是Java 8发布的一种新的语法特性。它可以用来简化代码，从而提高代码的可读性和开发效率。Lambda表达式是一种匿名函数，它可以接受任意数量的参数，但只能有一个表达式作为执行体。Lambda表达式的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值