1、函数式接口
概念
函数式接口在Java中是指：有且仅有一个抽象方法的接口。
小贴士：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。
格式
只要确保接口中有且仅有一个抽象方法即可：
修饰符 interface 接口名称 {
//接口当中抽象方法的 public abstract 是可以省略的
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
@FunctionalInterface注解
与 @Override的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface 。该注解可用于一个接口的定义上：
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。
自定义函数式接口
对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：
public class FunctionalInterfaceDemo {
// 使用自定义的函数式接口作为方法参数
private static void doSomething(MyFunctionalInterface inter){
// 调用自定义的函数式接口方法
inter.method();
}
public static void main(String[] args) {
//调用使用函数式接口的方法
doSomething(()->{System.out.println("Lambda执行啦！");});
}
}
2、函数式编程
Lambda的延迟执行
@FunctionalInterface
public interface MyFunctionalInterface {
String method();
}
public class FunctionalInterfaceDemo {
// 使用自定义的函数式接口作为方法参数
private static void doSomething(int level, MyFunctionalInterface inter) {
// 调用自定义的函数式接口方法
if (level == 1) {
System.out.println(inter.method());
}
}
public static void main(String[] args) {
String m1 = "a";
String m2 = "b";
//调用使用函数式接口的方法
doSomething(1, () -> m1 + m2);
doSomething(2, () -> {
System.out.println("Lambda执行吗？");
return m1 + m2;
});
}
}
从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行，从而达到节省性能的效果。
使用Lambda作为参数和返回值
- 如果方法的参数类型是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。
public class FunctionalInterfaceDemo {
private static void startThread(Runnable task) {
new Thread(task).start();
}
public static void main(String[] args) {
startThread(() -> {
System.out.println(Thread.currentThread().getName() + "线程执行啦！");
});
}
}
- 如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。
public class FunctionalInterfaceDemo {
private static Comparator newComparator() {
//升序排列
return (a, b) -> a.length() - b.length();
}
public static void main(String[] args) {
String[] array = { "abc", "ab", "abcd" };
System.out.println(Arrays.toString(array));//[abc, ab, abcd]
Arrays.sort(array, newComparator());
System.out.println(Arrays.toString(array));//[ab, abc, abcd]
}
}
3、常用函数式接口
Supplier接口
java.util.function.Supplier
Supplier
public class Demo01Supplier {
//定义一个方法,方法的参数传递Supplier接口,泛型执行String,get方法就会返回一个String
public static String getString(Supplier sup){
return sup.get();
}
public static void main(String[] args) {
//调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
String s = getString(()->{
//生产一个字符串,并返回
return "胡歌";
});
System.out.println(s);
//优化Lambda表达式
String s2 = getString(()->"胡歌");
System.out.println(s2);
}
}
Consumer接口
java.util.function.Consumer
（1）抽象方法：accept
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
public class Demo01Consumer {
/*
定义一个方法
方法的参数传递一个字符串的姓名
方法的参数传递Consumer接口,泛型使用String
可以使用Consumer接口消费字符串的姓名
*/
public static void method(String name, Consumer con){
con.accept(name);
}
public static void main(String[] args) {
//调用method方法,传递字符串姓名,方法的另一个参数是Consumer接口,是一个函数式接口,所以可以传递Lambda表达式
method("赵丽颖",(String name)->{
//对传递的字符串进行消费
//消费方式:直接输出字符串
//System.out.println(name);
//消费方式:把字符串进行反转输出
String reName = new StringBuffer(name).reverse().toString();
System.out.println(reName);
});
}
}
（2）默认方法：andThen
如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。
要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。
public class Demo02AndThen {
//定义一个方法,方法的参数传递一个字符串和两个Consumer接口,Consumer接口的泛型使用字符串
public static void method(String s, Consumer con1 ,Consumer con2){
//con1.accept(s);
//con2.accept(s);
//使用andThen方法,把两个Consumer接口连接到一起,在消费数据
con1.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据,在执行con2消费数据
}
public static void main(String[] args) {
//调用method方法,传递一个字符串,两个Lambda表达式
method("Hello",
(t)->{
//消费方式:把字符串转换为大写输出
System.out.println(t.toUpperCase());
},
(t)->{
//消费方式:把字符串转换为小写输出
System.out.println(t.toLowerCase());
});
}
}
Predicate接口
需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate
（1）抽象方法：test
Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：
public class Demo01Predicate {
/*
定义一个方法
参数传递一个String类型的字符串
传递一个Predicate接口,泛型使用String
使用Predicate中的方法test对字符串进行判断,并把判断的结果返回
*/
public static boolean checkString(String s, Predicate pre){
return pre.test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s = "abcdef";
//调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式
boolean b = checkString(s,(String str)->{
//对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
return str.length()>5;
});
//优化Lambda表达式
boolean b = checkString(s,str->str.length()>5);
System.out.println(b);
}
}
（2）默认方法：and、or、negate
既然是条件判断，就会存在与、或、非三种常见的逻辑关系。
即：and、or、negate
public class Demo02Predicate_and_or_negate {
public static boolean checkString1(String s, Predicate pre1,Predicate pre2){
//等价于return pre1.test(s) && pre2.test(s);
return pre1.and(pre2).test(s);
}
public static boolean checkString2(String s, Predicate pre1,Predicate pre2){
//等价于return pre1.test(s) || pre2.test(s);
return pre1.or(pre2).test(s);
}
public static boolean checkString3(String s, Predicate pre){
//等效于return !pre.test(s);
return pre.negate().test(s);
}
public static void main(String[] args) {
//与：字符串长度大于5且包含a
boolean b1 = checkString1("abcdef", str -> str.length() > 5, str -> str.contains("a"));
System.out.println(b1);
//或：字符串长度大于5或包含a
boolean b2 = checkString2("abcdef", str -> str.length() > 5, str -> str.contains("a"));
System.out.println(b2);
//非：字符串长度大于5返回false
boolean b3 = checkString3("abcdef", str -> str.length() > 5);
System.out.println(b3);
}
}
Function接口
java.util.function.Function
（1）抽象方法：apply
Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。
使用的场景例如：将 String 类型转换为 Integer 类型。
public class Demo01Function {
/*
定义一个方法
方法的参数传递一个字符串类型的整数
方法的参数传递一个Function接口,泛型使用
使用Function接口中的方法apply,把字符串类型的整数,转换为Integer类型的整数
*/
public static void change(String s, Function fun){
//Integer in = fun.apply(s);
int in = fun.apply(s);//自动拆箱 Integer->int
System.out.println(in);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s = "1234";
//调用change方法,传递字符串类型的整数,和Lambda表达式
change(s,(String str)->{
//把字符串类型的整数,转换为Integer类型的整数返回
return Integer.parseInt(str);
});
//优化Lambda
change(s,str->Integer.parseInt(str));
}
}
（2）默认方法：andThen
Function 接口中有一个默认的 andThen 方法，用来进行组合操作。
该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：
public class Demo02Function_andThen {
/*
定义一个方法
参数串一个字符串类型的整数
参数再传递两个Function接口
一个泛型使用Function
一个泛型使用Function
*/
public static void change(String s, Function fun1,Function fun2){
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s = "123";
//调用change方法,传递字符串和两个Lambda表达式
change(s,(String str)->{
//把字符串转换为整数+10
return Integer.parseInt(str)+10;
},(Integer i)->{
//把整数转换为字符串
return i+"";
});
//优化Lambda表达式
change(s,str->Integer.parseInt(str)+10,i->i+"");
}
}