一、函数式接口
1.1 概念
函数式接口在Java中是指：有且仅有一个抽象方法的接口
1.2 格式
只要确保接口中有且仅有一个抽象方法即可：
修饰符 interface 接口名称 {public abstract 返回值类型 方法名称（可选参数信息）//其他非抽象方法内容}
由于接口当中抽象方法的public abstract是可以参略的，所以：
public interface MyFunctionalInterface {void myMethod();}
1.3 @FunctionalInterface注解
- @FunctionalInterface注解
- 作用：检测接口是否是一个函数式接口
- 是：成功
- 否：编译失败（1.接口中没有抽象方法，2.接口中抽象方法大于1)
二、函数式编程
2.1 Lambda的延迟执行
有些场景的代码在执行之后，结果不一定会被使用，从而造成性能浪费，Lambda延迟执行，可以提升性能。
性能浪费的日志案例
案例：
public class Demo01Logger{private static void log(int level,String msg){if(level == 1){System.out.println(msg);}}public static void main(String[] args){String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, msgA+msgB+msgC);}}
使用Lambda：
public class Demo02Lambda {
//显示日志的方法
public static void showLogger(int level,MessageBuilder mb){
//判断等级
if(level == 1){
System.out.println(mb.builderMessage());
}
}
public static void main(String[] args) {
String msg1="hello";
String msg2="world";
String msg3="java";
//调用showLogger方法，参数MessageBuilder是函数式接口，可以调用Lambda
showLogger(2,()->{//传进一个Lambda-》实际上是接口，如果等级为1，才回return
//返回是一个拼接好的字符串
return msg1+msg2+msg3;
});
/*使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
* 只有满足条件，日志的等级是1级
* 才会调用接口MessageBuilder中的方法
* 才会进行字符串的拼接*/
}
}
2.2 使用Lambda作为参数和返回值
如果抛开实现原理不说，Java中的Lambda表达式可以当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。
例如java.lang.Runnable接口就是一个函数式接口，加入有一个startThread方法使用该接口作为参数,那么就可以使用Lambda进行传参。这种情况其实和Thread类的构造方法参数为Runnable没有本质区别
public class Demo01Runnable {
//定义一个方法，方法的参数使用函数式接口Runnable
public static void startThread(Runnable run){
new Thread(run).start();
}
public static void main(String[] args) {
//调用方法。方法的参数是一个接口，那么我们可以传递这个接口的匿名内部类
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
//调用方法。方法的参数是一个接口,使用Lambda表达式
startThread(()->{
System.out.println(Thread.currentThread().getName());
});
}
}
函数式接口作为方法的返回值：
public class Demo02Comparator {
//定义一个方法，方法的返回值类型使用函数式接口comparator
public static Comparator<String> getComparator(){
//方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
/*return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//按照字符串降序排序
return o2.length()-o1.length();
}
};*/
//方法的返回值是一个函数式接口，所以我们可以返回Lambda表达式
return (String o1,String o2)->{
return o2.length()-o1.length();
};
}
public static void main(String[] args) {
String[] arr={"aaa","b","ccccc","dd"};
Arrays.sort(arr,getComparator());
System.out.println(Arrays.toString(arr));
}
}
三、常用函数式接口
3.1 Supplier接口
java.util.function.Supplier<T>接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。（Supplier指定什么泛型，get方法就获取什么类型的对象）
public class Demo02Comparator {
//定义一个方法，方法的返回值类型使用函数式接口comparator
public static Comparator<String> getComparator(){
//方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
/*return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//按照字符串降序排序
return o2.length()-o1.length();
}
};*/
//方法的返回值是一个函数式接口，所以我们可以返回Lambda表达式
return (String o1,String o2)->{
return o2.length()-o1.length();
};
}
public static void main(String[] args) {
String[] arr={"aaa","b","ccccc","dd"};
Arrays.sort(arr,getComparator());
System.out.println(Arrays.toString(arr));
}
}
3.2 练习：求数组元素最大值
题目
使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值，提示：接口的泛型请使用java.lang.Integer类
解答
public class Demo02Test {
//定义一个方法，用于获取int类型数组中元素的最大值
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
public static void main(String[] args) {
//定义一个int类型的数组，并赋值
int[] arr={100,0,-50,990,88,33};
//调用getmax方法
int maxvalue=getMax(()->{
//获取数组的最大值，并且返回
//定义一个变量，把每次比较的较大值赋值给他
int max=arr[0];
for(int i:arr){
if(i>max){
max=i;
}
}
return max;
});
System.out.println("最大值:"+maxvalue);
}
}
3.3 Consumer接口
java.util.function.Consumer<T>接口恰好与Supplier接口相反，它不是生产一个数据，而是消费一个数据。其数据类型由泛型决定。
抽象方法：accept
Consumer接口中包含抽象方法void accpet(T t)，意为消费一个指定泛型的数据
public class Demo03Consumer {
public static void method(String name, Consumer<String> con){
con.accept(name);
}
public static void main(String[] args) {
method("Crisp",(String name)->{
//对传递的字符串进行消费
System.out.println(name);
});
}
}
默认方法：andThen
如果一个方法的参数和返回值全都是Consumer类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口的default方法andThen。
default Consumer<T> andThen(Consumer<? super T> after){
Objeccts.requireNonNull(after);
return(T t) -> { accept(t); after.accept(t);};
}
备注：
java.util.Objects的requireNonNull静态方法将会在参数为null时主动抛出NullPointerException异常，省去了重复编写if语句和抛出空指针异常的麻烦
3.4 Predicate接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T>接口
抽象方法：test
Predicate接口中包含一个抽象方法：boolean test(T t)用于条件判断
/*
* 对某种数据类型的数据进行判断*/
public class Demo04Predicate {
//定义一个方法，参数传递一个String类型的字符串
//传递一个Predicate接口，泛型使用String
//使用test方法对字符串进行判断
public static boolean checkString(String s, Predicate<String> 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;
});
System.out.println(b);
}
}
默认方法：and
既然是条件判断，就会存在于、或、非三种常见的逻辑关系。
将两个Predicate条件使用“与”逻辑连接的方法就是and
default Predicate<T> and (Predicate<? super T> other){
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：
import java.util.function.Predicate;
public class Demo01PRedicateAnd{
private static void method(Predicate<String> one , Predicate<String> two){
boolean isValid = one.and(two).text("HelloWorld");
System.out.println("字符串符合要求吗:"+isValid);
}
public static void main(String[] args){
method(s -> s.contains("H"), s -> s.contains("W"));
//method((s)->{return s.contains("H");},(s)->{return s.contains("W")})
}
}
默认方法：or
与and方法类似。默认方法or实现逻辑关系中的或
default Predicate<T> or(Predicate<? super T> other){
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“or”即可
import java.util.function.Predicate;
public class Demo01PRedicateAnd{
private static void method(Predicate<String> one , Predicate<String> two){
boolean isValid = one.or(two).text("HelloWorld");
System.out.println("字符串符合要求吗:"+isValid);
}
public static void main(String[] args){
method(s -> s.contains("H"), s -> s.contains("W"));
//method((s)->{return s.contains("H");},(s)->{return s.contains("W")})
}
}
3.5 练习多条件判断
判断一个数组里，性别为女，并且姓名长度为5的人
import java.util.ArrayList;
import java.util.function.Predicate;
public class Demo05PredicateTest {
public static ArrayList<String> filter(String[] arr, Predicate<String> pre1,Predicate<String> pre2){
//定义一个ArrayList集合，存储过滤后的信息
ArrayList<String> list=new ArrayList<>();
//遍历
for(String s:arr){
//使用Predicate接口的方法test对获取到的字符串进行判断
boolean b=pre1.and(pre2).test(s);
//对得到的boolean进行判断
if(b){
//条件成立，存储到ArrayList中
list.add(s);
}
}
return list;
}
public static void main(String[] args) {
//定义一个存储字符串的数组
String[] array={"Gimgoon,男","Tian,女","Doinb,男","LWX,女","Crisp,男"};
//调用filter方法，传递字符串数组和两个Lambda表达式
ArrayList<String> list = filter(array,(String s)->{
//获取字符串中的性别，判断是否为男
return s.split(",")[1].equals("男");
},(String s)->{
//获取字符串中的姓名，判断长度是否为5个字符
return s.split(",")[0].length()==5;
});
//遍历结果集合
for (String s : list) {
System.out.println(s);
}
}
}
3.6 Function接口
java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。
抽象方法：apply
Function接口中最重要的抽象方法为：R apply(T t)，根据类型T的参数获取R的结果。
使用场景例如：将String类型转换为Integer类型
public class Demo01Apply {
/*
* 定义一个方法
* 方法的参数传递一个字符串类型的整数
* 方法的参数传递一个Function接口，泛型使用<String,Integer>
* 使用apply方法，把字符串类型的整数转换为Integer类型的整数
* */
public static void change(String s,Function<String,Integer> fun){
Integer in=fun.apply(s);
System.out.println(in);
}
public static void main(String[] args) {
String s = "12345";
change(s,(String str)->{
//转换数据
return Integer.parseInt(str);
});
}
}
默认方法：andThen
Function接口中有一个默认的andThen方法，用来进行组合操作。JDK源代码：
default <V> Function<T, V>andThen(Function<? super R, ? extends V> after){
Objects.requireNonNull(after);
return(T t) -> after.apply(apply(t));
}
该方法用于“先做什么，再做什么”的场景，和Consumer中的andThen差不多
public class Demo02andThen {
/*
* 用来进行组合操作
* 需求：
* 把String类型的"123"，转换为Integer类型，把转换结果加10
* 把增加之后的Integer类型的数据，转换为String类型
* 分析：
* 转换两次-1.String转Integer->使用Function<String,Integer> fun1
* Integer i= fun1.apply("123")+10
* 1.Integer转换为String类型,使用Function<Integer,String> fun2
* String s= fun2.apply(i);
* 可以使用andThen方法，将两次转换组合在一起
* String s = fun1.andThen(fun2).apply("123");->fun1先调用appy转换，如何fun2调用
*/
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方法,传递字符串和两个Lambda表达式
change(s,(String str)->{
//把字符串转换为整数+10
return Integer.parseInt(str)+10;
},(Integer i)->{
//把整数转换为字符串
return i+"";
});
}
}
3.7 练习：自定义函数模型拼接
题目
请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str="Crisp,20";
1.将字符串截取数字年龄部分，得到字符串；
2.将上一步的字符串转换为int类型的数字；
3.将上一步的int数字累加100，得到结果int数字
public class Demo03Test{
public static int agePlus(String s, Function<String,Integer> fun){
return fun.apply(s);
}
public static void main(String[] args) {
String s="雨落,20";
int result=agePlus(s,(String str)->{
//截取数字年龄部分
str=str.split(",")[1];
//将年龄字符串转换为int类型的数字
int age=Integer.parseInt(str);
//将该数字累加100。返回
return age+100;
});
System.out.println(result);
}
}
若有收获，就点个赞吧
0 人点赞
