Java中Lambda表达式与方法引用

内部类

内部类

匿名内部类

Java匿名类，Java匿名内部类 (biancheng.net)
匿名类是一个表达式，匿名类的语法就类似于调用一个类的构建函数（new HelloWorld()），除些之外，还包含了一个代码块，在代码块中完成类的定义。主要针对接口类和抽象类，对于普通类可直接new实例，匿名构造就没有意义。

匿名内部类主要用来对接口或抽象类进行一次性的实例化实现

实现接口，不必传入参数，只需实现接口方法

实现抽象类，可根据抽象类不同构造方法来传入必要的参数，同时可以重写抽象类方法

使用目的：匿名内部类这一语法适用于创建一次性使用的类。

使用前提：存在抽象类或接口带实现

语法格式为：

new 实现接口() | **父类构造器 (实参列表)**{

//匿名内部类的类体部分

}

从这一定义可以看出，使用匿名内部类需要注意两点：

匿名内部类不能为抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的实例。

匿名内部类无法定义构造器。因为匿名内部类不存在类名，所以也就无从定义构造器。不过也可以通过定义初始化块来完成构造器需要完成的工作。
而最常见的匿名内部类的应用场合为： 需要通过实现接口来创建匿名内部类。

举个例子：

interface ProductInformationList {

  int getNumber();

  String getName();

}

public class AnonymousClassTest{

  public void test (ProductInformationList pil) {

    System.out.println("产品数量是： "+
      pil.getNumber()+"产品名称是 "+pil.getName());

  }

  public static void main(String[] args) {

​    AnonymousClassTest ac = new AnonymousClassTest();

​    //调用test()方法，需要传入一个ProductInformationList参数

​    //此处传入其匿名实现类的实例

​    ac.test(new ProductInformationList()

​    {

​      public int getNumber()

​      {

​        return 4;

​      }

​      public String getName()

​      {

​        return "电脑";

​      }

});

  }

}

如果这个接口实现类的对象会被重复使用的话，则可以将此实现类定义为一个独立的类；

但是现在只需要使用一次，所以就采用上述方法，定义一个匿名内部类。

因为匿名内部类不能是抽象类，所以必须要实现抽象父类或者接口中定义的全部抽象方法。

如果通过实现接口来创建匿名内部类，匿名内部类不能显式地创建构造器，所以匿名内部类只能有一个隐式的无参构造器。也就是说，new接口名后的括号里不能传入参数。

但是，如果是通过继承抽象父类来创建匿名内部类，则有：匿名内部类将拥有和父类拥有相同行参列表的构造器。

举个例子：

abstract class Person{

  private String name;

  public abstract double getHeight();

  //父类的构造器

  public Person(){}

  public Person(String name){

​    this.name = name;

  }

//私有成员变量name的setter和getter方法

  public void setName(String name){

​    this.name = name;

  }

  public String getName(){

​    return this.name;

  }

}

public class AnonyousInnerTest{

  public void test (Person p){

​    //%f表示格式化输出浮点数，.2表示保留到小数点后两位

​    //%s对应字符串

​    //%n表示换行

​    System.out.printf("姓名为%s;%n身高为%.2f;%n",

​      p.getName(),p.getHeight());

  }

  public static void main(String[] args) {

​    AnonyousInnerTest ait = new AnonyousInnerTest();

​    //调用有参数的构造器创建Person匿名实现类的对象

​    ait.test(new Person("图灵")

​    {

​      //实现抽象父类的抽象方法

​      public double getHeight(){

​        return 180.2;

​      }

​    });

//调用无参构造器创建Person匿名实现类的对象

​    Person p = new Person()

​    {

​      //初始化块

​      {

​        System.out.println(".........分割线.........");

​        System.out.println("匿名内部类的初始化块。。。");

​      }

​      //实现抽象方法

​      public double getHeight(){

​        return 170.4;

​      }

​      //重写父类实例方法

​      public String getName(){

​        return "人工智能";

​      }

​    };

​    ait.test(p);

  }

}

也就是说，创建匿名内部类时，必须实现接口或抽象父类中的所有抽象方法。

另外，如果有必要的话，也可以重写父类中的普通方法

匿名类有如下特点：

1）匿名类和局部内部类一样，可以访问外部类的所有成员。如果匿名类位于一个方法中，则匿名类只能访问方法中 final 类型的局部变量和参数。

public static void main(String[] args) {

   int a = 10;

   final int b = 10;

   Out anonyInter = new Out() {

   void show() {

   // System.out.println("调用了匿名类的 show() 方法"+a); // 编译出错

   System.out.println("调用了匿名类的 show() 方法"+b); // 编译通过

​     }

   };

   anonyInter.show();

 }

注意，若使用JDK1.8，方法中内部类的方法是可以直接访问外部类的方法的局部变量，并且不需要声明为final类型。

2）匿名类中允许使用非静态代码块进行成员初始化操作。

3）匿名类的非静态代码块会在父类的构造方法之后被执行。

匿名内部类的格式和理解

A：匿名内部类

就是内部类的简化写法。

B：前提：存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

匿名内部类，意思就是没有名字。没有名字就需要想办法表示它。

怎么表示它呢？就是要实现一个接口或者继承一个类。

必须要和外面的某个接口或者某个类产生关系，这才是匿名内部类。

C：格式

new 类名或者接口名(){

重写方法;

}

D：本质是什么呢?

是一个继承了该类或者实现了该接口的子类匿名对象。

Lambda表达式：实现函数式接口

参考文献：https://www.cnblogs.com/three-fighter/p/13326627.html#java-lambdas%E5%92%8C%E5%87%BD%E6%95%B0%E5%BC%8F%E6%8E%A5%E5%8F%A3

函数式接口：

只定义了一个待实现方法的接口称为函数式接口

Lambda 表达式的结

(arg1, arg2...) -> { body }

• 一个 Lambda 表达式可以有零个或多个参数
• 参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
• 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
• 空圆括号代表参数集为空。例如：() -> 42
• 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a
• Lambda 表达式的主体可包含零条或多条语句
• 如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
• 如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

函数式接口匹配Lambda表达式

单个抽象方法接口有时也称为函数式接口。@FunctionalInterface 是 Java 8 新加入的一种注解，用于指明该接口类型声明是根据 Java 语言规范定义的函数式接口

将Java lambda表达式与函数式接口进行匹配需要以下步骤：

• 接口是否只有一个抽象方法？
• lambda表达式的参数是否与抽象方法的参数匹配？
• lambda表达式的返回类型是否与抽象方法的返回类型匹配？

如果这三个条件都满足，则该接口可以匹配给定的lambda表达式。

从Java 8开始，Java接口可以包含默认方法和静态方法。默认方法和静态方法都可以在接口中直接实现。这意味着，Java lambda表达式可以实现带有默认方法和静态方法的接口——只要该接口仅有一个抽象方法即可。

Lambda表达式 vs 匿名接口实现

即使lambda表达式接近匿名接口实现，但也有一些区别需要注意。

最主要的区别，匿名接口实现可以具有状态（成员变量），而lambda表达式则不能。

看一下下面这个接口：

public interface MyEventConsumer {

public void consume(Object event);

}

可以使用匿名接口实现方式来实现此接口，如下所示：

MyEventConsumer consumer = new MyEventConsumer() {

public void consume(Object event){

System.out.println(event.toString() + " consumed");

}

};

此匿名MyEventConsumer实现可以具有自己的内部状态。

重写匿名接口实现：

MyEventConsumer myEventConsumer = new MyEventConsumer() {

private int eventCount = 0;

public void consume(Object event) {

System.out.println(event.toString() + " consumed " + this.eventCount++ + " times.");

}

};

请注意，匿名MyEventConsumer接口实现现在具有一个名为eventCount的属性。

Lambda表达式不能具有此类属性。因此，lambda表达式是无状态的。

Lambda类型推断

在Java 8之前，在进行匿名接口实现时，必须指定要实现的接口。这是本文开头的匿名接口实现示例：

stateOwner.addStateListener(new StateChangeListener() {

 

public void onStateChange(State oldState, State newState) {

*// do something with the old and new state.*

}

});

使用lambda表达式时，通常可以从相关的代码中推断出类型。例如，可以从addStateListener()方法（StateChangeListener接口上的抽象方法）的方法声明中推断参数的接口类型。

这称为类型推断。编译器通过在其他地方寻找类型来推断参数的类型——在这种情况下为方法定义。这是本文开头的示例，lambda表达式中并未声明参数的类型：

stateOwner.addStateListener(

(oldState, newState) -> System.out.println("State changed")

);

在lambda表达式中，通常可以推断参数类型。在上面的示例中，编译器可以从onStateChange()方法声明中推断其类型。因此，从onStateChange()方法的方法声明中就可以推断出参数 oldState 和 newState 的类型。

Lambda参数

无参数

如果lambda表达式匹配的方法无参数，则可以这样写lambda表达式：

() -> System.out.println("Zero parameter lambda");

请注意，括号中没有内容。那就是表示lambda不带任何参数。

一个参数

如果Java lambda表达式匹配的方法有一个参数，则可以这样写lambda表达式：

(param) -> System.out.println("One parameter: " + param);

请注意，参数在括号内列出。

当lambda表达式是单个参数时，也可以省略括号，如下所示：

param -> System.out.println("One parameter: " + param);

多个参数

如果Java lambda表达式匹配的方法有多个参数，则需要在括号内列出这些参数。代码如下：

(p1, p2) -> System.out.println("Multiple parameters: " + p1 + ", " + p2);

仅当方法是单个参数时，才可以省略括号。

指定参数类型

如果编译器无法从lambda匹配的函数式接口抽象方法推断参数类型，则有时可能需要为lambda表达式指定参数类型。不用担心，编译器会在这种情况下会有提醒。这是一个Java lambda指定参数类型示例：

(Car car) -> System.out.println("The car is: " + car.getName());

如你所见，car参数的类型（Car）写在参数名称的前面，就像在其他方法中声明参数或对接口进行匿名实现时一样。

Lambda表达式主体

lambda表达式的主体以及它表示的函数/方法的主体在lambda声明中的->的右侧指定：

这是一个示例：

(oldState, newState) -> System.out.println("State changed")

如果你的lambda表达式需要包含多行，则可以将lambda函数主体括在{}括号内，Java在其他地方声明方法时也需要将其括起来。这是一个例子：

(oldState, newState) -> {

	System.out.println("Old state: " + oldState);

	System.out.println("New state: " + newState);

}

Lambda表达式返回值

你可以从Java lambda表达式返回值，就像从方法中返回值一样。你只需向lambda表达式主体添加一个return，如下所示：

(param) -> {

System.out.println("param: " + param);

return "return value";

}

如果你的lambda表达式只需要计算一个返回值并将其返回，则可以用更短的方式指定返回值。例如这个：

(a1, a2) -> { return a1 > a2; }

你可以写成：

(a1, a2) -> a1 > a2;

然后，编译器会断定表达式 a1> a2 是lambda表达式的返回值。

Lambdas作为对象

Java lambda表达式本质上是一个对象。你可以将变量指向lambda表达式并传递，就像处理其他任何对象一样。这是一个例子：

public interface MyComparator {

public boolean compare(int a1, int a2);

}

MyComparator myComparator = (a1, a2) -> return a1 > a2;
boolean result = myComparator.compare(2, 5);

第一个代码块显示了lambda表达式实现的接口。

第二个代码块显示了lambda表达式的定义，lambda表达式如何分配给变量，以及最后如何通过调用其实现的接口方法来调用lambda表达式。

Lambda方法引用

参考文献：https://zq99299.github.io/java-tutorial/java/javaoo/methodreferences.html#%E6%96%B9%E6%B3%95%E5%BC%95%E7%94%A8%E7%9A%84%E6%96%B9%E5%BC%8F

方法引用：如果你的lambda表达式所做的只是用传递给lambda的参数调用另一个方法，则Java lambda实现提供了更简洁的方式表示该方法调用。

首先，这是一个函数式接口：

public interface MyPrinter{

  public void print(String s);

}

以下是创建实现MyPrinter接口的Java lambda表达式的示例：

MyPrinter myPrinter = (s) -> { System.out.println(s); };

由于lambda主体仅由一个语句组成，因此我们实际上可以省略括号{}。另外，由于lambda方法只有一个参数，因此我们可以省略该参数周围的括号()。更改之后的lambda表达式：

MyPrinter myPrinter = s -> System.out.println(s);

由于所有lambda主体所做的工作都是将字符串参数转发给System.out.println()方法，因此我们可以将上述lambda声明替换为方法引用。以下是lambda表达式引用方法的实例：

MyPrinter myPrinter = System.out::println;

注意双冒号::。它会向Java编译器发出信号，这是方法引用。引用的方法是双冒号之后的内容。拥有被引用方法的任何类或对象都在双冒号之前。

lambda 表达式创建匿名方法。然而，有时，lambda 表达式只能调用现有方法。在这些情况下，通过名称来引用现有的方法往往更为清楚。方法引用使您能够做到这一点; 对于已经有名称的方法，它们是紧凑的，易于阅读的 lambda 表达式

你可以引用以下类型的方法：

• 静态方法
• 参数对象的实例方法
• 实例方法
• 构造方法

静态方法引用

最容易引用的方法是静态方法。

首先是函数式接口的示例：

public interface Finder {

	public int find(String s1, String s2);

}

这是一个静态方法：

public class MyClass{

	public static int doFind(String s1, String s2){
			return s1.lastIndexOf(s2);
	}
}

最后是引用静态方法的Java lambda表达式：

Finder finder = MyClass::doFind;

由于Finder.find()和MyClass.doFind()方法的参数匹配，因此可以创建实现Finder.find()并引用MyClass.doFind()方法的lambda表达式。

参数方法引用: 引用第一个参数的方法，其余参数作为方法入参传入

也可以将其中一个参数的方法引用到lambda。

函数式接口如下：

public interface Finder {
	public int find(String s1, String s2);
}

该接口用于表示能在s1中搜索s2的出现的部分。下面是一个Java lambda表达式的示例，它调用indexOf() 搜索：

Finder finder = String::indexOf;

这等价以下lambda定义：

Finder finder = (s1, s2) -> s1.indexOf(s2);

Java编译器尝试将引用的方法与第一个参数类型相匹配，使用第二个参数类型作为被引用方法的参数。

实例方法引用

第三，还可以从lambda表达式中引用实例方法。

首先，让我们来看一个函数式接口定义：

public interface Deserializer {

	public int deserialize(String v1);

}

此接口表示一个组件，该组件能够将字符串“反序列化”为int。

现在看看这个StringConverter类：

public class StringConverter {
	public int convertToInt(String v1){
			return Integer.valueOf(v1);
	}
}

convertToInt()方法与Deserializer deserialize()方法的deserialize()方法具有相同的签名。因此，我们可以创建StringConverter的实例，并从Java lambda表达式引用其convertToInt()方法，如下所示：

StringConverter stringConverter = new StringConverter();

Deserializer des = stringConverter::convertToInt;

第二行创建的lambda表达式引用在第一行创建的StringConverter实例的convertToInt方法。

构造方法引用

最后，可以引用一个类的构造方法。你可以通过在类名后加上:: new来完成此操作，如下所示：

MyClass::new

来看看如何在lambda表达式中引用构造方法。

函数式接口定义如下：

public interface Factory {
	public String create(char[] val);
}

此接口的create()方法与String类中某个构造函数的签名匹配。因此，此构造函数可以被lambda表达式用到。下面是一个示例：

Factory factory = String::new;

等同于如下lambda表达式：

Factory factory = chars -> new String(chars);

Java8四大内置函数式接口

1、Consumer 消费性接口：void accept(T t)；

//有一个参数，并且无返回值

public static void test3() {

  //这个e就代表所实现的接口的方法的参数，

  Consumer<String> consumer = e->System.out.println("Lambda 表达式方式，"+e);

  consumer.accept("传入参数");

}

2、Supplier供给型接口： T get();

package javase.Lambda;

import java.util.ArrayList;

import java.util.function.Supplier;

public class Test2 {

  public static void main(String[] args) {

​    ArrayList<Integer> res = getNumList(10,()->(int)(Math.random()*100));

​    System.out.println(res);

  }

  public static ArrayList<Integer> getNumList(int num, Supplier<Integer> sup){

​    ArrayList<Integer> list = new ArrayList<>();

​    for (int i = 0; i < num; i++) {

​      Integer e = sup.get();

​      list.add(e);

​    }

​    return list;

  }

}

3、Function 函数式接口：R apply(T t);

package javase.Lambda;

import java.util.function.Function;

public class Test2 {

  public static void main(String[] args) {

​    String newStr = strHandler("abc",(str)->str.toUpperCase());

​    System.out.println(newStr);

​    newStr = strHandler(" abc ",(str)->str.trim());

​    System.out.println(newStr);

  }

  public static String strHandler(String str, Function<String,String>fun){

​    return fun.apply(str);

  }

}

4、Predicate 断言式接口：boolean test(T t);

package javase.Lambda;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.function.Predicate;

public class Test2 {

  public static void main(String[] args) {

​    List<String> list = Arrays.asList("hello","jiangshuying","lambda","www","ok","q");

​    List<String> ret = filterStr(list,(str)->str.length()>2);

​    System.out.println(ret);

  }

  public static List<String> filterStr(List<String> list, Predicate<String> pre){

​    ArrayList<String> arrayList = new ArrayList<>();

​    for(String str:list){

​      if(pre.test(str)) {

​        arrayList.add(str);

​      }

​    }

​    return arrayList;

  }

}