Java基础(二十五)：Lambda表达式、方法引用、构造器引用

已于 2024-04-03 14:35:29 修改
阅读量884 收藏 21
点赞数 18
分类专栏： Java基础 文章标签： java python 开发语言
于 2024-02-19 16:30:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35512802/article/details/136141747
版权

Java基础系列文章

Java基础(一)：语言概述Java基础(二)：原码、反码、补码及进制之间的运算Java基础(三)：数据类型与进制Java基础(四)：逻辑运算符和位运算符
Java基础(五)：流程控制语句Java基础(六)：数组Java基础(七)：面向对象编程Java基础(八)：封装、继承、多态性
Java基础(九)：Object 类的使用Java基础(十)：关键字static、代码块、关键字finalJava基础(十一)：抽象类、接口、内部类Java基础(十二)：枚举类
Java基础(十三)：注解(Annotation)Java基础(十四)：包装类Java基础(十五)：异常处理Java基础(十六)：String的常用API
Java基础(十七)：日期时间APIJava基础(十八)：java比较器、系统相关类、数学相关类Java基础(十九)：集合框架Java基础(二十)：泛型
Java基础(二十一)：集合源码Java基础(二十二)：File类与IO流Java基础(二十三)：反射机制Java基础(二十四)：网络编程
Java基础(二十五)：Lambda表达式、方法引用、构造器引用Java基础(二十六)：Java8 Stream流及Optional类

目录

一、Lambda表达式

1、语法

  • Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符
  • 这个操作符为 “->” ， 该操作符被称为Lambda操作符或箭头操作符
  • 它将 Lambda 分为两个部分：
    • 左侧：指定了 Lambda 表达式需要的参数列表
    • 右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能

语法格式一：无参，无返回值

  • run方法名省略，保留无参()和具体实现类{内容}
@Test
public void test1(){
    //未使用Lambda表达式
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("我爱北京天安门");
        }
    };

    r1.run();

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

    //使用Lambda表达式
    Runnable r2 = () -> {
        System.out.println("我爱北京故宫");
    };

    r2.run();
}

语法格式二：一个参数，但是没有返回值

  • 只保留参数(类型 变量)和具体实现类{内容}
@Test
public void test2(){
    //未使用Lambda表达式
    Consumer<String> con = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    con.accept("谎言和誓言的区别是什么？");

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

    //使用Lambda表达式
    Consumer<String> con1 = (String s) -> {
        System.out.println(s);
    };
    con1.accept("一个是听得人当真了，一个是说的人当真了");
}

语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

@Test
public void test3(){
    //语法格式三使用前
    Consumer<String> con1 = (String s) -> {
        System.out.println(s);
    };
    con1.accept("一个是听得人当真了，一个是说的人当真了");

    System.out.println("*******************");
    //语法格式三使用后
    Consumer<String> con2 = (s) -> {
        System.out.println(s);
    };
    con2.accept("一个是听得人当真了，一个是说的人当真了");
}

语法格式四：若只需要一个参数时，参数的小括号可以省略

@Test
public void test4(){
    //语法格式四使用前
    Consumer<String> con1 = (s) -> {
        System.out.println(s);
    };
    con1.accept("一个是听得人当真了，一个是说的人当真了");

    System.out.println("*******************");
    //语法格式四使用后
    Consumer<String> con2 = s -> {
        System.out.println(s);
    };
    con2.accept("一个是听得人当真了，一个是说的人当真了");
}

语法格式五：当Lambda体只有一条语句时，return与大括号若有，都可以省略

@Test
public void test5(){
    //语法格式五使用前
    Comparator<Integer> com1 = (o1,o2) -> {
        return o1.compareTo(o2);
    };

    System.out.println(com1.compare(12,6));

    System.out.println("*****************************");
    //语法格式五使用后
    Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);

    System.out.println(com2.compare(12,21));
}

语法格式六：需要两个或以上的参数，多条执行语句，并且可以有返回值

@Test
public void test6(){
    //语法格式六使用前
    Comparator<Integer> com1 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };

    System.out.println(com1.compare(12,21));
    System.out.println("*****************************");
    //语法格式六使用后
    Comparator<Integer> com2 = (o1,o2) -> {
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(com2.compare(12,6));
}

Lambda表达式的语法规则总结

  • -> 的左边：lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略
  • -> 的右边：lambda体，对应着重写的方法的方法体。如果方法体中只有一行执行语句，则一对{}可以省略。如果有return关键字，则必须一并省略

2、函数式(Functional)接口

  • 只包含一个抽象方法的接口，称为函数式接口。当然该接口可以包含其他非抽象方法
  • 可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口
  • 在java.util.function包下定义了Java 8 的丰富的函数式接口

2.1、四大核心函数式接口

函数式接口称谓参数类型用途
Consumer<T> 消费型接口T对类型为T的对象应用操作
包含方法： void accept(T t)
Supplier<T> 供给型接口无返回类型为T的对象
包含方法：T get()
Function<T, R> 函数型接口T对类型为T的对象应用操作，并返回结果。结果是R类型的对象
包含方法：R apply(T t)
Predicate<T> 判断型接口T确定类型为T的对象是否满足某约束，并返回boolean值
包含方法：boolean test(T t)

消费型接口

在这里插入图片描述

@Test
public void test1() {
    List<String> list = Arrays.asList("hello", "java", "lambda");
    list.forEach(s -> System.out.println(s));
}

供给型接口

在这里插入图片描述

@Test
public void test2() {
    // 返回一个无限连续的无序流，其中每个元素都由提供的 Supplier 生成
    // 这适用于生成恒定流、随机元素流等
    Stream.generate(() -> Math.random()).forEach(System.out::println);
}

功能型接口

在这里插入图片描述

@Test
public void test3() {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "100");
    map.put(2, "200");
    map.put(3, "300");
    map.put(4, "400");
    map.put(5, "500");
    // 如果k为偶数，则返回v + "00"，否则返回v
    map.replaceAll((k, v) -> {
        if (k % 2 == 0){
            return v + "00";
        }
        return v;
    });
    map.forEach((k, v) -> System.out.println(k + "=" + v));
}

功能型接口

在这里插入图片描述

@Test
public void test4() {
    ArrayList<String> list = new ArrayList<>();
    list.add("hello");
    list.add("java8");
    list.add("ok");
    list.add("yes");
    // 移除所有长度小于5的元素
    list.removeIf(str -> str.length() < 5);
    list.forEach(str -> System.out.println(str)); // hello java8
}

2.2、消费型接口

  • 消费型接口的抽象方法特点：有形参，但是返回值类型是void
接口名抽象方法描述
BiConsumer<T,U>void accept(T t, U u)接收两个对象用于完成功能
DoubleConsumervoid accept(double value)接收一个double值
IntConsumervoid accept(int value)接收一个int值
LongConsumervoid accept(long value)接收一个long值
ObjDoubleConsumervoid accept(T t, double value)接收一个对象和一个double值
ObjIntConsumervoid accept(T t, int value)接收一个对象和一个int值
ObjLongConsumervoid accept(T t, long value)接收一个对象和一个long值

2.3、供给型接口

  • 供给型接口的抽象方法特点：无参，但是有返回值
接口名抽象方法描述
BooleanSupplierboolean getAsBoolean()返回一个boolean值
DoubleSupplierdouble getAsDouble()返回一个double值
IntSupplierint getAsInt()返回一个int值
LongSupplierlong getAsLong()返回一个long值

2.4、函数型接口

  • 函数型接口的抽象方法特点：既有参数又有返回值
接口名抽象方法描述
UnaryOperatorT apply(T t)接收一个T类型对象，返回一个T类型对象结果
DoubleFunctionR apply(double value)接收一个double值，返回一个R类型对象
IntFunctionR apply(int value)接收一个int值，返回一个R类型对象
LongFunctionR apply(long value)接收一个long值，返回一个R类型对象
ToDoubleFunctiondouble applyAsDouble(T value)接收一个T类型对象，返回一个double
ToIntFunctionint applyAsInt(T value)接收一个T类型对象，返回一个int
ToLongFunctionlong applyAsLong(T value)接收一个T类型对象，返回一个long
DoubleToIntFunctionint applyAsInt(double value)接收一个double值，返回一个int结果
DoubleToLongFunctionlong applyAsLong(double value)接收一个double值，返回一个long结果
IntToDoubleFunctiondouble applyAsDouble(int value)接收一个int值，返回一个double结果
IntToLongFunctionlong applyAsLong(int value)接收一个int值，返回一个long结果
LongToDoubleFunctiondouble applyAsDouble(long value)接收一个long值，返回一个double结果
LongToIntFunctionint applyAsInt(long value)接收一个long值，返回一个int结果
DoubleUnaryOperatordouble applyAsDouble(double operand)接收一个double值，返回一个double
IntUnaryOperatorint applyAsInt(int operand)接收一个int值，返回一个int结果
LongUnaryOperatorlong applyAsLong(long operand)接收一个long值，返回一个long结果
BiFunction<T,U,R>R apply(T t, U u)接收一个T类型和一个U类型对象，返回一个R类型对象结果
BinaryOperatorT apply(T t, T u)接收两个T类型对象，返回一个T类型对象结果
ToDoubleBiFunction<T,U>double applyAsDouble(T t, U u)接收一个T类型和一个U类型对象，返回一个double
ToIntBiFunction<T,U>int applyAsInt(T t, U u)接收一个T类型和一个U类型对象，返回一个int
ToLongBiFunction<T,U>long applyAsLong(T t, U u)接收一个T类型和一个U类型对象，返回一个long
DoubleBinaryOperatordouble applyAsDouble(double left, double right)接收两个double值，返回一个double结果
IntBinaryOperatorint applyAsInt(int left, int right)接收两个int值，返回一个int结果
LongBinaryOperatorlong applyAsLong(long left, long right)接收两个long值，返回一个long结果

2.5、判断型接口

  • 判断型接口的抽象方法特点：有参，但是返回值类型是boolean结果
接口名抽象方法描述
BiPredicate<T,U>boolean test(T t, U u)接收两个对象
DoublePredicateboolean test(double value)接收一个double值
IntPredicateboolean test(int value)接收一个int值
LongPredicateboolean test(long value)接收一个long值

二、方法引用

  • 方法引用，可以看做是基于lambda表达式的进一步简化

1、方法引用格式

  • 情况1：对象 :: 实例方法名
    • 函数式接口中的抽象方法a在被重写时使用了某一个对象的方法b
    • 如果方法a的形参列表、返回值类型与方法b的形参列表、返回值类型都相同
    • 则我们可以使用方法b实现对方法a的重写、替换
  • 情况2：类 :: 静态方法名
    • 函数式接口中的抽象方法a在被重写时使用了某一个类的静态方法b
    • 如果方法a的形参列表、返回值类型与方法b的形参列表、返回值类型都相同
    • 则我们可以使用方法b实现对方法a的重写、替换
  • 情况3：类 :: 实例方法名
    • 函数式接口中的抽象方法a在被重写时使用了某一个对象的方法b
    • 如果方法a的返回值类型与方法b的返回值类型相同
    • 同时方法a的形参列表中有n个参数，方法b的形参列表有n-1个参数
    • 且方法a的第1个参数作为方法b的调用者，且方法a的后n-1参数与方法b的n-1参数匹配

2、举例

情况一：对象 :: 实例方法

  • Consumer中的void accept(T t)与PrintStream中的void println(T t)参数返回值相同
  • 后者直接替换掉前者
@Test
public void test1() {
	Consumer<String> con1 = str -> System.out.println(str);
	con1.accept("北京");

	System.out.println("*******************");
	PrintStream ps = System.out;
	Consumer<String> con2 = ps::println;
	con2.accept("beijing");
}
  • Supplier<String>中的T get()与Employee中的String getName()参数返回值相同
@Test
public void test2() {
	Employee emp = new Employee(1001,"Tom",23,5600);

	Supplier<String> sup1 = () -> emp.getName();
	System.out.println(sup1.get());

	System.out.println("*******************");
	Supplier<String> sup2 = emp::getName;
	System.out.println(sup2.get());
}

情况二：类 :: 静态方法

  • Comparator中的int compare(T t1,T t2)与Integer中的静态方法int compare(T t1,T t2)参数返回值相同
@Test
public void test3() {
	Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
	System.out.println(com1.compare(12,21));

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

	Comparator<Integer> com2 = Integer::compare;
	System.out.println(com2.compare(12,3));
}
  • Function中的R apply(T t)与Math中的静态方法Long round(Double d)参数返回值相同
@Test
public void test4() {
	Function<Double,Long> func = new Function<Double, Long>() {
		@Override
		public Long apply(Double d) {
			return Math.round(d);
		}
	};

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

	Function<Double,Long> func1 = d -> Math.round(d);
	System.out.println(func1.apply(12.3));

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

	Function<Double,Long> func2 = Math::round;
	System.out.println(func2.apply(12.6));
}

情况三：类 :: 实例方法

  • a抽象方法第一个参数s1为b方法调用者，a抽象方法其他参数为b方法参数
@Test
public void test5() {
	Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
	System.out.println(com1.compare("abc","abd"));

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

	Comparator<String> com2 = String :: compareTo;
	System.out.println(com2.compare("abd","abm"));
}
  • Function中的R apply(T t)与Employee中的String getName()返回值一样
  • e -> e.getName()：第一参数e为后者的调用者
@Test
public void test6() {
	Employee employee = new Employee(1001, "Jerry", 23, 6000);

	Function<Employee,String> func1 = e -> e.getName();
	System.out.println(func1.apply(employee));

	System.out.println("*******************");
	Function<Employee,String> func2 = Employee::getName;
	System.out.println(func2.apply(employee));
}

三、构造器引用

  • 当Lambda表达式是创建一个对象，并且满足Lambda表达式形参正好是给创建这个对象的构造器的实参列表，就可以使用构造器引用
  • 格式：类名::new

空参构造器

@Test
public void test1(){
    Supplier<Employee> sup = new Supplier<Employee>() {
        @Override
        public Employee get() {
            return new Employee();
        }
    };
    System.out.println("*******************");

    Supplier<Employee>  sup1 = () -> new Employee();
    System.out.println(sup1.get());

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

    Supplier<Employee>  sup2 = Employee :: new;
    System.out.println(sup2.get());
}

多参构造器

  • 相当于BiFunction中的R apply(T t,U u)中的参数赋值给new Employee(id,name)
@Test
public void test2(){
    BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
    System.out.println(func1.apply(1001,"Tom"));

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

    BiFunction<Integer,String,Employee> func2 = Employee :: new;
    System.out.println(func2.apply(1002,"Tom"));
}

四、数组构造引用

  • 当Lambda表达式是创建一个数组对象，并且满足Lambda表达式形参正好是给创建这个数组对象的长度，就可以数组构造引用
  • 格式：数组类型名::new
@Test
public void test3(){
    Function<Integer,String[]> func1 = length -> new String[length];
    String[] arr1 = func1.apply(5);
    System.out.println(Arrays.toString(arr1));

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

    Function<Integer,String[]> func2 = String[] :: new;
    String[] arr2 = func2.apply(10);
    System.out.println(Arrays.toString(arr2));
}

总结

  • 只要看起来没有歧义，只能仅有调用某个方法，传入某些参数，就可以简化为Lambda表达式或方法构造器引用
冬天vs不冷
关注
  • 18
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础理论之Lambda表达式，方法引用
Allen_Heng的博客
09-27 539
函数式编程思想，让编码偏向于过程，让我们书写代码是关注关键所在而不在于固定形式。 函数式编程思想概述 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。 做什么，而不是怎么做 传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做
Java Lambda表达式的方法引用和构造器引用实例分析
08-25
主要介绍了Java Lambda表达式的方法引用和构造器引用,结合实例形式分析了Lambda表达式的方法引用和构造器引用相关原理、用法及操作注意事项,需要的朋友可以参考下
Java，Lambda表达式、方法引用和构造器引用
二狗mao的博客
11-30 965
>的左边：lambda形参列表，参数的类型都可以省略。如果形参只有一个，则括号( )也可以省略。->的右边：lambda体，对应着重写的方法体。当方法体只有一条语句时，大括号{}可以省略。如果只有一条return语句，则大括号{}和return一并省略。
java8新特性之lambda表达式(及方法引用与构造器引用)
cristianoxm的博客
11-27 430
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。 一、语法 lambda 表达式的语法格式如下： (parameters) -> expression 或 (parameters) ->{ statements; } 以下是lambda表达式的重要特征: 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。 可选的大括号：如果主体包含了
Java基础：Lambda表达式方法引用
时代各有不同，青春一脉相承。
12-26 1520
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？能否省去Lambda的语法格式（尽管它已经相当简洁）呢？双冒号::为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。
java知识点回顾（11）：Lambda表达式、方法引用
qq_50843126的博客
07-19 480
java知识点回顾（11）：Lambda表达式、方法引用
Java：Lambda表达式、方法引用
游手好闲
01-06 835
Java：Lambda表达式、方法引用
【Java基础】Java8特性——lambda表达式，方法引用，构造器引用
橙子的博客
02-21 231
(parameters) -> expression 或 (parameters) ->{ statements;lamaba表达式的实质：作为函数式接口的实例，是对象，不是函数。（注解@FunctionalInterface)函数式接口： 接口只有一个抽象方法。
Java:JDK8新特性：Lambda表达式、省略规则与方法引用
ZQCJL的博客
08-06 248
参数类型可以不写如果只有一个参数，参数类型可以省略，同时（）也可以省略;两个参数的话就不可以省略了。如果Lambda表达式中的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号；此时，如果这行代码是return语句，也必须去掉return不写。
lanlan2017#JavaReadingNotes#6.8.3 方法引用与构造器引用1
07-25
- 第6章 面向对象(下)6.8.3 方法引用与构造器引用如果Lambda表达式的代码块只有一条代码,程序就可以省略Lambda表达式中代码块的花括号。如果L
Java面向对象系列[Lambda]
12-22
Lambda表达式支持将代码块作为方法参数，Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口（这种接口叫函数式接口）的实例 public class ProcessArray { public void process(int[] target, Command ...
JVM调用Lambda的表达式实现方法原理详解.docx
07-03
invokespecial：用于调用实例构造器方法、私有方法和父类中的方法。 invokevirtual：用于调用所有的虚方法。 invokeinterface：用于调用接口方法，会在运行时再确定一个实现该接口的对象。 invokedynamic：...
Java8 新特性之lamdba表达式和Optional
03-19
1.3 方法引用和构造器 12 1.2.1 方法引用 12 1.2.2 构造器 12 1.4 Stream语法 13 1.3.1 入门案例 13 1.3.2 怎么得到Stream 15 1.3.3 转换Stream 16 1.3.4 汇聚Stream 19 2 Optional类 20 2.1 创建Optional容器 21 ...
java学习和项目总结
2301_79390585的博客
05-24 465
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1196
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
深入理解Java的垃圾回收机制（GC）实现原理
最新发布
微笑听雨
05-25 1383
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
QQ1304979694的博客
05-24 567
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
【进程信号】可重入函数&&volatile关键字
稻草人敲代码的博客
05-22 560
虽然执行了myhandler,也成功修改了flag的值，但是由于编译器优化，早就将flag的值拷贝到寄存器中了，CPU只会在寄存器中读取flag的值。标准情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ， while。意思就是说，可重入函数里面的数据都是临时变量，随着函数栈帧的销毁而销毁，编译器在优化代码的时候，会大概推断出哪些变量在特定的范围内不会改变。保持内存的可见性，告知编译器，被该关键字修饰的变量，，对该变量的任何操作，都必须在真实的内存中进行操作。
lambda表达式 条件构造器
09-06
Lambda表达式的条件构造器用于在Lambda表达式中根据条件来构造不同的结果。它可以根据给定的条件返回不同的表达式或语句。具体来说，Lambda表达式的条件构造器可以使用if语句或者三元运算符来实现条件判断。 使用if语句的Lambda表达式条件构造器的语法如下： (parameters) -> { if (condition) { // 执行条件为真的语句 return expression1; } else { // 执行条件为假的语句 return expression2; } } 使用三元运算符的Lambda表达式条件构造器的语法如下： (parameters) -> condition ? expression1 : expression2 注意，expression1和expression2可以是表达式或者语句块。条件构造器可以根据需要自由组合和嵌套，以实现更复杂的条件逻辑。 方法引用是对Lambda表达式符合某种情况下的一种缩写，使得我们的Lambda表达式更加精简。当Lambda表达式中的逻辑非常简单且只调用了一个已存在的方法时，可以考虑使用方法引用。方法引用通过引用已存在的方法来替代Lambda表达式，使代码更加简洁和易读。方法引用的语法格式为：类名::方法名。 总结一下，Lambda表达式的条件构造器用于根据条件来构造不同的结果，可以使用if语句或者三元运算符来实现。方法引用是对符合某种情况下的Lambda表达式的一种缩写，用于替代Lambda表达式中调用已存在方法的情况，使代码更简洁。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Java学习day042 lambda表达式（构造器引用、变量作用域、处理lambda表达式、再谈Comparator）](https://blog.csdn.net/Zzehao11/article/details/105415027)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [java8新特性之lambda表达式(及方法引用与构造器引用)](https://blog.csdn.net/cristianoxm/article/details/110222407)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

冬天vs不冷

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

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

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

打赏作者

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

抵扣说明：

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

余额充值