浅谈Lambda表达式 | 滚~韬的博客

什么是Lambda表达式？

可以将Lambda表达式理解为一个匿名函数； Lambda表达式允许将一个函数作为另外一个函数的参数；我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码作为实参）,也可以理解为函数式编程，将一个函数作为参数进行传递。

2. 为什么要引入Lambda表达式？

当java程序员看到其他语言的程序员（如JS，Python）在使用闭包或者Lambda表达式的时候，于是开始吐槽世界上使用最广的语言居然不支持函数式编程。千呼万唤，Java8推出了Lambda表达式。

package com.isea.java;
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");
        }
}

为了使这段代码变得更加简洁，可以使用匿名内部类重构一下（注意代码中的注释）

package com.isea.java;
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();
    }
}

3. Lambda表达式的分类

1. 无参无返回值

public class TestLambda {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello"));
    }
}

2. 有参无返回值

import java.util.ArrayList;
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
    }
}
public void forEach(Consumer<? super E> action)

forEach() 功能等同与增强型for循环这个方法来自于Iterable接口，Collection接口继承了这个接口，List又继承了Collection接口，而ArrayList是List的实现类；forEach函数，指明该函数需要传入一个函数，而且是有参数没有返回值的函数，而Consumer接口中正好有且仅有一个这样的有参无返回值的抽象方法。接下来，我们会了解到这是使用Lambda的必要条件。

3. 无参有返回值

import java.util.Random;
import java.util.stream.Stream;
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) //来自源码

4. 有参有返回值

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 + '\'' +
                '}';
    }
}

4. 函数式接口

即SAM（Single Abstract Method ）接口，有且只有一个抽象方法的接口（可以有默认方法或者是静态方法和从Object继承来的方法，但是抽象方法有且只能有一个）。 JDK1.8之后，添加@FunctionalInterface表示这个接口是是一个函数式接口，因为有了@functionalInterface标记，也称这样的接口为Mark（标记）类型的接口。举例子：

@FunctionalInterface
java.lang.Runnable{
    void run();
}
@FunctionalInterface
java.lang.Comparator<T>{
	int compare(T o1, T o2);
}
@FunctionalInterface
public interface Function<T, R> {
	R apply(T t);
}

针对上面的例子，比方说这个Runnable接口是支持Lambda表达式，那么如果有一个方法（比如Thread类的构造函数）需要传入一个Runnable接口的实现类的话，那么就可以直接把Lambda表达式写进去。

换个角度说TreeSet，它有一个构造函数中是要求传入一个接口类型，如果这个接口类型恰好是函数式接口，那么直接传进去一个Lambda表达式即可。

函数式接口作用

函数式接口能够接受匿名内部类的实例化对象，换句话说，我们可以使用匿名内部类来实例化函数式接口的对象，而Lambda表达式能够代替内部类实现代码的进一步简化，因此，Lambda表达式和函数式接口紧密的联系到了一起，接下来的这句话非常的重要：

每一个Lambda表达式能隐式的给函数式接口赋值
1
new Thread(() -> System.out.println("hello")).start();

编译器会认为Thread()中传入的是一个Runnable的对象，而我们利用IDEA的智能感知，鼠标指向“->”或“（）”的时候，会发现这是一个Runnable类型，实际上编译器会自动将Lambda表达式赋值给函数式接口，在本例中就是Runnable接口。本例中Lambda表达式将打印方法传递给了Runnable接口中的run（）方法，从而形成真正的方法体。

而且，参数与返回值是一一对应的，即如果函数式接口中的抽象方法是有返回值，有参数的，那么要求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)有参有返回值的抽象方法；

5. 新日期时间API(补充)

1. LocalDate(只有年月日)

public class LocalDate_Test {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        System.out.println(date.getYear()+" "+date.getMonthValue()+" "+date.getDayOfMonth());
        System.out.println(date.toString());
    }
}

2 . LocalTime(只有时分秒)

public class LocalTime_Test {
    public static void main(String[] args) {
        LocalTime time = LocalTime.now();
        System.out.println(time.getHour()+" "+time.getMinute()+" "+time.getSecond());
        System.out.println(time.toString());
        System.out.println(time.toSecondOfDay());
    }
}

3. LocalDateTime(年月日和时分秒)

public class LocalDateTime_Test {
    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(dateTime.getYear()+" "+dateTime.getMonthValue()+" "+dateTime.getDayOfMonth()+
                            dateTime.getHour()+" "+dateTime.getMinute()+" "+dateTime.getSecond());
        System.out.println(dateTime.toString());
    }
}

4. DateTimeFormatter

public class DateTimeFormatter_Test {
    public static void main(String[] args) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd:HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.parse("2017-12-15:19:15:01",formatter);
        System.out.println(dateTime.toString());
    }
}

5. ZonedDateTime(有时区)

public class ZonedDateTime_Test {
    public static void main(String[] args) {
        ZonedDateTime zonedDateTime = ZonedDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy:HH:mm:ss");
        String date = zonedDateTime.format(formatter);
        System.out.println(date);
    }
}