Java函数式接口

3 函数式接口

3.1 函数式接口概述

• 函数式接口：有且仅有一个抽象方法的接口

• Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法， Java中的Lambda才能顺利地进行推导

• 如何检测一个接口是不是函数式接口呢?

  • @FunctionalInterface
  • 放在接口定义的上方:如果接口是函数式接口，编译通过；如果不是,编译失败

• 注意：我们自己定义函数式接口的时候，@Functionallnterface是可选的, 就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

3.2 函数式接口作为方法的参数

• 需求
  

package test;public class Demo {public static void main(String[] args) {//匿名内部类startThread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "线程启动了"); //Thread-0线程启动了}});//Lambda表达式startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了")); //Thread-1线程启动了}public static void startThread(Runnable r) { //Runnable为函数式接口，上方有@FunctionalInterface
//        Thread t  = new Thread(r);
//        t.start();new Thread(r).start();}
}

• 如果方法的参数是函数式接口，可以使用Lambda表达式作为参数传递

startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));

3.3 函数式接口作为方法的返回值

• 需求
  

package test;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Demo {public static void main(String[] args) {//构造使用场景//定义一个集合存储字符串ArrayList array = new ArrayList();array.add("cccc");array.add("aa");array.add("b");array.add("dd");System.out.println("排序前："+array); //排序前：[cccc, aa, b, dd]Collections.sort(array); //排序后:[aa, b, cccc, dd]Collections.sort(array,getComparator()); //排序后:[b, aa, dd, cccc]System.out.println("排序后:"+array);}public static Comparator<String> getComparator() {//匿名内部类
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
//        return comp;//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };//Lambda表达式
//        return (String s1,String s2) ->{
//            return s1.length()-s2.length();
//        };return(s1,s2) -> s1.length()-s2.length();}
}

• 如果方法的返回值是函数式接口，可以使用Lambda表达式作为结果返回

public static Comparator<String> getComparator() {return(s1,s2) -> s1.length()-s2.length();
}	

3.4 常用函数式接口

• Java 8在java.util.function包下预定义了大量的函数式接口供我们使用
• 重点来学习下面的4个接口
  • Supplier [səˈplaɪər] 接口
  • Consumer [kənˈsuːmər] 接口
  • Predicate[ˈpredɪkət] 接口
  • Function接口

3.4.1 Supplier接口

• Supplier<T>：包含一个无参的方法
• T get()方法：获得结果
• 该方法不需要参数， 它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
• Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型,那么接口中的get()方法就会生产什么类型的数据供我们使用

package test;import java.util.function.Supplier;public class Demo {public static void main(String[] args) {
//        String s = getString(() -> {
//            return "小黑";
//        });String s = getString(() -> "小黑");System.out.println(s); //小黑int i = getInteger(() -> 10);System.out.println(i); //10}//定义一个方法，返回字符数据public static String getString(Supplier<String> sup) {return sup.get();}//定义一个方法，返回整数数据public static Integer getInteger(Supplier<Integer> sup) {return sup.get();}
}

• 练习
  

package test;import java.util.function.Supplier;public class Demo {public static void main(String[] args) {int[] arr = {22, 55, 11, 44, 33};int maxValue = getMax(() -> {int max = arr[0];for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}return max;});System.out.println(maxValue); //55}public static int getMax(Supplier<Integer> sup) {return sup.get();}
}

3.4.2 Consumer接口

• Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
• Consumer ：包含两个方法

方法名	说明
void accept(T t) [əkˈsept]	对给定的参数执行此操作
default Consumer<T> andThen(Consumer after)	返回一个组合的Consumer，依次执行此操作，然后执行after操作

• 范例

package test;import java.util.function.Consumer;public class Demo {public static void main(String[] args) {
//        operatorString("小白",(String s)->{
//            System.out.println(s); //小白
//        });operatorString("小白",s-> System.out.println(s)); //小白//        operatorString("小黑",System.out::println); //小黑//        operatorString("大熊猫",s -> {
//            System.out.println(new StringBuilder(s).reverse().toString()); //猫熊大
//        });operatorString("大熊猫",s -> System.out.println(new StringBuilder(s).reverse().toString())); //猫熊大System.out.println("---------");operatorString("小熊猫",s -> System.out.println(s),s -> System.out.println(new StringBuilder(s).reverse().toString()));
//        小熊猫
//        猫熊小}//定义一个方法，用不同的方式消费同一个字符串数据两次private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2) {//1,void accept(T t) [əkˈsept] 	对给定的参数执行此操作
//        con1.accept(name);
//        con2.accept(name);//2,Consumer<T> andThen(Consumer after) 	返回一个组合的Consumer，依次执行此操作，然后执行after操作con1.andThen(con2).accept(name);}//定义一个方法，消费一个字符串数据private static void operatorString(String name, Consumer<String> con) {con.accept(name);}
}

• 练习
  

package test;import java.util.function.Consumer;public class Demo {public static void main(String[] args) {String[] strArray = {"小白,10", "小黑,20"};
//        printInfo(strArray,(String str) ->{
//            String name = str.split(",")[0];
//            System.out.print("姓名:"+name);
//        },(String str)->{
//            int age = Integer.parseInt(str.split(",")[1]);
//            System.out.println(",年龄:"+age);
//        });//姓名:小白,年龄:10//姓名:小黑,年龄:20printInfo(strArray, str -> System.out.print("姓名:" + str.split(",")[0]),str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1])));}private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {for (String str : strArray) {con1.andThen(con2).accept(str);}}
}

3.4.3 Predicate [predɪkeɪt] 接口

• Predicate<T>接口通常用于判断参数是否满足指定的条件
• 常用的四个方法

方法名	说明
boolean test(T t)	对给定的参数进行判断(判断逻辑由Lambda表达式实现，返回一个布尔值
default Predicate<T> negate()	返回一个逻辑的否定，对应逻辑非
default Predicate <T> and(Predicate other)	返回一个组合判断，对应短路与
default Predicate <T> or(Predicate other)	返回一个组合判断，对应短路或

• 范例

package test;import java.util.function.Predicate;public class Demo {public static void main(String[] args) {
//        boolean b1 = checkString("hello",(String s) ->{
//            return s.length()>8;
//        });boolean b1 = checkString("hello", s -> s.length() > 8);System.out.println(b1); //1：false，2：trueboolean b2 = checkString("hello",s->s.length()>8,s -> s.length()<15);System.out.println(b2); //3:false,4:trueboolean b3 = checkString("hellojava",s->s.length()>8,s -> s.length()<15);System.out.println(b3); //3:true,4:true}//判断给定的字符串是否满足要求private static boolean checkString(String s, Predicate<String> pre) {//1,boolean test(T t) 	对给定的参数进行判断(判断逻辑由L ambda表达式实现，返回一个布尔值
//        return pre.test(s);
//        return !pre.test(s); //输出相反的，不过用下一个方法//2,default Predicate<T> negate() 	返回一个逻辑的否定，对应逻辑非return pre.negate().test(s);}//同一个结果给出两个不同的判断条件，最后把这两个判断结果做逻辑与的结果作为最终结果private static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2) {
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;//3,default Predicate <T> and(Predicate other) 	返回一个组合判断，对应短路与
//        return pre1.and(pre2).test(s); //源码：return (t) -> test(t) && other.test(t);//default Predicate <T> or(Predicate other) 	返回一个组合判断，对应短路或return pre1.or(pre2).test(s); //源码：return (t) -> test(t) || other.test(t);}
}

• 练习
  

package test;import java.util.ArrayList;
import java.util.function.Predicate;public class Demo {public static void main(String[] args) {String[] strArray = {"小黑,50", "大熊猫,40", "小白,20", "奥特曼,100"};ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,s -> Integer.parseInt(s.split(",")[1]) > 33);for(String str:array) {System.out.println(str);
//            大熊猫,40
//            奥特曼,100}}public static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {//定义一个集合ArrayList<String> array = new ArrayList<String>();//遍历数组for (String str : strArray) {if (pre1.and(pre2).test(str)) {array.add(str);}}return array;}
}

3.4.4 Function接口

• Function<T,R> 接口通常用于对参数进行处理,转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
• 常用的两个方法

方法名	说明
R apply(T t)	将此函数应用于给定的参数
default <V> Function andThen(Function after)	返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果

• 案例

package test;import java.util.function.Function;public class Demo {public static void main(String[] args) {convert("100", s -> Integer.parseInt(s)); //100
//        convert("100",Integer::parseInt); //100convert(100, i -> String.valueOf(i + 566)); //666convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566)); //666}//定义一个方法，把一个字符串转换成int类型，在控制台输出public static void convert(String s, Function<String, Integer> fun) {//1,R apply(T t) 	将此函数应用于给定的参数
//        Integer i = fun.apply(s);int i = fun.apply(s);System.out.println(i);}//定义一个方法，把一个int类型的数据加上一个整数之后，转换为字符串在控制台输出public static void convert(int i, Function<Integer, String> fun) {String s = fun.apply(i);System.out.println(s);}//定义一个方法，把一个字符串转换成int类型，把int类型的数据加上一个整数之后，转换为字符串在控制台输出public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {//Integer i = fun.apply(s);//String ss = fun.apply(i);//2,default <V> Function andThen(Function after) 	返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果String ss = fun1.andThen(fun2).apply(s);//源码：return (T t) -> after.apply(apply(t));相当于上两步System.out.println(ss);}
}

• 练习
  

package test;import java.util.function.Function;public class Demo {public static void main(String[] args) {String s = "小黑,20";convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70); //90}public static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {int i = fun1.andThen(fun2).andThen(fun3).apply(s);System.out.println(i);}
}