jdk8新特性（Lambda表达式)）-第一阶段-第二十三天

Lambda表达式

1.概念

1. JAVA8提供的一个非常优秀的新特性，从本质上来说Lambda表达式是一个遵循某一个接口规范（方法的形参、方法的返回类型）的匿名方法，提供了在JAVA中进行接口实现的一种简便形式，精简了代码的编写
2. Lambda表达式一定是基于某个具体的接口规范来编写的，这个接口必须是一个函数式接口。
3. 函数式接口：接口中只能有且只有一个必须被子类实现的抽象方法，默认方法不需要强制子类实现
4. 函数式专用注解@FunctionalInterface

2. 八大函数式接口

最常用的四大函数式接口都是定义在java.util.function包中

1. Consumer 消费型的：里面定义了一个有参无返回的抽象方法 void accept(T t);//方法体;
2. Predicate 断言型 里面定义了一个方法boolean test(T t); 接收一个参数并对其判断返回一个boolean值;
3. Function 函数型 里面定义一个抽象方法R apply(T t); 接收一个任意类型的参数并返回一个任意类型的结果;
4. Supplier 供给型函数式接口 里面定义一个方法T get(); 无参有返回;

lambda表达式常用的八大函数式接口

1 Consumer : 接收一个参数，没有返回值，例如：list的遍历
2 BiConsumer<T, E>: 接收两个参数，没有返回值，例如：Map的遍历
3 Function<T, R>: 接收一个参数 T，返回一个值 R. 
(UnaryOperator<T> 接受一个对象，返回一个相同的对象， 继承与Function)
4 BiFunction<T, E, R>: 接收两个参数 T、E，返回一个值 R. 
5 BinaryOperator: 它继承了 BiFunction 接口，接收两个参数 T、T，返回一个值 T. 
6 Predicate: 谓词(断言)，接口一个值 T, 返回一个boolean。
7 Supplier: 没有参数，返回一个 T.
8 Comparator: 比较，接收两个值 T, T， 返回 int类型。

3.Lamdba表达式使用方法

package com.qianfeng.day21;

import java.util.function.*;

public class Test01 {

	public static void main(String[] args) {
		//消费型
		Consumer<String> con = (str)->{System.out.println(str);};
		//断言型
		Predicate<Integer> pre = (flag)->{return flag>=10;};
		//函数型
		Function<String,String> fun = (std)->"abc"+std;
		//供给型
		Supplier<String> sup = ()->"我是第四个";
		
		con.accept("哈哈哈");
		System.out.println(pre.test(50));
		System.out.println(fun.apply("dddd"));
		System.out.println(sup.get());
	}
}

4.Lambda表达式简写

1. 参数的简写：参数的类型已经在相应的接口中约束好了，可以不指定，如果只要一个形参则（）可以省略不写，如果参数个数为0或者超过一个不能省略小括号。
2. 方法体中如果只有一条语句，则方法体的{}可以省略不写，如果这条语句是一个return语句则return 可以省略，并且将最后的;省略

5.Lambda表达式的另一种书写形式（方法引用）

语法：

1. 如果我们接口引用的是一个类的静态方法则语法为：类名::静态方法名;
2. 如果我们引用的是一个非静态的方法 则语法为：对象名::实例方法名;
3. 如果接口方法的第一个参数恰巧是调用引用方法的对象：类名::实例方法名
4. 可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象：类名::new

使用代码举例

package com.qianfeng.day21;

import java.util.function.*;

public class Test01 {

	public static void main(String[] args) {
		//消费型
		Consumer<String> con = (str)->{System.out.println(str);};
		//断言型
		Predicate<Integer> pre = (flag)->{return flag>=10;};
		//函数型
		Function<String,String> fun = (std)->"abc"+std;
		//供给型
		Supplier<String> sup = ()->"我是第四个";
		
		con.accept("哈哈哈");
		System.out.println(pre.test(50));
		System.out.println(fun.apply("dddd"));
		System.out.println(sup.get());
		
		
		Student stu = new Student("zhangsan");
		
		//方法引用的第一种方式 对象名::实例方法名
		stu.setName("hhhhh");
		Function<Student,String> f = str->stu.apply(stu);
		Function<Student,String> f1 = stu::apply;
		System.out.println(f.apply(stu));
		System.out.println(f1.apply(stu));
		
		Consumer<String> c1 = str->{System.out.println(str);};
		Consumer<String> c2 = str->stu.setName(str);
		
		Consumer<String> c3 = System.out::println;
		Consumer<String> c4 = stu::setName;
		
		c1.accept("hello c1对象");
		c3.accept("hello c2对象");
		
		c2.accept("zhangsan");
		System.out.println(stu.getName());
		c4.accept("lisi");
		System.out.println(stu.getName());
		
		//方法引用的第二种方式 类名::静态方法名
		Consumer<String> c5 = str->{Student.sayHello(str);};
		Consumer<String> c6 = Student::sayHello;
		
		c5.accept("我是方法c5");
		c6.accept("我是方法c6");
		
		//方法引用的第三种方式 类名::实例方法名
		Function<Student,String> f3 = student->student.getName();
		Function<Student,String> f4 = Student::getName;
		
		System.out.println(f3.apply(stu));
		System.out.println(f4.apply(stu));
		
		//方法引用的第四种方式 类名::构造方法
		Function<String,Student> f5 = name->new Student(name);
		Function<String,Student> f6 = Student::new;
		
		Student stu1 = f5.apply("zhaoliu");
		Student stu2 = f6.apply("tianqi");
		System.out.println(stu1.getName());
		System.out.println(stu2.getName());
		
		Tempinterface<String,Student> i1 = (n)->new Student(n[1],n[2]);
		//通过可变参数类型的话就不可用第四种方式
		//Tempinterface<String,Student> i2 = Student::new;
		String a = "",b = "",c = "",d = "";
		aaaa(a,b,c,d);
	}
	
	public static void aaaa(String... strings) {
		System.out.println(strings.length);
	}
}

@FunctionalInterface
interface Tempinterface<T,R>{
	
	@SuppressWarnings("unchecked")
	R gouzao(T... ts);
	
	
}