简介
Lambda表达式是 Java8 中最重要的新功能之一。使用 Lambda 表达式可以替代只有一个抽象函数的接口实现，告别匿名内部类，代码看起来更简洁易懂。Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作。
应用场景
任何有函数式接口的地方。
函数式接口：只有一个抽象方法（Object类中的方法除外）的接口
例子
public class LambdaDemo {
public static void main(String[] args) {
//使用匿名内部类
// Thread thread = new Thread(new Runnable() {
// @Override
// public void run() {
// System.out.println("running.....");
// }
// });
// thread.start();
//
//使用Lambda表达式
// new Thread(()->{System.out.println("running2.....");}).start();
List<String> list = Arrays.asList("java","javascript","scala","python");
//使用匿名内部类
// Collections.sort(list, new Comparator<String>() {
// @Override
// public int compare(String o1, String o2) {
// return o1.length()-o2.length();
// }
// });
// for(String str:list){
// System.out.println(str);
// }
//使用Lambda表达式
Collections.sort(list,(a,b)->a.length()-b.length());
list.forEach(System.out::println);
}
}
函数式接口
Supplier 代表一个输出
Consumer 代表一个输入
BiConsumer 代表两个输入
Function 代表一个输入，一个输出（一般输入和输出是不同类型的）
扫描二维码关注公众号，回复：
9512221 查看本文章
UnaryOperator 代表一个输入，一个输出（输入和输出是相同类型的）
BiFunction 代表两个输入，一个输出（一般输入和输出是不同类型的）
BinaryOperator 代表两个输入，一个输出（输入和输出是相同类型的）
public class Test {
public static void main(String[] args) {
Supplier<String> supplier = ()-> "hahaha";
Supplier<Integer> supplier1 = ()-> {return 666;};
System.out.println(supplier.get());
System.out.println(supplier1.get());
Consumer<String> c1 = (str)-> System.out.println(str);
c1.accept("hello");
}
}
方法引用
用于直接访问 类 或者 实例 的已经存在的方法或者构造方法。
方法引用提供了一种引用而不执行方法的方式，
如果抽象方法的实现恰好可以使用调用另外一个方法来实现，就有可能可以使用方法引用。
静态方法引用：如果函数式接口的实现恰好可以通过调用一个静态方法来实现，那么就可以使用静态方法引用
实例方法引用：如果函数式接口的实现恰好可以通过调用一个实例的实例方法来实现，那么就可以使用实例方法引用
对象方法引用：抽象方法的第一个参数类型刚好是实例方法的类型，抽象方法剩余的参数恰好可以当做实例方法的参数。如果函数式接口的实现能由上面说的实例方法调用来实现的话，那么就可以使用对象方法引用
构造方法引用：如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用
//静态方法引用
public class Test {
static String put(){
System.out.println("put....");
return "put";
}
public static void main(String[] args) {
Supplier<String> s1 = ()->"put1....";
Supplier<String> s2 = Test::put;
System.out.println(s1);
System.out.println(s2);
}
}
//实例方法引用
public class Test2 {
public String put(){
return "put...";
}
public static void main(String[] args) {
Supplier<String> s1 = () ->new Test2().put();
Supplier<String> s2 = () -> {return new Test2().put();};
Supplier<String> s3 = new Test2()::put;
System.out.println(s1.get());
System.out.println(s2.get());
System.out.println(s3.get());
}
}
//构造方法引用
public class Test5 {
public static void main(String[] args) {
Supplier<Person> s1 = ()->new Person();
s1.get();
Supplier<Person> s2 = Person::new;
s2.get();
Supplier<List> s3 = ArrayList::new;
Supplier<Set> s4 = HashSet::new;
Supplier<Thread> s5 = Thread::new;
Supplier<String> s6 = String::new;
Consumer<Integer> c1 = (age)->new Account(age);
Consumer<Integer> c2 = Account::new;
c1.accept(123);
c2.accept(456);
Function<String,Account> f1 = (str)->new Account(str);
Function<String,Account> f2 = Account::new;
f1.apply("abc");
f2.apply("def");
}
}
class Account{
public Account(){
System.out.println("调用无参构造方法");
}
public Account(int age){
System.out.println("age 参数构造" +age);
}
public Account(String str){
System.out.println("str 参数构造" +str);
}
}
class Person{
public Person(){
System.out.println("调用无参的构造方法");
}
}
