Lambda

可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。

  • 匿名——我们说匿名，是因为它不像普通的方法那样有一个明确的名称：写得少而想得多！
  • 函数——我们说它是函数，是因为Lambda函数不像方法那样属于某个特定的类。但和方法一样，Lambda有参数列表、函数主/ 体、返回类型，还可能有可以抛出的异常列表。
  • 传递——Lambda表达式可以作为参数传递给方法或存储在变中。
  • 简洁——无需像匿名类那样写很多模板代码。

什么是方法引用?

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。
当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式。(注意方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号”::”。)
例如：

  1. //原始方式
  2.  List<Apple> lists= Arrays.asList(new Apple("red", 50),
  3.                                   new Apple("green", 40),
  4.                                   new Apple("blank", 90)
  5.                                  );
  6. //使用lambda表达式     
  7. lists.sort((Apple a1, Apple a2) 
  8.               -> a1.getWeight().compareTo(a2.getWeight())); 
  9. //使用方法引用和java.util.Comparator.comparing：
  10. lists.sort(comparing(Apple::getWeight));
  11. /**
  12. Apple::getWeight就是引用了Apple类中定义的方法getWeight。请记住，不需要括号，因为你没有实际调用这个方法。方法引用就是Lambda表达式(Apple a) -> a.getWeight()的快捷写法。
  13. **/

解析：
方法的引用 - 图1简单地说，就是一个Lambda表达式。在Java 8中，我们会使用Lambda表达式创建匿名方法，但是有时候，我们的Lambda表达式可能仅仅调用一个已存在的方法，而不做任何其它事，对于这种情况，通过一个方法名字来引用这个已存在的方法会更加清晰，Java 8的方法引用允许我们这样做。方法引用是一个更加紧凑，易读的Lambda表达式，注意方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号”::”。

四种方法引用类型

方法引用的基本语法是：类名::方法名。（注意：只需要写方法名，不需要写括号）
方法引用的四种类型:

类型 Lambda示例 方法引用示例
引用静态方法 ()->Integer.parseInt(‘20’) Integer::parseInt
引用某个对象的实例方法 (String x)->x.length() String::length
引用某个类型的任意对象的实例方法 expensiveTransaction::getValue
引用构造方法 ()->new Apple(“red”, 50) Person::new

解析：

指向静态方法的方法引用（例如Integer的parseInt方法，写作Integer::parseInt）。

指 向 任意类型实例方法 的方法引用（例如 String 的 length 方法，写作String::length）。

指向现有对象的实例方法的方法引用（假设你有一个局部变量expensiveTransaction用于存放Transaction类型的对象，它支持实例方法getValue，那么你就可以写expensiveTransaction::getValue）。

使用方法引用的主要步骤

  1. 定义一个函数式接口
  2. 定义一个满足函数式接口抽象方法要求的方法
  3. 使用对步骤2中定义的（x::y）方法引用实例化函数式接口的实例（注：静态方法的方法引用格式为 类名::方法名；实例方法的方法引用格式为 对象实例名::方法名）
  4. 使用函数式接口实例调用方法：Instance.AbstractMethod();

1、静态方法引用

组成语法格式：类型::方法名
注意：

静态方法引用比较容易理解，和静态方法调用相比，只是把 . 换为 ::

在目标类型兼容的任何地方，都可以使用静态方法引用。

例子：

String::valueOf 等价于lambda表达式 (s) -> String.valueOf(s)

Math::pow 等价于lambda表达式 (x, y) -> Math.pow(x, y);
测试示例代码：

  2.     /**
  3.      *方法引用---字符翻转示例
  4.      */
  6.     interface StringFunc
  7.     {
  8.         String func(String n);
  9.     }
  11.     static class MyStringOps
  12.     {
  13.         public static String strReverse(String str)
  14.         {
  15.             StringBuilder result = new StringBuilder();
  16.             for (int i = str.length() - 1; i >= 0; i--)
  17.             {
  18.                 result.append(str.charAt(i));
  19.             }
  20.             return result + "";
  21.         }
  22.     }
  24.     public static class CRacer {
  25.         public static String stringOp(StringFunc sf, String s) {
  26.             return sf.func(s);
  27.         }
  29.         public static void main(String[] args) {
  30.             String inStr = "labmda add power to Java";
  31.             //MyStringOps::strReverse 相当于实现了接口方法func()
  32.             // 并在接口方法func()中作了MyStringOps.strReverse()操作
  33.             //表达式MyStringOps::strReverse的计算结果为对象引用，其中，strReverse提供了StringFunc的func()方法的实现。
  34.             String outStr = stringOp(MyStringOps::strReverse, inStr);
  35.             System.out.println("--------- " + inStr);
  36.             System.out.println("++++++++ +" + outStr);
  37.         }
  39.     }

2. 特定实例对象的方法引用

这种语法与用于静态方法的语法类似，只不过这里使用对象引用而不是类名。实例方法引用又分以下三种类型：

2.1 实例上的实例方法引用

组成语法格式：instanceReference::methodName

如下示例，引用的方法是myComparisonProvider 对象的compareByName方法。

  1. class ComparisonProvider{
  3.     public int compareByName(Person a, Person b){
  4.         return a.getName().compareTo(b.getName());
  5.     }
  7.     public int compareByAge(Person a, Person b){
  8.         return a.getBirthday().compareTo(b.getBirthday());
  9.     }
  10. }
  12. ComparisonProvider myComparisonProvider = new ComparisonProvider();
  13. Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);
  1.       public static void main(String[] args) {
  2.         String inStr = "lambda add power to Java";
  3.         MyStringOps strOps = new MyStringOps();//实例对象
  4.         //strOps::strReverse1 相当于实现了接口方法func() 
  5.         String outStr = stringOp(strOps::strReverse1, inStr);
  7.         System.out.println("Original string: " + inStr);
  8.         System.out.println("String reserved: " + outStr);
  9.     }
  10. //唯一区别就是一个传入的是 class:StaticFun  object:PublicFun

2.2超类上的实例方法引用

组成语法格式：super::methodName
方法的名称由methodName指定，通过使用super，可以引用方法的超类版本。
例子：

还可以捕获this 指针，this :: equals 等价于lambda表达式 x -> this.equals(x);

2.3.类型上的实例方法引用

组成语法格式：ClassName::methodName
注意：

  • 若类型的实例方法是泛型的，就需要在::分隔符前提供类型参数，或者（多数情况下）利用目标类型推导出其类型。
  • 静态方法引用和类型上的实例方法引用拥有一样的语法。编译器会根据实际情况做出决定。一般我们不需要指定方法引用中的参数类型，因为编译器往往可以推导出结果，但如果需要我们也可以显式在::分隔符之前提供参数类型信息。

例子：

String::toString 等价于lambda表达式 (s) -> s.toString()
解析：
这里不太容易理解，实例方法要通过对象来调用，方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象。

在泛型类或泛型方法中，也可以使用方法引用。

  1. package mytest;
  3. interface MyFunc<T>
  4. {
  6.     int func(T[] als, T v);
  7. }
  9. class MyArrayOps
  10. {
  12.     public static <T> int countMatching(T[] vals, T v)
  13.     {
  14.         int count = 0;
  15.         for (int i = 0; i < vals.length; i++)
  16.         {
  17.             if (vals[i] == v)
  18.             {
  19.                 count++;
  20.             }
  21.         }
  22.         return count;
  23.     }
  25. }
  27. public class CRacer
  28. {
  29.     public static <T> int myOp(MyFunc<T> f, T[] vals, T v)
  30.     {
  31.         return f.func(vals, v);
  32.     }
  34.     public static void main(String[] args)
  35.     {
  36.         Integer[] vals = {1, 2, 3, 4, 2, 3, 4, 4, 5};
  37.         String[] strs = {"One", "Two", "Three", "Two"};
  38.         int count;
  39.         //count = myOp(MyArrayOps::<Integer>countMatching, vals, 4); // 泛型 实现统计
  40.         count = myOp(MyArrayOps::countMatching, vals, 4); // 泛型 实现统计
  41.         System.out.println("vals contains " + count + " 4s");
  42.         // count = myOp(MyArrayOps::<String>countMatching, strs, "Two");
  43.         count = myOp(MyArrayOps::countMatching, strs, "Two");
  44.         System.out.println("strs contains " + count + " Twos");
  45.     }
  47. }

分析：
方法的引用 - 图2在程序中，MyArrayOps是非泛型类，包含泛型方法countMatching()。该方法返回数组中与指定值匹配的元素的个数。注意这里如何指定泛型类型参数。例如，在main()方法中，对countMatching()方法的第一次调用如下所示：

  1. count = myOp(MyArrayOps::<Integer>countMatching,vals,4);// 这里传递了类型参数Integer。

方法的引用 - 图3注意:参数传递发生在::的后面。这种语法可以推广。当把泛型方法指定为方法引用时，类型参数出现在::之后、方法名之前。但是，需要指出的是，在这种情况(和其它许多情况)下，并非必须显示指定类型参数，因为类型参数会被自动推断得出。对于指定泛型类的情况，类型参数位于类名的后面::的前面。

3、引用特定类型的任意对象的实例方法

方法的引用 - 图4在Java 8 In Action是这样介绍的，指向任意类型实例方法的方法引用（我觉得叫类的任意对象的实例方法引用更直观）。我开始一直想当然的就认为是类::实例方法这样就可以了，结果写了几个发现都用不了，看了官网给出的示例发现又可以，于是，作为当代优秀青年，怎么可能不解决这个问题呢。
官网给出的示例：

  1. String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };
  2. Arrays.sort(stringArray, String::compareToIgnoreCase);

方法的引用 - 图5方法引用的等效lambda表达式String::compareToIgnoreCase 将具有形式参数列表(String a, String b)，其中a和b是用于更好地描述此示例的任意名称。方法引用将调用该方法 a.compareToIgnoreCase(b)。之后再查了下，原文是这样的 “ reference to an instance method of an arbitrary object of a particular type ” arbitrary 任意的， particular 特定的，翻译过来就是引用特定类型的任意对象的实例方法。于是乎，知道了类的实例方法调用是有讲究的。那么，有什么样的条件呢?

  1. public class test1 {
  2.     public static void main(String[] args) {
  4.         List<Student> list = new ArrayList<>();
  5.         list.add(new Student("Jack1", 88));
  6.         list.add(new Student("Jack2", 81));
  7.         list.add(new Student("Jack3", 82));
  8.         list.add(new Student("Jack4", 83));
  9.         list.add(new Student("Jack5", 84));
  10.         list.add(new Student("Jack6", 85));
  11.         list.sort(Student::compareByScore);
  12.         System.out.println(list);
  13.     }
  14. }
  16. class Student {
  17.     private String name;
  18.     private int score;
  20.     public Student(){
  22.     }
  24.     public Student(String name,int score){
  25.         this.name = name;
  26.         this.score = score;
  27.     }
  29.     public String getName() {
  30.         return name;
  31.     }
  33.     public void setName(String name) {
  34.         this.name = name;
  35.     }
  37.     public int getScore() {
  38.         return score;
  39.     }
  41.     public void setScore(int score) {
  42.         this.score = score;
  43.     }
  45.     public int compareByScore(Student student){
  46.         return this.getScore() - student.getScore();
  47.     }
  49.     @Override
  50.     public String toString(){
  51.         return this.name + "  " + this.score + "  ";
  52.     }
  53. }

list.sort接受一个Comparator，Comparator需要实现compare方法，lambda形式 (v1,v2)-> {dosth;return intval;}。这里的compareByScore就是这种lambda形式的方法引用。
如果将上面的compareByScore方法改成如下形式，为什么又要报错了，我不就多传了一个参数进去么，其他的啥也没做啊。

  1.  public int compareByScore(Student student1, Student student2){
  2.         return this.getScore() - student1.getScore();
  3.     }

方法的引用 - 图6不好意思，==它要求接口方法的参数必须比引用方法的参数多一个。而且第一个参数要是该引用方法的所在类型的或其父类，除接口方法的第一个参数以外， 其余参数的类型要求一样。==这一段话，有些难以理解，看下面的代码就会明白了（也就是Interface参数个数要比我们引用方法参数个数多一个）。

Demo1

  1. package mytest;
  3. class Test1
  4. {
  5.     public void a()
  6.     {
  7.         System.out.println("just a test " + this.hashCode());
  8.     }
  10.     public static void main(String[] args)
  11.     {
  12.         MyInter m = Test1::a;
  13.         System.out.println(m.hashCode());
  14.         Test1  object = new Test1();
  15.         System.out.println(object.hashCode());
  16.         m.d(object);
  17.     }
  18. }
  20. @FunctionalInterface
  21. interface MyInter
  22. {
  23.     // 入参参数比Test1的a方法多一个，接口方法的第一个参数恰巧是调用引用方法的对象
  24.     void d(Test1 b);
  25.     //void d(int b); 这个会报错
  26. }

Demo2

  1. class Test1
  2. {
  3.     public void a(int param1, int param2)
  4.     {
  5.         System.out.println("just a test");
  6.     }
  8.     public static void main(String[] args)
  9.     {
  11.         MyInter m = Test1::a;
  12.     }
  13. }
  15. @FunctionalInterface
  16. interface MyInter
  17. {
  18.     //该接口参数比上述的a方法参数数量多一个，除去第一个，其它类型一致(可兼容，如可以一个int,一个Integer)
  19.     //且 interface 中 虚函数的一个参数一定是 引用方法所在类 类型
  20.     void d(Test1 d, int param1, int param2);
  21. }

Demo3

  1. class Father
  2. {
  3.     public void a(Integer param1, int param2)
  4.     {
  5.     }
  6. }
  7. ==========================================
  8. class Son extends Father
  9. {
  11.     public static void main(String[] args)
  12.     {
  13.         MyInter m = Son::a;  //  这个是不对的！
  14.         m.fun(new Son(), 12, 13); // 实参  需要是 形参的同类或者子类
  15.     }
  16. }
  18. @FunctionalInterface
  19. interface MyInter
  20. {
  21.     //该接口参数比上述的a方法参数数量多一个，除去第一个，其它类型一致(可兼容，如可以一个int,一个Integer)
  22.     // interface 虚函数第一个参数 类型
  23.     void fun(Father d, int param1, int param2);
  24. }
  26. ==========================================
  27. class Son extends Father
  28. {
  29.     public static void main(String[] args)
  30.     {
  31.         MyInter m = Father::a; // 该类要是 interface 中的同类或父类
  32.         m.fun(new Son(), 12, 13); // 实参  需要是 形参的同类或者子类
  33.     }
  34. }
  36. @FunctionalInterface
  37. interface MyInter
  38. {
  39.     //该接口参数比上述的a方法参数数量多一个，除去第一个，其它类型一致(可兼容，如可以一个int,一个Integer)
  40.     /*
  41.         interface第一个参数    引用函数类型    状态
  42.         Father            Father        OK
  43.         Son            Son        OK
  44.         Son             Father         OK
  45.         Father            Son        NO
  46.     * */
  47.     void fun(Son d, int param1, int param2);
  48. }

demo4

  1. class Test1
  2. {
  3.     public void a(Integer param1, int param2)
  4.     {
  5.     }
  7.     public static void main(String[] args)
  8.     {
  9.         MyInter m = (j, k, l) -> j.a(k, l);
  10.        //第一个参数为方法目标，其余参数为参数
  11.     }
  12. }
  14. @FunctionalInterface
  15. interface MyInter
  16. {
  17.     void d(Test1 d, int param1, int param2);
  18. }

这个指向任意类型实例方法的方法引用有两个要求：
方法的引用 - 图7第一点：接口方法(interface)的参数比引用方法的参数多一个
方法的引用 - 图8第二点：接口方法的第一个参数恰巧是调用引用方法的对象,或者是引用方法类型的子类。

interface第一个参数 引用函数类型 状态是否正确
Father Father OK
Son Son OK
Son Father OK
Father Son NO

4、构造方法引用

构造方法引用又分构造方法引用和数组构造方法引用。
构造函数的方法引用，它们是对象初始化方法。

使用构造函数的方法引用的主要步骤有：
方法的引用 - 图9 1. 定义一个只有抽象方法的函数式接口，该interface 中抽象方法的返回类型与使用该对象进行构造函数引用的对象相同。
方法的引用 - 图10 2. 创建一个类，该类的构造函数与函数式接口的抽象方法匹配。
方法的引用 - 图11 3. 使用对步骤#2中定义的构造函数的方法引用，实例化函数式接口的实例。（构造函数的方法引用格式为 类名::new）
方法的引用 - 图12 4. 在步骤#2中使用构造函数引用实例化类的实例。

构造函数引用与泛型一起使用时会变得更有用。通过使用泛型工厂方法，可以创建各种类型的对象。
可以结合下面例子重点理解下思想

4.1.构造方法引用（也可以称作构造器引用）

组成语法格式：Class::new

构造函数本质上是静态方法，只是方法名字比较特殊，使用的是new 关键字。

例子：

String::new， 等价于lambda表达式 () -> new String()

  1. package mytest;
  3. interface MyFunc1
  4. {
  6.     MyClass func(int n);
  7.     // 会有个类的构造方法来实现该函数
  9. }
  11. class MyClass
  12. {
  14.     private int val;
  16.     MyClass(int v)
  17.     {
  18.         val = v;
  19.     }
  21.     MyClass()
  22.     {
  23.         val = 0;
  24.     }
  26.     public int getValue()
  27.     {
  28.         return val;
  29.     }
  31. }
  33. public class CRacer
  34. {
  35.     public static void main(String[] args)
  36.     {
  38.         MyFunc1 myClassCons1 = MyClass -> new MyClass();
  39.         // 跟下面同样效果  相当于用构造函数 实现了interface 的 虚函数 切记
  40.         MyFunc1 myClassCons = MyClass::new;
  41.         // 等价于 MyFunc1 myClassCons = new MyClass();
  42.         MyClass mc = myClassCons.func(100);
  43.         System.out.println("val in mc is: " + mc.getValue());
  44.     }
  46. }

4.2.数组构造方法引用

组成语法格式：TypeName[]::new
例子：

int[]::new 是一个含有一个参数的构造器引用，这个参数就是数组的长度。等价于lambda表达式 x -> new int[x]。
假想存在一个接收int参数的数组构造方法

  1. IntFunction<int[]> arrayMaker = int[]::new;
  2. int[] array = arrayMaker.apply(10) // 创建数组 int[10]
  1. package mytest;
  3. import java.util.function.Function;
  5. interface MyFunc1
  6. {
  7.     MyClass func(int n);
  8.     // 会有个类的构造方法来实现该函数
  9. }
  11. class MyClass
  12. {
  14.     private int val;
  16.     MyClass(int v)
  17.     {
  18.         val = v;
  19.     }
  21.     MyClass()
  22.     {
  23.         val = 0;
  24.     }
  26.     public int getValue()
  27.     {
  28.         return val;
  29.     }
  31. }
  33. public class CRacer
  34. {
  35.     public static void main(String[] args)
  36.     {
  38.         MyFunc1 myClassCons1 = MyClass -> new MyClass();
  39.         // 跟下面同样效果  相当于用构造函数 实现了interface 的 虚函数 切记
  40.         MyFunc1 myClassCons = MyClass::new;
  41.         // 等价于 MyFunc1 myClassCons = new MyClass();
  42.         MyClass mc = myClassCons.func(100);
  43.         System.out.println("val in mc is: " + mc.getValue());
  45.         /*
  46.         * 数组引用的创建 第一个参数是传入数组长度，第二个参数是传入数组类型， 真正实例化的时候跟  Scala 中 apply 类似来构造
  47.         * 多看源码即可理解思路
  48.         * */
  49.         Function<Integer, String[]> function = (x) -> new String[x];
  50.         Function<Integer, String[]> functionNew = String[]::new;
  51.         String[] abc = function.apply(12);
  52.         System.out.println(function.apply(12).length + functionNew.apply(33).length);
  53.     }
  55. }

挺好的一个例子参考：

  1. package mytest;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. @FunctionalInterface
  7. interface Supplier<T>
  8. {
  9.     T get();
  10. }
  12. class Car
  13. {
  14.     public static Car create(final Supplier<Car> supplier)
  15.     {
  16.         return supplier.get();
  17.     }
  19.     public static void collide(final Car car)
  20.     {
  21.         System.out.println("静态方法形式调用 " + car.toString());
  22.     }
  24.     public void follow(final Car another)
  25.     {
  26.         System.out.println("对象方法形式调用 " + another.toString());
  27.     }
  29.     public void repair()
  30.     {
  31.         System.out.println("任意对象方法引用 " + this.toString());
  32.     }
  34.     @Override
  35.     public String toString()
  36.     {
  37.         return "just a Car " + this.hashCode();
  38.     }
  39. }
  41. public class CRacer
  42. {
  43.     public static void main(String[] args)
  44.     {
  45.         //构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
  46.         final Car car = Car.create(Car::new);
  47.         System.out.println(car.hashCode());
  48.         final List<Car> cars = Arrays.asList(car);
  50.         //静态方法引用：它的语法是Class::static_method，实例如下：
  51.         cars.forEach(Car::collide);
  53.         //特定类的任意对象的方法引用：它的语法是Class::method实例如下：
  54.         cars.forEach(Car::repair);
  55.                 cars.forEach(System.out::println); 
  56.         //  forEach 应该接受的要是cars的父类，而我们传入的函数 
  57.           //   println 是 Object 是所以类型的父类 因此可以执行。 再理解下 多态
  59.         //特定对象的方法引用：它的语法是instance::method实例如下：
  60.         final Car police = Car.create(Car::new);
  61.         System.out.println(police.hashCode());
  62.         cars.forEach(police::follow);
  63.     }
  64. }

转载：【Java8】 方法引用 讲解