JAVA基础 - 046常用函数式接口 - 《JAVA从0到1》

Supplier<T>接口
- 练习：求数组元素最大值
java.langRunnable接口
java.util.function.Predicate<T>接口
java.util.function.Consumer

Supplier`<T>`接口

java.util.function.Supplier<T>接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据
Supplier<T>接口被称为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会生产什么类型数据

import java.util.function.Supplier;
public class DemoSupplier {
    //定义一个方法，方法的参数传递Supplier<T>接口，泛型String，get方法就会返回一个String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }
    public static void main(String[] args) {
        //调用getString方法，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
        String s = getString(() -> {
            //生产一个字符串，并返回
            return "胡歌";
        });
        System.out.println(s);
        //优化Lambda表达式
        String s1 = getString(() -> "胡歌");
        System.out.println(s1);
    }
}

练习：求数组元素最大值

使用Supplier接口作为方法的参数类型，通过Lambda表达式求出int数组中的最大值。

提示：接口泛型请使用java.lang.Integer类

import java.util.function.Supplier;

public class DemoSupplierMax {
    //定义一个方法，用于获取Int类型数组中元素的最大值，方法的参数传递Supplier接口,泛型使用Integer
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //定义一个int类型的数组，并赋值
        int[] arr = {122,0,-53,44,55,66};
        //调用getMax，方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
        int max1 = getMax(() -> {
            //获取数组的最大值，并返回
            //定义一个变量，把数组中的第一个元素赋值给该变量，记录数组元素的最大值
            int max = arr[0];
            for (int i : arr) {
                //使用其他的元素和最大值进行比较
                if (i > max)
                    max = i;
            }
            return max;
        });
        System.out.println("数组中元素的最大值是：" + max1);
    }
}

java.langRunnable接口

假设有一个startThread方法使用该接口作为参数，那么就可以一使用Lambda进行传参
这种情况下其实和Thread类的构造方法参数为Runnable没有本质区别

import javax.print.attribute.standard.PagesPerMinute;

public class DemoRunnable01 {
    //定义一个方法startThread，方法的参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }

    public static void main(String[] args) {
        //调用startThread方法，方法的参数是一个接口，那么我们可以传递这个接口的匿名内部类
//        startThread(new Runnable(){
//
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + "->" + "线程启动了");
//            }
//        });

        // //定义一个方法startThread，方法的参数使用函数式接口,所以可以用Lambda
        startThread(()->System.out.println(Thread.currentThread().getName() + "->" + "线程启动了"));
    }
}

java.util.function.Predicate`<T>`接口

作用：对某种数据类型的数据进行判断,结果返回一个boolean值
Predicate接口中包含一个抽象方法：
Boolean test(T t):用来对指定数据类型数据进行判断的方法
结果：
```
       符合条件,返回true
```

```
       不符合条件,返回false
```

import java.util.function.Predicate;

public class DemoPredicate {
    /*
    定义一个方法
    参数传递一个String类型的字符串
    传递一个Predicate接口，泛型使用String
    使用Predicate中的方法test对字符串进行判断，把判断的结果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcde";

        //调用checkString方法对字符串进行校检，参数传递字符串和Lambda表达式
//        boolean b = checkString(s, (String str) -> {
//            //对字符串进行判断
//            return str.length() > 4;
//        });
//        System.out.println(b);

        //优化Lambda表达式
        boolean b = checkString(s, str -> str.length() > 5);
        System.out.println(b);
    }
}

pre1.and

逻辑表达式：可以连接多个判断的条件

&&：与运算符，有false则false
||：或运算符，有true则true
！：非运算符，非真则假，非假则真
需求：判断一个字符串，有两个判断条件
1、判断字符串的长度是否大于5
2、判断字符串中是否包含a
用&&运算符

import java.util.function.Predicate;

public class DemoPredicate_and {
    //定义一个方法，方法的参数，传递一个字符串
    //传递两个Predicate接口
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcdef";
        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s, (String str) -> {
            //判断字符串长度是否大于5
            return str.length() > 5;
        }, (String str) -> {
            return str.contains("a");
        });
        System.out.println(b);
    }


}

pre1.or

逻辑表达式：可以连接多个判断的条件

&&：与运算符，有false则false
||：或运算符，有true则true
！：非运算符，非真则假，非假则真
需求：判断一个字符串，有连个判断条件

1、判断字符串的长度是否大于5

```
2、判断字符串中是否包含a
```

用or运算符

import java.util.function.Predicate;

public class DemoPredicate_or {
    //定义一个方法，方法的参数，传递一个字符串
    //传递两个Predicate接口
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) || pre2.test(s);
        return pre1.or(pre2).test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "djjjef";
        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s, (String str) -> {
            //判断字符串长度是否大于5
            return str.length() > 5;
        }, (String str) -> {
            return str.contains("a");
        });
        System.out.println(b);
    }

}

pre.negate()

需求：判断一个字符串长度是否大于5

如果字符串的长度大于5，那返回false

如果字符串长度不大于5，那就返回true

```
用！符号
```

import java.util.function.Predicate;

/**
 * 
 * Predicate接口中有一个方法negate，也表示取反
 * default  Predicate<T> negate(){
 *     return (t) -> !test(t)
 * }
 */
public class DemoPredicate_negate {
    //定义一个方法，方法的参数，传递一个字符串
    //传递一个Predicate接口
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return pre.negate().test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abc";
        boolean b = checkString(s, (String str) -> str.length() > 5);
        System.out.println(b);
    }
}

练习：集合信息筛选

数组当中有多条”姓名 + 性别”的信息
通过Predicate接口中的拼装符合要求的字符串筛选到结合ArrayList集合中
需要同时满足两个条件：
1、必须为女生；
2、姓名为四个字

分析：

1、有两个判断条件，需要两个Predicate接口

2、必须同时满足两个条件，所以要用and方法

package Demo49;

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

public class DemoPredicate_Test {
    //定义一个方法
    public static ArrayList<String> filter(String[] arr, Predicate<String> pre1, Predicate<String> pre2){
        //定义一个数组，存储过滤之后的信息
        ArrayList<String> list = new ArrayList<>();
        for (String s : arr) {
            //使用Predicate接口中的方法test对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(s);
            //对得到的布尔值进行判断
            if (b){
                //条件成立，两个条件都满足，把信息存储到ArrayList集合中
                list.add(s);
            }
        }
        return list;
    }

    public static void main(String[] args) {
        //定义一个数组
        String[] arr = {"迪丽热巴,女","古力娜扎,女","马尔扎哈,男"};
        ArrayList<String> list = filter(arr, (String s) -> {
            //获取字符串中的性别，判断是否为女
            return s.split(",")[1].equals("女");
        }, (String s) -> {
            //获取字符串中的姓名，判断长度是否为4个字符
            return s.split(",")[0].length() == 4;
        });

        //遍历结合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

java.util.function.Consumer

java.til.function.Consumer`<T>`接口

则正好与Supplier相反

它是一个消费数据，其类型由泛型决定
Consumer接口中包含抽象方法void accept(T t),意为消费一个指定泛型的数据
Consumer接口是一个消费型接口，泛型是什么类型，就可以使用accept方法消费什么类型数据


import java.util.function.Consumer;


public class DemoConsumer {
    /*
    定义一个方法
    方法的参数传递一个字符串的姓名
    方法的参数传递Consumer接口，泛型使用String
    可以使用Consumer接口消费字符串的姓名

     */
    public static void method(String name, Consumer<String> 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);
        });
    }
}

练习：

字符数组中当中存有多条信息，请按照格式"姓名: xx。性别: xx。"的格式将信息打印出来

要求将打印姓名的动作作为第一个Consumer接口的Lambda实例

将打印性别的动作作为第二个Consumer解耦的Lambda实例

将两个Consumer接口按照顺序拼接到一起

package Demo49;

import java.util.function.Consumer;


public class DemoConsumerPrintf {
    //定义一个方法,c参数传递String类型的数组和两个Consumer接口，泛型使用String
    public static void printInfo(String[] arr, Consumer<String> con1, Consumer<String> con2){
        //遍历字符串数组
        for (String s : arr) {
            //使用andThen连接俩个Consumer接口
            con1.andThen(con2).accept(s);
        }
    }


    public static void main(String[] args) {
        //定义一个字符串类型的数组
        String[] arr = {"迪丽热巴,女","古力娜扎,女","马尔扎哈,男"};

        //调用printInfo方法，传递一个字符串数组，和两个Lambda表达式
        printInfo(arr,(s)->{
            String name = s.split(",")[0];
            System.out.print("姓名：" + name);
        },(s)->{
            String sex = s.split(",")[1];
            System.out.println("。 性别：" + sex);

        });
    }
}

Consumer接口的默认对象andThen

作用：需要两个Consumer接口，可以把两个Consumer接口组合到一起，在对数据进行消费

package Demo49;

import java.util.function.Consumer;

public class DemoConsumerAndThen {
    //定义一个方法，方法的参数传递一个字符串，和两个Consumer接口
    public static void method(String s, Consumer<String> con1, Consumer<String>con2){
        //con1.accept(s);
        //con2.accept(s);
        //使用andThen方法，把两个Consumer接口连接到一起，在消费数据
        con1.andThen(con2).accept(s);//先执行从con1,在执行con2
    }

    public static void main(String[] args) {
        //调用method方法，传递一个字符串，两个Lambda表达式
        method("Hello",
                (t)-> {
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    System.out.println(t.toLowerCase());
        });
    }
}

Comparator接口

如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式
当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序及其是，就可以调用该方法获取

import javax.imageio.stream.ImageInputStream;
import java.util.Arrays;
import java.util.Comparator;
public class DemoComparator {
    //定义一个方法，方法的返回值类型使用函数式接口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();
//        };
        //继续优化
        return ( o1, o2)->o2.length()-o1.length();

    }

    public static void main(String[] args) {
        //创建一个数组
        String[] arr = {"aa","b","ccc","ddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));
        //调用Arrays中的sort方法,对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //排序后的数组
        System.out.println(Arrays.toString(arr));
    }
}

java.util.function.Function接口

用来根据一个类型的数据得到另一个类型的数据

前者为前置条件，后者为后置条件

FUnction接口中最主要的抽象方法为：R apply(T t),根据类型T的参数获取类型R的结果
使用场景：将String类型转换为Integer类型

import java.util.function.Function;
public class DemoFunction {
    /*
     * 定义一个方法
     * 方法的参数传递为字符串类型的整数
     * 方法的参数传递一个Function接口，泛型用<String,Integer>
     *使用Function接口中的方法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方法，传递字符串类型的整数，和Lambda表达式
        change(s,(String str)->
                //把字符串类型的整数，转换为Integer类型的整数返回
             Integer.parseInt(str));
    }
}

Function接口中的默认方法anThen

package Demo49;

import java.util.function.Function;

/**
 * Function接口中的默认方法anThen：用来进行组合操作
 *
 * 需求：
 *      把String类型的"123"转换为Integer类型,转换之后的结构+10
 *      把增加之后的Integer类型的数据，转换为String类型
 *
 * 分析:转换了俩次
 * 第一次是把String类型转换成Integer类型
 * 所以用 Function<String, Integer> fun1
 *第二次是把Integer类型转换成String类型
 * 所以用Function<Integer, String> fun2
 *
 * 使用andThen组合在一起使用
 * String ss = fun1.andThen(fun2).apply(s);
 * fun1先调用apply方法，把字符串转换为Integer
 * fun2在调用apply方法，把Integer转换为字符串
 */
public class DemoFunction_andThen {
    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(s,(String str)-> Integer.parseInt(str) + 10, (Integer i)-> i + "");
    }
}

练习：自定义函数模式拼接

题目
请使用Function进行函数模型的拼接，按照顺序徐亚执行的多个函数操作为：
```
String str = "赵丽颖,20";
```

分析：

1、将字符串截取数字年龄部分，得到字符串

2、将上一步的字符串转换成为int类型的数字

3、将上一步int数字累加100，得到结果int数字

```java

import java.util.function.Function;

public class DemoFunction_Test { public static int change(String s, Function fun1, Function fun2, Function fun3){ return fun1.andThen(fun2).andThen(fun3).apply(s);

 }

public static void main(String[] args) {
    //定义一个字符串
    String str = "赵丽颖,20";
    int num = change(str, (String s) -> {
        return s.split(",")[1];
    }, (String s) -> {
        return Integer.parseInt(s);
    }, (Integer i) -> {
        return i + 100;
    });
    System.out.println(num);
}

} ```

046常用函数式接口

Supplier<T>接口