函数式接口：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，可以通过Lambda表达式节创建该接口的对象。
使用Lambda表达式：避免匿名内部类定义过多、可以让代码看起来更简洁、去掉了一对没有意义的代码只留下了核心的逻辑
原来：
package Lambda;
public class TestLambda1 {
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
}
}
//1、定义一个函数式接口
interface ILike{
void lambda();
}
//2、实现类
class Like implements ILike {
public void lambda(){
System.out.println("I like lambda");
}
}
通过匿名内部类简化：
package Lambda;
public class TestLambda1 {
public static void main(String[] args) {
ILike like = new ILike(){
public void lambda(){
System.out.println("I like lambda");
}
};
like.lambda();
}
}
//1、定义一个函数式接口
interface ILike{
void lambda();
}
通过Lambda表达式进一步简化：
package Lambda;
public class TestLambda1 {
public static void main(String[] args) {
ILike like = ()->{
System.out.println("I like lambda");
};
like.lambda();
}
}
//1、定义一个函数式接口
interface ILike{
void lambda();
}
总结：对于只包含一个抽象方法的接口，就可以用Lambda表达式简化代码创建对象
进一步省略：
ILike like = ()->System.out.println("I like lambda");
函数式接口指的是有且只有一个抽象方法的接口，但是也可以有其他的方法(默认、静态、私有)。
可以添加@FunctionalInterface注解，作用是检测一个接口是否是函数式接口
函数式接口一般可以作为方法的参数和返回值类型
作为方法的参数：
package Lambda;
public class TestLambda1 {
public static void show(MyFunctionalInterface myInter){
myInter.method();
}
public static void main(String[] args) {
show(()->System.out.println("重写接口中的方法"));
}
}
@FunctionalInterface
interface MyFunctionalInterface{
public void method();
}
作为方法的返回值类型：可以直接返回一个Lambda表达式
package Lambda;
import java.util.Arrays;
import java.util.Comparator;
public class TestLambda1 {
public static Comparator<String> getComparator(){
return (o1,o2) -> o2.length()-o1.length();
}
public static void main(String[] args) {
String[] arr = {"aaa","b","cccccc","dddddddddd"};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr,getComparator());//按照长度排序
System.out.println(Arrays.toString(arr));
}
}
java.util.function.Supplier< T >接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要向外提供一个符合泛型类型的对象数据。这个接口被称为生产型接口，即指定接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据。
样例：
package Lambda;
import java.util.function.Supplier;
public class DemoSupplier {
public static String getString(Supplier<String> sup){
return sup.get();
}
public static void main(String[] args) {
String s = getString(()->"胡歌");
System.out.println(s);
}
}
练习：使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。
package Lambda;
import java.util.function.Supplier;
public class DemoSupplier {
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
public static void main(String[] args) {
int[] arr = {100,0,0-50,88,99,33,-30};
int maxValue = getMax(()->{
int max = arr[0];
for(int i :arr){
if(i > max)
max = i;
}
return max;
});
System.out.println(maxValue);
}
}
java.util.function.consumer< T >接口正好与Supplier接口相反，它消费一个数据，其数据类型由泛型决定。它包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
accept()方法的使用：
package Lambda;
import java.util.function.Consumer;
public class DemoConsumer {
public static void method(String name , Consumer<String> con){
con.accept(name);
}
public static void main(String[] args) {
method("赵丽颖",(String name)->{
//消费方式：把字符串进行翻转输出
String reName = new StringBuffer(name).reverse().toString();
System.out.println(reName);
});
}
}
Consumer接口中的默认方法andThen：如果一个方法的参数和返回值都是Consumer类型，那么就可以实现消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。这个方法就是由andThen实现的。要向实现组合，需要两个或者多个Lambda表达式即可，而andThen语义正是一步接一步操作。例如：
Consumer<String> con1
Consumer<String> con2
String s = "hello";
con1.accept(s);
con2.accept(s);
可以用andThen来进行连接，再进行消费，谁写前面谁先消费，所以下面是con1先进行消费：
con1.andThen(con2).accept(s);
第一种方式：
第一种方式：
package Lambda;
import java.util.Locale;
import java.util.function.Consumer;
public class DemoConsumer {
public static void method(String s , Consumer<String> con1 , Consumer<String> con2){
con1.accept(s);
con2.accept(s);
}
public static void main(String[] args) {
method("hello",
(t)->{
System.out.println(t.toUpperCase());
},
(t)->{
System.out.println(t.toLowerCase());
});
}
}
第二种方式：用andThen进行连接
package Lambda;
import java.util.Locale;
import java.util.function.Consumer;
public class DemoConsumer {
public static void method(String s , Consumer<String> con1 , Consumer<String> con2){
con1.andThen(con2).accept(s);
}
public static void main(String[] args) {
method("hello",
(t)->{
System.out.println(t.toUpperCase());
},
(t)->{
System.out.println(t.toLowerCase());
});
}
}
练习：下面的字符串数组中存有多条信息，请按照格式“姓名：XX，性别：XX”的格式将信息打印出来，要求将打印姓名的动作作为第一个Consumer接口的Lambda实例，将打印性别的动作作为第二个Consumer接口的Lambda实例，将两个Consumer接口按照顺序拼接到一起：
package Lambda;
import java.util.Locale;
import java.util.function.Consumer;
public class DemoConsumer {
public static void printInfo(String[] arr , Consumer<String> con1 , Consumer<String> con2){
for(String message : arr){
con1.andThen(con2).accept(message);
}
}
public static void main(String[] args) {
String[] arr = {"迪丽热巴,女","古力娜扎,女","马尔扎哈,男"};
printInfo(arr,(message)->{
String name = message.split(",")[0];
System.out.print("姓名："+name+",");
},(message)->{
String gender = message.split(",")[1];
System.out.println("性别："+gender);
});
}
}
有时候我们需要对某种数据的类型进行判断，从而得到一个boolean值结果。这是可以用java.util.function.Predicate< T >接口。
抽象方法test()：
package Lambda;
import java.util.function.Predicate;
public class DemoPredicate {
public static boolean checkString(String s , Predicate<String> pre){
return pre.test(s);
}
public static void main(String[] args) {
String s = "abcdef";
//对参数传递的字符串进行判断，判断字符串长度是否大于5
boolean b = checkString(s,str->str.length()>5);
System.out.println(b);
}
}
既然是条件判断，那么就会存在与或非三种逻辑。
与逻辑：默认方法and()
package Lambda;
import java.util.function.Predicate;
public class DemoPredicate {
/*
定义一个方法，方法的参数，传递一个字符串，两个Predicate接口
一个用于判断字符串长度是否大于5
一个用于判断字符串中是否包含a
两个条件必须同时满足
*/
public static boolean checkString(String s , Predicate<String> pre1 , Predicate<String> pre2){
return pre1.and(pre2).test(s);
}
public static void main(String[] args) {
String s = "bcdeff";
boolean b = checkString(s,(String str)->{
return str.length()>5;
},(String str)->{
return str.contains("a");
});
System.out.println(b);
}
}
或逻辑：默认方法or()
package Lambda;
import java.util.function.Predicate;
public class DemoPredicate {
/*
定义一个方法，方法的参数，传递一个字符串，两个Predicate接口
一个用于判断字符串长度是否大于5
一个用于判断字符串中是否包含a
满足一个条件即可
*/
public static boolean checkString(String s , Predicate<String> pre1 , Predicate<String> pre2){
return pre1.or(pre2).test(s);
}
public static void main(String[] args) {
String s = "bcdeff";
boolean b = checkString(s,(String str)->{
return str.length()>5;
},(String str)->{
return str.contains("a");
});
System.out.println(b);
}
}
非逻辑：negate()
package Lambda;
import java.util.function.Predicate;
public class DemoPredicate {
/*
定义一个方法，方法的参数，传递一个字符串，一个Predicate接口
如果字符串长度大于5，则返回false
如果字符串长度不大于5，则返回true
*/
public static boolean checkString(String s , Predicate<String> pre){
return pre.negate().test(s);
}
public static void main(String[] args) {
String s = "bcdeff";
boolean b = checkString(s,str->str.length()>5);
System.out.println(b);
}
}
java.util.function.Function< T , R >接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。将T的数据类型转换为R的数据类型
抽象方法R apply(T t)，根据类型T的参数获取类型R的结果
package Lambda;
import java.util.function.Function;
public class DemoFunction {
/*
定义一个方法
方法的参数传递一个字符串类型的证书
方法的参数传递一个Function接口，泛型使用<String,Integer>
使用Function接口中的方法apply，把字符串类型的整数转换为Integer类型
*/
public static void change(String s , Function<String,Integer> fun){
int in = fun.apply(s);
System.out.println(in);
}
public static void main(String[] args) {
String s = "1234";
change(s,str->Integer.parseInt(s));
}
}
默认方法andThen：进行组合操作
package Lambda;
import java.util.function.Function;
public class DemoFunction {
/*
需求：把String类型的“123”转换为Integer类型，把转换后的结果加10
把增加之后的Integer类型的数据转换为String类型
分析：转换了两次
第一次是Function<String,Integer> fun1：
Integer i = fun1.apply("123")+10
第二次是Function<Integer,String> fun2:
String s = fun2.apply(i)
我们可以使用andThen方法将两次转换组合在一起使用
String s = fun1.andThen(fun2).apply("123")
*/
public static void change(String s , Function<String,Integer> fun1 , Function<Integer,String> fun2){
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
public static void main(String[] args) {
String s = "123";
change(s,str->Integer.parseInt(str)+10,i->i+"");
}
}