Java的方法分为实例方法，以及静态方法。它们本质上都相当于过程式语言的函数，但Java的实例方法隐含了个参数this。

我们常把支持函数式编程的编码风格称为Lambda表达式。

匿名类方式编写：

InnerClass ic = new InnerClass() {
    public int method(String s1, String s2) {
        return s1.equals(s2);
    }
});

Lambd表达式方式：

InnerClass ic =(s1, s2) -> {
    return s1.equals(s2);
 }

如果只有一行return代码，则可更简：

InnerClass ic=(s1, s2) ->s1.equals(s2)

只定义了单方法的接口为FunctionalInterface，用@FunctionalInterface标记。

Lambda表达式可不写FunctionalInterface实现类，而简化。

如果某个方法签名（除了方法名外，参数、返回类型相同则称方法签名一致）和接口一致，可直接传入方法引用。

@FunctionalInterface
public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
}

public class Main {
    public static void main(String[] args) {
        String[] array = new String[] { "Avocado", "Cappuccino","Espresso"};
        Arrays.sort(array, Main::cmp); //某个方法签名和接口恰好一致，就可以直接传入方法引用。
//Sorting an array of Objects using a Comparator,Besides using the Comparable implementation approach, it’s also possible to sort an array of Objects by passing an implementation of the java.util.Comparator interface to the Arrays.sort() method:
        System.out.println(String.join(", ", array));
    }

    static int cmp(String s1, String s2) {
        return s1.compareTo(s2);
    }
}

引用实例方法

public class Main {
    public static void main(String[] args) {
        String[] array = new String[] { "Avocado", "Cappuccino","Espresso"};
        Arrays.sort(array, String::compareTo);//签名只有一个参数，能和int Comparator<String>.compare(String, String)匹配是因为第一个隐含参数总是传入this，相当于静态方法。实例类型被看做第一个参数类型。
        System.out.println(String.join(", ", array));
    }
}

构造方法引用

// 引用构造方法
//构造方法的引用写法是类名::new
public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Bob", "Alice", "Tim");
        List<Person> persons = names.stream().map(Person::new).collect(Collectors.toList());
        System.out.println(persons);
    }
}

class Person {
    String name;
    public Person(String name) {
        this.name = name;
    }
    public String toString() {
        return "Person:" + this.name;
    }
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
//map()需要传入的FunctionalInterface的定义

泛型对应上就是方法签名Person apply(String),构造方法会隐式地返回this实例。实例类型被看做返回类型。