**
函数式接口
**
我们在使用lambda表达式的时候,有一个要求,就是接口中只有一个抽象方法。
函数式接口就是指有且仅有一个抽象方法的接口
函数式接口的作用就是用来简化编程模型
函数式接口的使用:作为方法的参数或者返回值
我们先定义一个函数式接口(也可以有其他非抽象的方法)
//FunctionalInterface是一个注解,检测这是不是一个函数式接口
@FunctionalInterface
public interface MyInterface {
public abstract void method();//一个抽象方法
}
定义好了函数式接口,我们先来看函数式接口作为参数的情况
//定义了一个方法,函数式接口作为方法的参数
public static void show(MyInterface myinter)
{
myinter.method();
}
主函数
public static void main(String[] args) {
show(()->{
System.out.println("Lambda表达式重写");
});
//使用Lambda表达式作为参数传递,前提是参数必须是一个函数式接口
}
结果
Lambda表达式重写
现在看一下函数式接口的第二种使用:把函数式接口作为方法的返回值
public static Comparator<String> getComparator()//函数式接口作为方法的返回值
{
return (o1,o2)->{
return o1.length()-o2.length();
};
//返回了这个方法的Lambda表达式,前提是返回值必须是一个函数式接口
}
主函数
String[] str= {"zzzzzzzzzzzzzzzzzzzzzzz","vvvvv","ddddd","eeeeeeeeeeeeee"};
Arrays.sort(str,getComparator());
System.out.println(Arrays.toString(str));
结果
[vvvvv, ddddd, eeeeeeeeeeeeee, zzzzzzzzzzzzzzzzzzzzzzz]
这就是函数式接口了,这最后说一句,使用匿名内部类也可以达到效果,只是要比Lambda表达式麻烦一点。
**
常用的的函数式接口
**
Supplier接口:
包含一个无参的get方法,指定接口的泛型是什么数据,就返回什么数据
public static void main(String[] args) {
String s=supplier_pri(()->{
return "返回的字符串";
});
System.out.println(s);
}
public static String supplier_pri(Supplier<String> sup)
{
return sup.get();
}
结果
返回的字符串
Consumer接口
包含一个带参的accept方法,泛型指定什么数据就可以使用什么数据,怎么使用自定
包含一个默认方法andThen,把两个Consumer接口组合到一起,再进行使用
public static void main(String[] args) {
consumer_pri("gfx",(String name)->{
System.out.println("使用的字符串是:"+name);
});
//andThen方法
andThen_pri("Hello",(String str1)->{
System.out.println("con1把字符串变成全大写:"+str1.toUpperCase());
},
(String str2)->{
System.out.println("con1把字符串变成全小写:"+str2.toLowerCase());
});
}
public static void consumer_pri(String name,Consumer<String> con) {
con.accept(name);
}
public static void andThen_pri(String name,Consumer<String> con1,Consumer<String> con2) {
con1.andThen(con2).accept(name);
/*
这句话等于
con1.accept(name);
con2.accept(name);
*/
}
结果
使用的字符串是:gfx
con1把字符串变成全大写:HELLO
con1把字符串变成全小写:hello
Predicate接口
包含一个带参的test方法,用于判断,返回一个boolean值,如何判断自定
包含三个默认方法:and(&&),or(||),negate(!)
public static void main(String[] args) {
String s2="abcde";
boolean b=pridicate_pri(s2,(String str)->{
return str.length()>10;
});
System.out.println(b);
boolean b2=and_pri(s2,(String str)->{
return str.charAt(1)=='b';
},
(String str)->{
return str.charAt(2)=='c';
});
System.out.println(b2);
}
public static boolean pridicate_pri(String str,Predicate<String> pre)
{
return pre.test(str);
}
public static boolean and_pri(String str,Predicate<String> pre1,Predicate<String> pre2)
{
return pre1.and(pre2).test(str);
/*
这句话等于
return pre1.test(str)&&pre2.test(str);
*/
}
结果
false
true
Function<T,R>接口
包含一个带参的apply方法,把T类型的数据转换为R类型的数据
包含一个默认方法andThen,进行两次转换,把T转换成R再转换回来
public static void main(String[] args) {
String s3="1234";
function_pri(s3,(String str)->{
return Integer.parseInt(str);
});
}
public static void function_pri(String s,Function<String,Integer> fun) {
Integer in=fun.apply(s);
System.out.println(in);
}
结果
1234