二十、Java8新特性——函数式接口【黑马JavaSE笔记】

函数式接口

（一）函数式接口概述

---

（二）函数式接口作为方法的参数

测试类：

public class RunnableDemo {
    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() + "启动了"));
    }

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

---

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

代码演示：

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("aaabbb");
        array.add("sdas");
        array.add("sda");
        System.out.println("排序前：" + array);//排序前：[aaabbb, sdas, sda]
        Collections.sort(array, getComparator());
        System.out.println("排序后：" + array);//排序后：[sda, sdas, aaabbb]
    }

    private static Comparator<String> getComparator() {
        //匿名内部类实现
//        Comparator<String> c = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };
//        return c;

        //匿名内部类简写
//        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();
//        };

        //Lambda表达式简写
        return (s1, s2) -> s1.length() - s2.length();
    }
}

---

（四）常用的函数式接口

Java8在java.util.function包下预定义了大量的函数式接口供我们使用

我们重点来学习下面的4个接口

• Supplier接口
• Consumer接口
• Predicate接口
• Function接口

1.Supplier接口

代码演示：

import java.util.function.Supplier;

public class SupplierDEmo {
    public static void main(String[] args) {
//        String s = getString(new Supplier<String>() {
//            @Override
//            public String get() {
//                return "小明";
//            }
//        });

        String s = getString(() -> "小明");
        System.out.println(s);//小明
        Integer i = getInteger(() -> 10);
        System.out.println(i);//10

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

    private static String getString(Supplier<String> sup) {
        return sup.get();
    }
}

2.Supplier接口练习（获取最大值）

代码演示：

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        int[] arr = {19, 50, 28, 37, 46};
        int maxValue = getMax(() -> {
            int max = 0;
            for (int i = 0; i < arr.length; i++) {
                if (max < arr[i]) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }

    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

---

3.Consumer接口

代码演示：

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        //匿名内部类
        operatorString("小明", new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //Lambda表达式
        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(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }
    
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
    //对同一个字符串数据用不同的方式消费两次
    private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
        con1.andThen(con2).accept(name);
    }
}

4.Consumer接口练习（按要求打印信息）

代码演示：

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"王老五,20", "张三,30", "李四,22"};
        
        operatorString(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);
        });

        //简化代码
        operatorString(strArray, str -> System.out.print("姓名：" + str.split(",")[0]), 
                str -> System.out.println(", 年龄：" + Integer.parseInt(str.split(",")[1])));
    }

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

---

5.Predicate接口

代码演示：

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        boolean result = checkString("hello", (String s) -> {
            return s.length() > 6;
        });
        System.out.println(result);

        //简写
        boolean result2 = checkString("helloWorld", s -> s.length() > 6);
        System.out.println(result2);

        boolean result3 = checkString("hello", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result3);
        boolean result4 = checkString("helloWorld", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result4);

        boolean result5 = checkString2("hello", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result5);
        boolean result6 = checkString2("helloWorld", s -> s.length() > 6, s -> s.length() < 15);
        System.out.println(result6);
    }

    private static boolean checkString(String s, Predicate<String> p) {
//        return p.test(s);
        //否定操作
        return p.negate().test(s);
    }

    //对同一个字符串给出不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//        boolean b = b1 && b2;
//        return  b;
        return p1.and(p2).test(s);
    }

    //对同一个字符串给出不同的判断条件，最后把这两个判断的结果做逻辑或运算的结果作为最终的结果
    private static boolean checkString2(String s, Predicate<String> p1, Predicate<String> p2) {
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//        boolean b = b1 && b2;
//        return  b;
        return p1.or(p2).test(s);
    }
}

---

6.Predicate接口练习（筛选满足条件数据）

代码实现：

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

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"张三三,20", "王五,22", "李四四,40", "吕布布,55", "曾小贤,30"};

        //调用方法，编写满足条件
//        ArrayList<String> people = checkPeople(strArray, str -> {
//            String name = str.split(",")[0];
//            return name.length() > 2;
//        }, str -> {
//            int age = Integer.parseInt(str.split(",")[1]);
//            return age > 33;
//        });

        //简写
        ArrayList<String> people = checkPeople(strArray, str -> str.split(",")[0].length() > 2
                , str -> Integer.parseInt(str.split(",")[1]) > 33);

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

    private static ArrayList<String> checkPeople(String[] strArray, Predicate<String> p1, Predicate<String> p2) {
        //定义一个集合
        ArrayList<String> array = new ArrayList<>();

        //遍历数组，将满足条件的数据添加进入集合中
        for (String str : strArray) {
            if (p1.and(p2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

---

7.Function接口

代码演示：

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        convert("100", s -> Integer.parseInt(s));
//        convert("100", Integer::parseInt);//方法引用

        convert(100, i -> String.valueOf(i + 10));

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

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

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

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

---

8.Function接口练习（按照指定要求操作数据）

代码实现：

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林小青,30";
        convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
    }

    private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
        //这里解释上面调用时 s和ss的混乱
//        String ss = fun1.apply(s);
//        Integer i = fun2.apply(ss);
//        Integer i2 = fun3.apply(i);
        int i2 = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i2);
    }
}

---