Lambda详解
什么是Lambda表达式？
可以将Lambda表达式理解为一个匿名函数； Lambda表达式允许将一个函数作为另外一个函数的参数； 我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码作为实参）,也可以理解为[函数式编程]，将一个函数作为参数进行传递。
为什么要引入Lambda表达式？
-
避免匿名内部类定义过多
-
使代码看起来简洁
-
简化代码，只留下核心逻辑
-
让编程更加高效
(params)-> expression[表达式]
(params) -> statement[语句]
(params)-> {statements}
看一段代码
public class TestLambda {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start();
thread.close();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("Hello");
}
}
使用匿名内部类重构一下,让代码更加简洁
public class TestLambda {
public static void main(String[] args) {
new Thread(new Runnable() {
//这里的new Runnable()，这里new 了接口，在这个new的接口里面，我们写了这个接口的实现类。
//这里可以看出，我们把一个重写的run()方法传入了一个构造函数中。
@Override
public void run() {
System.out.println("Hello");
}
}).start();
}
}
但是用Lambda表达式还可以让代码更加简洁
public class TestLambda {
public static void main(String[] args) {
new Thread(() -> System.out.println("Hello")).start();
}
}
如何真正理解Lambda表达式?
-
理解Functional Interface (函数式接口)是学习Java8 lambda表达式的关键所在
-
函数式接口的定义:
-
任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口
public interface Runnable{ public abstract void run(); } -
对于函数式接口,我们可以通过Lambda表达式来创建该接口的对象
-
如何使用Lambda表达式?
Lambda表达式的语法：
([Lambda参数列表，即形参列表]) -> {Lambda体，即方法体(可以是一个表达式也可以是一个代码块)}
拷贝小括号，写死右箭头，落地大括号，大括号中写上业务逻辑
当然我们要防止一个接口有多个抽象方法(这个我接下来要讲),所以为了避免后来人给这个接口添加函数后,导致该接口有多个函数,不再是函数式接口,我们可以在接口类的上方声明@FunctionalInterface
特点：使用 "->"将参数和实现逻辑分离；( ) 中的部分是需要传入Lambda体中的参数；{ } 中部分，接收来自 ( ) 中的参数，完成一定的功能。
(int x, int y) -> x + y //接收x和y两个整形参数并返回他们的和 () -> 66 //不接收任何参数直接返回66 (String name) -> {System.out.println(name);} //接收一个字符串然后打印出来 (View view) -> {view.setText("lalala");} //接收一个View对象并调用setText方法
表达式：表达式会被执行然后返回结果。它简化掉了return关键字。
代码块：顾名思义就是一段代码，和普通方法中的语句一样。
Lambda表达式的分类
无参无返回值
public class TestLambda {
public static void main(String[] args) {
new Thread(() -> System.out.println("Hello"));
}
}
//()中无参数，也不能省略；{}中只有一句话，建议省略。
有参无返回值
public class TestLambda {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("AAAAA");
list.add("BBBBB");
list.add("CCCCC");
list.add("DDDDD");
//形参的类型是确定的，可省略；只有一个形参，()可以省略；
list.forEach(t -> System.out.print(t + "\t"));
//或者更简洁的方法引用：list.forEach(System.out::println);
//打印结果：AAAAA BBBBB CCCCC DDDDD
}
}
forEach() 功能等同与增强型for循环，这个方法来自于Iterable接口，Collection接口继承了这个接口，List又继承了Collection接口，而ArrayList是List的实现类；forEach函数，指明该函数需要传入一个函数，而且是有参数没有返回值的函数，而Consumer接口中正好有且仅有一个这样的有参无返回值的抽象方法。接下来，我们会了解到这是使用Lambda的必要条件。
无参有返回值
public class TestLambda {
public static void main(String[] args) {
Random random = new Random();
Stream<Integer> stream = Stream.generate(() ->random.nextInt(100));
stream.forEach(t -> System.out.println(t));
}//只有一个return，可以省略return；该方法将会不断的打印100以内的正整数。
}//Stream.generate()方法创建无限流，该方法要求传入一个无参有返回值的方法。
public static<T> Stream<T> generate(Supplier<T> s) //来自源码
有参有返回值
package com.isea.java;
import java.text.Collator;
import java.util.TreeSet;
public class TestLambda {
public static void main(String[] args) {
Collator collator = Collator.getInstance();
TreeSet<Student> set = new TreeSet<>((s1,s2) -> collator.compare(s1.getName(),s2.getName()));
set.add(new Student(10,"张飞"));
set.add(new Student(3,"周瑜"));
set.add(new Student(1,"宋江"));
set.forEach(student -> System.out.println(student));
}
}//这里的Collator是一个抽象类，但是提供了获取该类实例的方法getInstance()
class Student{
private int id;
private String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
Home | This.ID = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
针对上面的例子，比方说这个Runnable接口是支持Lambda表达式，那么如果有一个方法（比如Thread类的构造函数）需要传入一个Runnable接口的实现类的话，那么就可以直接把Lambda表达式写进去。
函数式接口有什么作用？
函数式接口能够接受匿名内部类的实例化对象，换句话说，我们可以使用匿名内部类来实例化函数式接口的对象，而Lambda表达式能够代替内部类实现代码的进一步简化，因此，Lambda表达式和函数式接口紧密的联系到了一起，接下来的这句话非常的重要：
每一个Lambda表达式能隐式的给函数式接口赋值
上文中提到的例子：
new Thread(() -> System.out.println("hello")).start();
编译器会认为Thread()中传入的是一个Runnable的对象，而我们利用IDEA的智能感知，鼠标指向“->”或“（）”的时候，会发现这是一个Runnable类型，实际上编译器会自动将Lambda表达式赋值给函数式接口，在本例中就是Runnable接口。本例中Lambda表达式将打印方法传递给了Runnable接口中的run（）方法，从而形成真正的方法体。
而且，参数与返回值是一一对应的，即如果函数式接口中的抽象方法是有返回值，有参数的，那么要求Lambda表达式也是有返回值，有参数的（余下类推）
自定义一个函数式接口：
@FunctionalInterface
interface IMyInterface {
void study();
}
public class TestIMyInterface {
public static void main(String[] args) {
IMyInterface iMyInterface = () -> System.out.println("I like study");
iMyInterface.study();
}
}//这里的Lambda表达式将方法体赋值给函数式接口
四大函数式接口：
有时候后，如果我们调用某一个方法，发现这个方法中需要传入的参数要求是一个函数式的接口，那么我们可以直接传入Lambda表达式。这些接口位于java.util.function包下，需要注意一下，java.util包和java.util.function包这两个包没有什么关系，切不可以为function包是java.util包下面的包。
-
消费型接口：Consumer< T> void accept(T t)有参数，无返回值的抽象方法；
-
供给型接口：Supplier < T> T get() 无参有返回值的抽象方法；
-
断定型接口： Predicate< T> boolean test(T t):有参，但是返回值类型是固定的boolean
-
函数型接口： Function< T，R> R apply(T t)有参有返回值的抽象方法；
除了这四个之外，在java.util.function包下还有很多函数式接口可供使用。
方法引用：
当Lambda表达式满足某种条件的时候，使用方法引用，可以再次简化代码
构造引用：当Lambda表达式是通过new一个对象来完成的，那么可以使用构造引用。
实例
public class TestLambda {
public static void main(String[] args) {
HashMap<String,Double> map = new HashMap<>();
map.put("周瑜",9000.0);
map.put("宋江",12000.0);
map.put("张飞",8000.0);
map.forEach((k,v) -> {
if (v < 10000.0)
map.put(k,10000.0);
});//BiConsumer<T,U>，void apply(T t, U u)
map.forEach((k,v) -> System.out.print(k + ":" + v + "\t\t"));
}
}//结果打印：张飞:10000.0 周瑜:10000.0 宋江:12000.0
类名::实例方法
Lambda表达式的的Lambda体也是通过一个对象的方法完成，但是调用方法的对象是Lambda表达式的参数列表中的一个，剩下的参数正好是给这个方法的实参。
public class TestLambda {
public static void main(String[] args) {
// Supplier<Student> s = () -> new Student();
Supplier<Student> s = Student::new;
}//实际过程：将new Student()赋值给了Supplier这个函数式接口中的那个抽象方法
}
类名::静态方法
public class TestLambda {
public static void main(String[] args) {
// Stream<Double> stream = Stream.generate(() -> Math.random());
// 类名::静态方法, Lambda表达式的(形参列表)与实例方法的(实参列表)类型，个数是对应
Stream<Double> stream = Stream.generate(Math::random);
stream.forEach(System.out::println);
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
