21.4 函数式接口

概念 

有且仅有一个抽象方法的接口

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

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

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

需求：

定义一个类(RunnableDemo)，在类中提供两个方法
一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用startThread方法

代码演示：

public class RunnableDemo {
    public static void main(String[] args) {
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });

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

    public static void startThread(Runnable r){
        new Thread(r).start();
    }
}

运行结果:

 

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

需求：

定义一个类(ComparatorDemo)，在类中提供两个方法
一个方法是：Comparator getComparator() 方法返回值Comparator是一个函数式接口 
一个方法是主方法，在主方法中调用getComparator方法 

代码演示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("cccc");
        array.add("aaa");
        array.add("ddd");
        array.add("bbb");

        //Collections.sort(array);

        Collections.sort(array,getComparator());
        System.out.println(array);
    }
    private 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 (s1,s2) -> s1.length() - s2.length();
    }
}

运行结果：

 

常用函数式接口之Supplier

Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产 什么类型的数据供我们使用。 

常用方法只有一个：

代码演示：

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "tom");
        System.out.println(s);

        Integer i = getInteger(() -> 30);
        System.out.println(i);

        Character data = getData(() -> 'A');
        System.out.println(data);

        String s1 = getData(() -> "666");
        System.out.println(s1);
    }

    //定义了泛型方法，使用了泛型接口 supplier
    public static <T> T getData(Supplier<T> sup) {
        return sup.get();
    }

    public static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

    public static String getString(Supplier<String> sup) {
        String s = sup.get();
        return s;
    }
}

运行结果：

 

Supplier接口练习之获取最值

实现代码：

import java.util.Arrays;
import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {12,33,43,23,15};
        int max1 = getMax(() -> {
            int max = 0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(max1);

        int min = getMin(() -> {
            Arrays.sort(arr);
            return arr[0];
        });
        System.out.println(min);
    }

    //返回一个数组中的最小值
    public static int getMin(Supplier<Integer> sup){
        return sup.get();
    }

    //返回一个数组中的最大值
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

运行结果：

 

常用函数式接口之Consumer

Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

常用方法：

演示代码：

import java.util.function.Consumer;

public class ConsumerTest_1 {
    public static void main(String[] args) {
        useCon("Hello",(s -> System.out.println(s)));
        System.out.println("--------");

        useConsumer("上海自来水来自海上",s -> System.out.println(s),
                s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }

    //定义方法参数为 消费者接口， 对同一字符串进行两次操作
    public static void useConsumer(String s,Consumer<String> c1,Consumer<String> c2){
        c1.andThen(c2).accept(s);
    }

    //定义方法 操作字符串
    public static void useCon(String s ,Consumer<String> con){
        con.accept(s);
    }
}

运行结果：

 

Consumer接口练习

实现代码+需求：

import java.util.function.Consumer;

/**
 *  String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
 *  字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来
 *  要求： 把打印姓名的动作作为第一个Consumer接口的Lambda实例
 *  把打印年龄的动作作为第二个Consumer接口的Lambda实例
 *  将两个Consumer接口按照顺序组合到一起使用
 */
public class ConsumerTest_2 {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
        operate(strArray,
                s -> System.out.print("姓名：" + s.split(",")[0]),
                s -> System.out.println(",年龄：" + s.split(",")[1])
        );
    }

    private static void operate(String[] strArray, Consumer<String> con1,Consumer<String> con2){
        for (String s : strArray) {
            con1.andThen(con2).accept(s);
        }
    }
}

运行结果：

 

常用函数式接口之Predicate

Predicate接口通常用于判断参数是否满足指定的条件 

常用方法：

演示代码：

import java.util.function.Predicate;

/**
 *  boolean test(T t)
 * 对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回 一个布尔值
 * default Predicate negate() 返回一个逻辑的否定，对应逻辑非
 * default Predicate and(Predicate other)
 * 返回一个组合判断，对应短路与
 * default Predicate or(Predicate other)
 * 返回一个组合判断，对应短路或
 */
public class PredicateTest {
    public static void main(String[] args) {
        boolean b1 = chackStringAnd("hello",
                s -> s.length() > 8,
                s -> s.length() < 8);
        System.out.println(b1);

        boolean b2 = chackStringOr("helloWorld",
                s -> s.length() > 5,
                s -> s.length() < 15);
        System.out.println(b2);

        boolean b3 = chackStringNe("hello", s -> s.length() > 3);
        System.out.println(b3);

    }

    private static boolean chackStringAnd(String s, Predicate<String> p1,Predicate<String> p2){
        return p1.and(p2).test(s);
    }

    private static boolean chackStringOr(String s, Predicate<String> p1,Predicate<String> p2){
        return p1.and(p2).test(s);
    }

    private static boolean chackStringNe(String s,Predicate<String> p){
        return p.negate().test(s);
    }
}

运行结果:

 

Predicate接口练习

实现代码+需求分析：

import java.util.ArrayList;
import java.util.function.Predicate;

/**
 *  String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
 *  字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，
 *  并 遍历ArrayList集合 同时满足如下要求：姓名长度大于2；年龄大于33
 *  分析
 * 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断 必须同时满足两个条件,所以可以使用and方法连接两个判断条件
 */
public class PredicateTest_2 {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};

        ArrayList<String> list = myFilter(strArray,
                s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);

        //遍历方法返回的集合
        for (String s : list) {
            System.out.println(s);
        }
    }

    private static ArrayList<String> myFilter(String[] arr, Predicate<String> p1,Predicate<String> p2){
        //定义一个集合 作为方法的返回值
        ArrayList<String> list = new ArrayList<>();
        //遍历字符串数组 将符合条件的元素添加到集合中
        for (String s : arr) {
            if(p1.and(p2).test(s)){
                list.add(s);
            }
        }
        return list;
    }
}

运行结果：

 

常用函数式接口之Function

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

常用方法：

演示代码：

import java.util.function.Function;

/**
 *  R apply(T t) 将此函数应用于给定的参数
 * default Function andThen(Function after)
 * 返回一个组合函数，首先将该函数应用于输入，然后将after函 数应用于结果
 */
public class FunctionDemo {
    public static void main(String[] args) {
        convert("100",s -> Integer.parseInt(s));

        convert("666",s -> Integer.parseInt(s),i -> String.valueOf(i + 1));
    }

    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function<String,Integer> fun){
        Integer i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台 输出
    private static void convert(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String apply = fun1.andThen(fun2).apply(s);
        System.out.println(apply);
    }
}

运行结果：

 

Function接口练习

实现代码+需求：

import java.util.function.Function;

/**
 *  String s = "林青霞,30"; 请按照我指定的要求进行操作：
 *  1:将字符串截取得到数字年龄部分
 *  2:将上一步的年龄字符串转换成为int类型的数据
 *  3:将上一步的int数据加70，
 *  得到一个int结果，在控制台输出 请通过Function接口来实现函数拼接
 */
public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";
        convert(s,s1 -> s1.split(",")[1],Integer::parseInt,i -> String.valueOf(i + 70));
    }

    private static void convert(String s, Function<String,String>
            fu1,Function<String,Integer> fu2,Function<Integer,String> fu3){
        String apply = fu1.andThen(fu2).andThen(fu3).apply(s);
        System.out.println(apply);
    }
}

运行结果：