Java - Lambda表达式 / 方法引用 / 构造器引用 / 数组引用（多种情况举例说明）

最新推荐文章于 2023-02-21 09:03:21 发布
最新推荐文章于 2023-02-21 09:03:21 发布
阅读量944 收藏 10
点赞数 5
分类专栏： Java学习 文章标签： lambda java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H_X_P_/article/details/105020439
版权

目录

    Java 8中有两个最为重要的改变：第一个是Lambda表达式，另一个则是Stream API。使用Stream配合Lambda表达式、方法引用会让你的代码更简洁。

list.stream().map(good -> good.getName())
			 .map(string -> string.toUpperCase())
			 .forEach(string -> System.out.println(string));

list.stream().map(Goods :: getName).map(String :: toUpperCase).forEach(System.out :: println);

Java - Stream流 - 让你的代码更简洁（创建流、中间操作（筛选、映射、排序）、终止操作（匹配、约简、收集））

    Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更加简洁的 Java 代码。
    Lambda 表达式是一个可传递的代码块， 可以在以后执行一次或多次。
    关键：Lambda 表达式在Java中是函数式接口的一个对象（实例）

Lambda表达式语法

    Lambda表达式分为三部分：

  1. ‘->’：该操作符被称为Lambda操作符或箭头操作符。它将Lambda表达式分为两部分。
  2. ‘->’左侧：指定了Lambda表达式需要的参数列表，即接口中的抽象方法的参数列表。
  3. ‘->’右侧：指定了Lambda体，是抽象方法的实现逻辑，即Lambda表达式要执行的功能。

    下面将Lambda表达式分为6种情况：

无参数，无返回值

    我们以Runnable接口举例说明：创建一个线程：

package java.lang;
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

    Java 8之前的写法是这样的：

Runnable runnable = new Runnable() {
	@Override
	public void run() {
		System.out.println("线程运行中");
	}
};
runnable.run();
  1. 一个非抽象类实现一个接口就必须实现里面所有的抽象方法。由于Runnable接口中只有一个抽象方法 run()，显然方法名是可以推断出来的，所以方法名可以省略。
  2. 可以由接口中方法的定义推出来，权限修饰符是 public，没有返回值，所以 public 和 void 也可以省略。
  3. 由于Lambda表达式在Java中是函数式接口的一个对象（实例），所以 new Runnable() 也可以省略了。

    使用Lambda表达式，只留参数列表（这里没有参数，但必须留括号），‘->’ 和方法体：

Runnable runnable = () -> {
	System.out.println("线程运行中");
};
runnable.run();

    只有一条语句且不是return语句时，方法体的花括号可以省略：

Runnable runnable = () -> System.out.println("线程运行中");
runnable.run();

有一个参数，无返回值

    我们以Consumer接口举例说明：判断一个数是大于0，小于0或等于0：

package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

    Java 8之前的写法是这样的：

Consumer<Integer> consumer = new Consumer<Integer>() {
	@Override
	public void accept(Integer t) {
		if (t > 0) {
			System.out.println("大于0");
		} else if (t < 0) {
			System.out.println("小于0");
		} else {
			System.out.println("等于0");
		}
	}
};
consumer.accept(0);
  1. 由于Consumer接口中只有一个抽象方法 accept()（另外一个是默认方法，Java 8可以在接口中定义默认方法），显然方法名是可以推断出来的，所以方法名可以省略。显然 public 和 void 也可以省略。
  2. 由于Lambda表达式在Java中是函数式接口的一个对象（实例），所以 new Consumer<Integer>() 也可以省略了。

    使用Lambda表达式，只留参数列表（这里的参数是t），‘->’ 和方法体（这里有多条语句，花括号不能省略）：

Consumer<Integer> consumer = (Integer t) -> {
	if (t > 0) {
		System.out.println("大于0");
	} else if (t < 0) {
		System.out.println("小于0");
	} else {
		System.out.println("等于0");
	}
};
consumer.accept(-10);

    由于参数 t 的类型可以由 Consumer<Integer> 推出来（类型推断，注意接口的定义中的泛型T），所以参数的类型可以省略。

Consumer<Integer> consumer = (t) -> {
	if (t > 0) {
		System.out.println("大于0");
	} else if (t < 0) {
		System.out.println("小于0");
	} else {
		System.out.println("等于0");
	}
};
consumer.accept(-10);

    当参数列表中的参数只有一个时，参数旁边的 () 可以省略。

Consumer<Integer> consumer = t -> {
	if (t > 0) {
		System.out.println("大于0");
	} else if (t < 0) {
		System.out.println("小于0");
	} else {
		System.out.println("等于0");
	}
};
consumer.accept(-10);

有多个参数，无返回值

    我们自己写一个接口进行说明：

@FunctionalInterface
interface MultiParamNoReturn<T> {
	void method(T a, T b);
}

    Java 8之前的写法是这样的：

MultiParamNoReturn<Integer> m = new MultiParamNoReturn<Integer>() {
	@Override
	public void method(Integer a, Integer b) {
		System.out.printf("%d + %d = %d\n", a, b, (a + b));
	}
}; 
m.method(10, 11);

    使用Lambda表达式，只留参数列表（这里的参数是a，b），‘->’ 和方法体：

MultiParamNoReturn<Integer> m = (a, b) -> 
	System.out.printf("%d + %d = %d\n", a, b, (a + b));
m.method(5, 6);

无参数，有返回值

    我们以Supplier接口举例说明：

package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
    T get();
}

    Java 8之前的写法是这样的：

Supplier<Double> supplier = new Supplier<Double>() {
	@Override
	public Double get() {
		return (Double)Math.random()*10000;
	}
};
System.out.printf("今天又双叒叕丢了%.2f块钱",supplier.get());

    使用Lambda表达式，只留参数列表（这里没有参数），‘->’ 和方法体：

Supplier<Double> supplier = () -> {
	return (Double)Math.random()*10000;
};
System.out.printf("今天又双叒叕丢了%.2f块钱\n",supplier.get());

    当Lambda表达式的方法体只有一条语句，且是return语句，那么return和花括号都可以省略。

Supplier<Double> supplier = () -> (Double)Math.random()*10000;
System.out.printf("今天又双叒叕丢了%.2f块钱\n",supplier.get());

有一个参数，有返回值

    我们以Predicate接口举例说明：判断一个字符串是否相等：

package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    ...
}

    Java 8之前的写法是这样的：

public static boolean search(List<String> list, Predicate<String> predicate) {
	for (String string : list) {
		if (predicate.test(string))
			return true;
	}
	return false;
}
	
public static void main(String[] args) {
	List<String> list = Arrays.asList("Lanbda","Lamdba","Landba","Lembda","Lambde");
	boolean result = search(list, new Predicate<String>() {
		@Override
		public boolean test(String t) {
			return t.equals("Lambda");
		}
	});
	System.out.println(result);
}
  1. public、boolean、方法名可以由Predicate接口中唯一的抽象方法 test(T t) 推出来，所以可以省略。
  2. new Predicate<String>() 和 test(T t) 中的参数类型可以由 search(List<String> list, Predicate<String> predicate) 推出，所以可以省略。

    使用Lambda表达式：

public static boolean search(List<String> list, Predicate<String> predicate) {
	for (String string : list) {
		if (predicate.test(string))
			return true;
	}
	return false;
}
	
public static void main(String[] args) {
	List<String> list = Arrays.asList("Lanbda","Lamdba","Landba","Lembda","Lambde");
	boolean result = search(list, t -> t.equals("Lambda"));
	System.out.println(result);
}

有多个参数，有返回值

    我们以Comparator接口举例说明：Comparator自然排序：

package java.util;
...
@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
	...
}

    Java 8之前的写法是这样的：

List<Integer> list = Arrays.asList(30,10,62,47,84,7,55);
Collections.sort(list, new Comparator<Integer>() {
	public int compare(Integer o1, Integer o2) {
		return Integer.compare(o1,o2);
	}
});
System.out.println(list);

    这里有一个问题：为什么Comparator有两个抽象方法compare和equals，但是必须要重写compare，而不必重写equals？

戳我☞☞☞因为重写了超类Object类中任意一个public方法的方法并不算接口中的抽象方法，任何接口的实现都会从其父类Object或其它地方获得这些方法的实现。

    使用Lambda表达式：

List<Integer> list = Arrays.asList(30,10,62,47,84,7,55);
Collections.sort(list,(o1, o2) -> Integer.compare(o1, o2));
System.out.println(list);

函数式接口

    函数式接口(Functional Interface)是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。我们可以通过Lambda表达式来创建该接口的对象。
    我们可以在一个接口上使用 @FunctionalInterface 注解，这样可以检查它是否是一个函数式接口。
    在java.util.function包下定义了丰富的函数式接口。
在这里插入图片描述

方法引用

    方法引用可以看做是lambda表达式深层次的表达。换句话说，方法引用就是lambda表达式，也就是函数式接口的一个对象（实例）。
    使用场景：当要传递给Lambda体的操作，已经有实现的方法了，那么就可以使用方法引用。
    要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致（相同）。
    格式：使用操作符 “::” 将类（或对象）与方法名分割开来。（是已经实现好的方法名及其所在的类或对象）。（可以看成左边的类或对象是调用者，右边的方法是被调用者）

对象 :: 实例（非静态）方法名

    Consumer接口中的方法：void accept(T t)
    PrintStream类中的方法：void println(T t)
    匿名内部类方式：

Consumer<String> consumer = new Consumer<String>() {
	@Override
	public void accept(String t) {
		System.out.println(t);
	}
};
consumer.accept("hello world");

    Lambda表达式方式：

Consumer<String> consumer = string -> System.out.println(string);
consumer.accept("hello world");

    方法引用方式：

  1. void accept(T t) 和 void println(T t) 的返回值类型都是void，没有返回值；参数列表参数类型都一样，为泛型T。返回值类型和参数类型都可以由两个方法推出来。
  2. println()方法在PrintStream类中已经实现好了，PrintStream对象调用println()方法。

    从Lambda表达式看，可以看成 ‘->’ 左边的参数列表和右边的参数列表相同，且右边的方法已经实现好了，那么用 ‘::’ 将右边的调用者和方法分割开来。

PrintStream printStream = System.out;
Consumer<String> consumer = printStream :: println;
consumer.accept("hello world");

    Supplier接口中的方法：T get()
    Person类中的方法：String getName()

public class Person{
	public String name;
	public Person(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;
	}
	...
}

    匿名内部类方式：

Person person = new Person("Tom",10);
Supplier<String> supplier = new Supplier<String>() {
	@Override
	public String get() {
		return person.getName();
	}
};
System.out.println(supplier.get());

    Lambda表达式方式：

Supplier<String> supplier = () -> person.getName();
System.out.println(supplier.get());

    方法引用方式：

  1. T get() 和 String getName() 的返回值类型都是String；都没有参数。返回值类型和参数类型都可以由两个方法推出来。
  2. getName()方法在Person类中已经实现好了，Person对象调用getName()方法。
Supplier<String> supplier = person :: getName;
System.out.println(supplier.get());

类 :: 静态方法名

    Comparator接口中的方法：int compare(T t1, T t2)
    Integer类中的方法：int compare(T t1, T t2)
    匿名内部类方式：

Comparator<Integer> comparator = new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return Integer.compare(o1, o2);
	}
};
System.out.println(comparator.compare(10, 5));

    Lambda表达式方式：

Comparator<Integer> comparator = (o1, o2) -> Integer.compare(o1, o2);
System.out.println(comparator.compare(1, 5));

    方法引用方式：

  1. 显然，两个方法的返回值类型都是int；参数都一样。返回值类型和参数类型都可以由两个方法推出来。
  2. compare()方法在Integer类中已经实现好了，Integer类调用compare()方法。
Comparator<Integer> comparator = Integer :: compare;
System.out.println(comparator.compare(5, 5));

    Function接口中的方法：R apply(T t)
    Math类中的方法：Long round(Double d)
    匿名内部类方式：

Function<Double, Long> function = new Function<Double, Long>() {
	@Override
	public Long apply(Double d) {
		return Math.round(d);
	}
};
System.out.println(function.apply(123.7));

    Lambda表达式方式：

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

    方法引用方式：

Function<Double, Long> function = Math :: round;
System.out.println(function.apply(100.4));

类 :: 实例（非静态）方法名

    Comparator接口中的方法：int compare(T t1, T t2)
    String类中的方法：int t1.compare(T t2)
    匿名内部类方式：

Comparator<String> comparator = new Comparator<String>() {
	@Override
	public int compare(String o1, String o2) {
		return o1.compareTo(o2);
	}
};
System.out.println(comparator.compare("c", "a"));

    Lambda表达式方式：

Comparator<String> comparator = (o1, o2) -> o1.compareTo(o2);
System.out.println(comparator.compare("z", "a"));

    方法引用方式：

  1. 返回值类型都是int，参数的类型都是String。虽然它的参数列表不一样，但是String的compare()方法实际上也是 t1，t2 两个参数进行操作，只是它的写法看上去不一样（依然可以看成 compare(T t1, T t2)）。其中一个 t1 是调用者，它的方法compare()在String类中已经实现好了。（可以看成t1作为调用者前移了，所以参数列表少了一个参数）
Comparator<String> comparator = String :: compareTo;
System.out.println(comparator.compare("a", "z"));

    BiPredicate接口中的方法：boolean test(T t, U u)
    String类中的方法：boolean t.equals(U u)
    匿名内部类方式：

BiPredicate<String, String> biPredicate = new BiPredicate<String, String>() {
	@Override
	public boolean test(String t, String u) {
		return t.equals(u);
	}
};
System.out.println(biPredicate.test("Lambda", "Lamdba"));

    Lambda表达式方式：

BiPredicate<String, String> biPredicate = (t, u) -> t.equals(u);
System.out.println(biPredicate.test("Lambda", "Lamdba"));

    方法引用方式：

  1. 返回值类型都是boolean，参数的类型都是String。虽然它的参数列表不一样，但是String的equals()方法实际上可以看成 equals(T t, U u)。其中一个 t 是调用者，它的equals()方法在String类中已经实现好了。
BiPredicate<String, String> biPredicate = String :: equals;
System.out.println(biPredicate.test("Lambda", "Lambda"));

    Function接口中的方法：R apply(T t)
    Person类中的方法：String getName()
    匿名内部类方式：

Person person = new Person("Jerry",20);
Function<Person, String> function = new Function<Person, String>() {
	@Override
	public String apply(Person t) {
		return t.getName();
	}
};
System.out.println(function.apply(person));

    Lambda表达式方式：

Person person = new Person("Jerry",20);
Function<Person, String> function = t -> t.getName();
System.out.println(function.apply(person));

    方法引用方式：

  1. 返回值类型都是String，虽然Person类的getName()方法没有参数，但是我们可以把Function接口的 String apply(Person t) 看成是将参数 t 前移作为调用者，这样参数列表就没参数了，与getName()方法一样。而getName()在Person类中已经实现好了。
Person person = new Person("Jerry",20);
Function<Person, String> function = Person::getName;
System.out.println(function.apply(person));

    类似的还有

(x, y) -> x.compareToIgnoreCase(y);
//等价于
String :: compareToIgnoreCase;

构造器引用

    构造器引用与方法引用类似，其要求是函数式接口的抽象方法的参数列表与构造器的参数列表相同。抽象方法的返回值类型即为构造器所属类的类型。
    格式：类名 “::” new

    Supplier接口中的方法：T get()
    Person类中的构造器：Person()
    匿名内部类方式：

Supplier<Person> supplier = new Supplier<Person>() {
	@Override
	public Person get() {
		return new Person();
	}
};
System.out.println(supplier.get());

    Lambda表达式方式：

Supplier<Person> supplier = () -> new Person();
System.out.println(supplier.get());

    构造器引用方式：

Supplier<Person> supplier = Person :: new;
System.out.println(supplier.get());

    BiFunction接口中的方法：R apply(T t, U,u)
    Person类中的构造器：Person(String name, int age)
    匿名内部类方式：

BiFunction<String, Integer, Person> b = new BiFunction<String, Integer, Person>() {
	@Override
	public Person apply(String name, Integer age) {
		return new Person(name, age);
	}
};
System.out.println(b.apply("Jack", 18));

    Lambda表达式方式：

BiFunction<String, Integer, Person> b = (name, age) -> new Person(name, age);
System.out.println(b.apply("Jack", 18));

    构造器引用方式：

BiFunction<String, Integer, Person> b = Person :: new;
System.out.println(b.apply("Jack", 18));

数组引用

    数组引用与构造器引用类似。

    Function接口中的方法：R apply(T t)
    匿名内部类方式：

Function<Integer, String[]> function = new Function<Integer, String[]>() {
	@Override
	public String[] apply(Integer t) {
		return new String[t];
	}
};
String[] array = function.apply(5);
System.out.println(Arrays.toString(array));

    Lambda表达式方式：

Function<Integer, String[]> function = length -> new String[length];
String[] array = function.apply(5);
System.out.println(Arrays.toString(array));

    数组引用方式：

Function<Integer, String[]> function = String[] :: new;
String[] array = function.apply(5);
System.out.println(Arrays.toString(array));

如有错误请大家指出了(ง •̀_•́)ง (*•̀ㅂ•́)و

H_X_P
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java，Lambda表达式、方法引用和构造器引用
二狗mao的博客
11-30 1001
>的左边：lambda形参列表，参数的类型都可以省略。如果形参只有一个，则括号( )也可以省略。->的右边：lambda体，对应着重写的方法体。当方法体只有一条语句时，大括号{}可以省略。如果只有一条return语句，则大括号{}和return一并省略。
Lambda表达式及对方法和构造器的引用
weixin_33696822的博客
12-19 115
2019独角兽企业重金招聘Python工程师标准>>> ...
Lambda 表达式之：方法引用、构造器引用以及数组引用
sanhao_的博客
02-21 179
Lambda 表达式之：方法引用、构造器引用以及数组引用
Lambda表达式之方法引用和构造器引用
swordsmanye的博客
09-15 451
Lambda表达式的含义 Lambda省去面向对象的条条框框，格式由3个部分组成： 一些参数 一个箭头 一段代码 Lambda表达式的标准格式为： (参数类型 参数名称) -> { 代码语句 } 格式说明： ( )：接口中的抽象方法的参数列表，无参数则留空，有参数就写出参数；多个参数则用逗号分隔。 -> ：是新引入的语法格式，代表指向动作，传递的意思，把小括号内的参数传递给后...
java8新特性之lambda表达式(及方法引用与构造器引用)
cristianoxm的博客
11-27 441
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。 一、语法 lambda 表达式的语法格式如下： (parameters) -> expression 或 (parameters) ->{ statements; } 以下是lambda表达式的重要特征: 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。 可选的大括号：如果主体包含了
Java Lambda表达式的方法引用和构造器引用实例分析
08-25
Java Lambda表达式的方法引用和构造器引用实例分析 Java Lambda表达式是Java 8中引入的一种新的编程模型，它允许开发者使用函数式编程的方式来编写代码。Lambda表达式可以用来简化代码，提高代码的可读性和可维护性...
Java-JDK8新特性总结-接口方法/Lambda/方法引用/Optional
07-12
内容：包括接口中的方法/Lambda/方法引用/Optional/函数式接口 适合人群：有一定编程基础及Java基础的伙伴 使用场景：开发和面试题中都会用到，开发中合理运用Java 8新特性可以大大简化代码量，提高开发效率，在Java...
Java8特性lambda表达式和方法引用
01-20
在jdk中有一个Arrays.sort()方法用来对数组进行排序，在没有用lambda表达式之前我们一般用匿名内部类来传递比较条件，但是出现lambda表达式之后，这个就可以替换掉了。 import java.util.Arrays; import java.util....
java8 探讨与分析匿名内部类、lambda表达式、方法引用的底层实现的测试用例
03-21
在Java 8中，匿名内部类、Lambda表达式和方法引用是重要的新特性，它们极大地简化了代码，提升了代码的可读性和效率。下面将详细探讨这三个知识点，并结合提供的测试用例进行分析。 1. **匿名内部类**： 匿名内部类...
java8-lambda表达式的基础使用.pdf
07-05
Java 8 中 Lambda 表达式的基础使用 Java 8 中的 Lambda 表达式是 Java 8 中最流行最常用的功能特性之一。它将函数式编程概念引入 Java，函数式编程的好处在于可以帮助我们节省大量的代码，非常方便易用，能够大...
lambda表达式：构造器引用
LieBrother
12-08 1432
写给大忙人看的JavaSE8中的第一章：lambda表达式中的 1.5构造器引用
三、Lambda 方法引用与构造器引用
Be_nurturing的博客
07-09 256
Lambda 方法引用与构造器引用 public class TestMethodRef{ /** * 一、方法引用：若Lambda 体中的内容有方法已经实现，我们可以使用“方法引用” * （可以理解为方法引用是lambda表达式的另一种表现形式） * 主要三种语法格式： * ① 对象::实现方法名 * ② 类::静态方法名 * ③ 类::实例方法名 * 注意: * ① lambda 体中调用方法的参数列表与返回值类型
Lambda表达式的方法引用和构造器引用
实践求真知
06-09 673
一点睛 如果Lambda表达式的代码块只有一条代码，还可以在代码块中使用方法引用和构造器引用，以使得Lambda表达式更加简洁。 种类 示例 说明 对应的Lambda表达式 引用类方法 类名::类方法 函数式接口中被实现方法的全部参数传给该类方法作为参数。...
Java8新特性：Lambda表达式、函数式接口、方法引用 、 构造器引用 和 数组引用
GQ的博客
06-16 201
1.2 Lambda表达式语法 语法格式1：无参， 无返回值 语法格式2：Lambda需要一个参数，但是没有返回值 语法格式3：数据类型可以省略，因为可由编译器推断，称为类型维护 语法格式4：Lambda 若只需要一个参数时，参数的小括号可以省略 语法格式5：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值 语法格式6：当 Lambda 体只有一条语句时，return 与 大括号若有，都可以省略 1.3 Lambda总结 -> 左边： Lambda形参列表的参数类型可以省略（类型推断）
lambda表达式方法引用和构造器引用
qq_33732195的博客
03-01 390
方法引用 若lambda体中的功能，已经有方法提供了实现，可以使用方法引用；可以将方法引用理解为 lambda 表达式的另外一种表现形式； 对象的引用 :: 实例方法名 public void test1(){ //Comparator 消费型接口 Consumer<String> con = (str) -> System.out.println(str); ...
Lambda表达式和方法引用与构造器引用
clisks的博客
08-04 162
一.Lambda表达式 匿名类的一种简写方式，但是有条件 1.用法概述 Lambda表达式要用到->箭头符号 以->箭头符号 分为左右俩半 箭头左边是重写接口中抽象方法的参数列表 箭头右边是对接口中抽象方法的重写逻辑 使用Lambda表达式的要求：要求接口中只能有一个抽象方法或者接口是函数式接口 函数式接口：接口中只有一个抽象方法 使用@FunctionalInterface...
JAVA----Lambda表达式的方法和数组引用
m0_68092999的博客
04-26 1977
一：Lambda静态方法引用 条件：如果lambda表达式方法体已经有其他方法实现那么则可以使用方法引用 首先创建一个Person类，表明属性，封装一下，再写一个无参构造方法， 再写一个有参构造方法。 public class Person { private String nickname; private int gander; public Person() { } public Person(String nickname, int gand
Lambda表达式，方法引用，构造引用，数组引用（多截图）
weixin_53716018的博客
04-06 174
一：lambda表达式 1：格式 2：六种不同语法： 语法一：无参，无返回值 语法二：有一个参数，无返回值 语法三：参数的数据类型可以省略，即类型推断 上图中的泛型指定了为string ，所以lambda表达式里面就可以推断出参数的类型 语法四：若只有一个参数要传入，参数的小括号可以省略 语法五：lambda表达式需要多个参数，有多条语句，且有返回语句 语法六：当lambda体只有一条语句时，return与大括号若有，则都可以省略 3：lambda...
lambda表达式方法引用 java
最新发布
07-28
例如，对于构造方法`new ArrayList()`，可以使用lambda表达式`ArrayList::new`来引用。 需要注意的是，方法引用只能引用已经存在的方法，而不能创建新的方法。此外，方法引用的参数和返回值类型必须与被引用方法的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值