【Java学习笔记】9.5 Java中的Lambda表达式

Lambda表达式是从Java8版本开始增加的语法。Lambda表达式有利于实现函数式编程，简化开发。

9.5.1 Lambda表达式入门

Lambda表达式由三部分组成：参数列表、箭头(->),及一个表达式或语句块。其完整的语法格式如下：

(Type 1 param1 , Type 2 param2 , ... , Type N paramN , -> {
   statment1;
   		statment2;
   		// ........
   		return statmentM;
})

例如，对于以下方法：

public int add(int x,int y){
return x +y; 
}

可以改写成Lambda表达式：

(int x,int y) -> {return x+y};

Lambda表达式的特点是书写简练。下面几种语法是对他的简化。

1. 单语句写法 当Lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号 (int x ,int y ) -> x + y

2. 省略参数类型 Java是一个强类型语言，因此参数必须指定类型。但是如果编译器能够根据上下文推出Lambda表达式的参数类型，则不需要我们显示的指定参数类型。例如(x,y) - > x+y;

3. 单个参数 如果只有一个参数并可以被Java推断出类型，那么参数列表的括号也可以省略。例如c -> {return c.size();}

4. 无参数和返回值可以用Lambda表达式实现一个没有参数且返回值类型为void的方法。这时候的参数列表的括号不能省。例如() ->{System.out.println("Hello World");}

   Lambda表达式的返回值类型无需指定，编译器会自行判断。另外，Lambda表达式的参数可以使用修饰符及注解，如final、@NonNull等。
   Lambda表达式可以看做一个行为，利用Lambda表达式Java允许将行为传到函数里。在这之前，如果想将行为传入函数，仅有的选则就是使用匿名类。匿名类的定义较为啰嗦。有时会显得其中行为定义不够突出。
   Lambda表达式取代了匿名类，取消了模板。允许用函数式风格编写代码。这样有时可读性更好、表达更清晰。

9.5.2 Lambda表达式与函数式接口

函数式接口是Java为支持Lambda表达式引入的概念。函数式接口（Functional Interface，功能性接口），简单来说，是指仅包含一个方法的接口。Java标准库中的java.lang.Runnable和java.util.Comparator都是典型的函数式接口。

@FunctionalInterface
public interface Runnable{
public abstract void run();
}

@FunctionalInterface 是java提供的注解。这个注解是非必须的。只要接口符合函数式接口的标准（只包含一个方法的接口），虚拟机会自动进行判断。
但最好还是声明一下。防止团队其他成员再往接口里添加新的方法。

Java中的Lambda表达式无法单独出现，它需要传递给一个函数式接口。Lambda表达式的方法其实就是函数接口方法的实现。例如：
可以用一个Lambda表达式为一个函数式接口赋值。

Runnable r1 = () -> {System.out.println("Hello Lambda!");};

然后再赋值给一个Object

Object obj = r1;

一个Lambda表达式只有在显式的转换成一个函数式接口后才能被当做Object使用。

Object o = (Runnable)() - > { System.out.println("hi");}; //正确
---------------------------------------------------------------------------------
System.out.println(() ->{}); //正确

【实例1】创建一个叫ISay的函数式接口

1. 函数式接口

package lambda;

@FunctionalInterface 				//函数式接口注解
public interface ISay {				//自定义函数式接口
	public void say(String str);    //唯一的接口方法
}

2. 测试类

public class TestLambda {

	public static void main(String[] args) {
		//用Lambda函数实现了函数式接口中的方法
		ISay saysth = (String str) -> {System.out.println("You said:\""+str+"\"");};
		saysth.say("Hello World");	//调用已实现的接口方法
	}
}

TestLambda类没有实现接口ISay的代码，所以也不需要显示地实现say()方法。从而也没有专门实例化一个TestLambda类对象来调用其say()方法
如果不使用Lambda表达式，那么上述代码应该改写成如下形式：

public class TestLambda implements ISay{
	public static void main(String[] args){
		//实例化类并调用方法
		new TestLambda().say("Hello World");
	}
	@Override
	public void say(String str ){
	System.out.println("you said :\""+str+"\"");
}
}

9.5.3 方法引用与构造器引用

方法引用（Method References）也是从Java8版本开始增加的特性。书写形式：

类名::方法名

有时候Lambda表达式中花括号部分代码较多。这时可以把花括号中的代码写成一个有方法名的方法，然后在Lambda表达式中使用方法调用的形式。
【实例2】静态方法引用形式

package lambdaTest1;

import java.text.SimpleDateFormat;
import java.util.Date;

import lambda.ISay;

public class TestLambda2 {

	public static void main(String[] args) {
		//用Lambda函数实现了函数式接口中的方法
		// ISay saysth = (String str) -> {System.out.println("You said:\""+str+"\"");};
		ISay saysth = (String str) -> {
			TestLambda2.FormatWords(str);		//调用了FormatWords()方法
			};
			saysth.say("Hello World");			//调用接口方法
	}
	
	public static void FormatWords(String str) {//定义一个格式输出的静态方法
		//设置时间
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(df.format(new Date())); //输出时间
		System.out.println("You Said:\""+str+"\"");	
	}
}

10 ~ 12 行，可替换为

ISay saysth = TestLambda2:FormatWords

类型	示例
引用静态方法	ContainingClass::staticMethodName
引用某个对象的实例方法	ContainingObject::instanceMethodName
引用特定类型的任意对象方法	ContainingType::methodName
引用构造方法（构造器引用）	ClassName::new

【实例2】方法引用
Puppy.java

package example;

import java.time.LocalDate;

public class Puppy {
	public Puppy(String name,LocalDate birthday) {
		this.name = name;
		this.birthday = birthday;
	}
	String name;
	LocalDate birthday;
	
	public String getName() {
		return name;
	}
	
	public LocalDate gerBirthday() {
		return birthday;
	}
	
	//定义一个静态方法，比较两只狗的静态年龄
	
	public static int compareByAge(Puppy a , Puppy b) {
		return a.birthday.compareTo(b.birthday);
	}
	@Override
	public String toString() {
		return "Puppy["+ "name=" + name + ",birthday="+birthday+"+\n]";
	}
}

SortPuppy.java

package example;

import java.time.LocalDate;

public class Puppy {
	public Puppy(String name,LocalDate birthday) {
		this.name = name;
		this.birthday = birthday;
	}
	String name;
	LocalDate birthday;
	
	public String getName() {
		return name;
	}
	
	public LocalDate gerBirthday() {
		return birthday;
	}
	
	//定义一个静态方法，比较两只狗的静态年龄
	
	public static int compareByAge(Puppy a , Puppy b) {
		return a.birthday.compareTo(b.birthday);
	}
	@Override
	public String toString() {
		return "Puppy["+ "name=" + name + ",birthday="+birthday+"+\n]";
	}
}

接下来是一个引用特定类型的任意对象方法的例子。

package example;

import java.util.Arrays;

public class SortString {

	public static void main(String[] args) {
		String[] stringArray = {"Cocker","Akita","Beagle","Alaskan","Dachshund"};
		Arrays.sort(stringArray,String::compartTo);
		System.out.println(Arrays.asList(stringArray));
		}
}

【实例3】构造器引用
构造器引用也是一种方法引用，其引用的是构造方法。构造器引用只需要以new关键字作为引用名。格式：类名:new

IBirth.java

package IBirth;

import java.time.LocalDate;

import example.Puppy;

@FunctionalInterface
interface IBirth {
	Puppy born(String name , LocalDate birthday);
}

PuppyBirth.java

package IBirth;

import java.time.LocalDate;

import example.Puppy;

public class PuppyBirth {

	public static void main(String[] args) {
		
		IBirth puppy1 = (name,birthday)->new Puppy("Akita",LocalDate.of(2017,5,9));
		IBirth puppy2 = Puppy::new;

		System.out.println(puppy1.born("Akita", LocalDate.of(2017,5,9)));
		System.out.println(puppy2.born("Beagle", LocalDate.of(2016,5,9)));
	}

}

9.5.4 Lambda表达式与匿名内部类的练习和区别

Lambda表达式是匿名内部类的一种简化，因此他可以取代匿名内部类的作用。

• 相同点
  （1）Java中局部内部类和匿名内部类访问的局部变量必须由final修饰。匿名内部类和Lambda表达式一样，可以访问final的局部变量和外部类成员变量
  (2) 创建方法一样，都可以直接调用从接口中继承的默认方法

  • 不同点
    （1）匿名内部类可以为任意接口创建实例——不管有多少个抽象的方法，只要匿名内部类实现了所有的方法即可。但是Lambda表达式只能为函数式接口创建实例
    （2）匿名内部类可以为抽象类甚至普通类创建实例。但是Lambda表达式只能为函数式接口创建实例
    （3）匿名内部类实现的抽象方法体允许调用接口中的默认方法，但Lambda表达式的代码不允许调用接口中的默认方法