java函数式接口

1.1 函数式接口概述

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

Java中函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口

只有确保接口中仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

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

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

注意：

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

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

需求

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

如果方法的参数是一个函数式接口，我们可以用Lambda表达式作为参数传递

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

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

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

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

需求

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

如果一个方法的返回值是一个函数式接口，我们可以把一个Lambda表达式作为结果返回

• private static Comparator<String> getComparator() {    
  	//Lambda表达式写法
      return (s1, s2) -> s1.length() - s2.length();
  }
  

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

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

        System.out.println("排序前" + list);
        Collections.sort(list, getComparator());
        System.out.println("排序后" + list);
    }

    //如果一个方法的返回值是一个函数式接口，我们可以把一个Lambda表达式作为结果返回
    private static Comparator<String> getComparator() {
        //使用匿名内部类实现
//        return new Comparator() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

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

2.1 常用的函数式接口

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

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

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

2.1.1 Supplier接口

Supplier< T >：包含一个无参的方法

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

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(()->"张三");
        int i = getInteger(()->18);

        System.out.println(s+","+i);
    }

    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }

    //定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }
}

练习：

• 定义一个类（SupplierTest），在类中提供两个方法
  • 一个方法是：int getMax(Supplier< Integer > sup) 用于返回一个int数组中的最大值
  • 一个方法是主方法，在主方法中调用getMax方法

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        int[] i = {3,75,32,76,98,42};
        int maxValue = getMax(()->{
           int max = i[0];
            for (int j = 1; j < i.length; j++) {
                if(i[j]>max){
                    max = i[j];
                }
            }
            return max;
        });

        System.out.println(maxValue);
    }

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

2.1.2 Consumer接口

Consumer< T >：包含两个方法

• void accept(T t)：对给定的参数执行此操作
• default Consumer < T > andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
• Consumer< T >接口也被称为消费型接口，它消费的数据类型由泛型指定

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {

        operatorString("张三", (s) -> System.out.println(s));

        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.accept(name);
//        con2.accept(name);
        //返回一个组合的Consumer
        con1.andThen(con2).accept(name);
    }
}

练习：

• String[] strArray = {“张三,30”, “李四,21”, “王五,18”};
• 字符串数组中有多条信息，请按照格式：
  • 把打印姓名的动作作为第一个Consumer接口的Lambda实例
  • 把打印年龄的动作作为第二个Consumer接口的Lambda实例
  • 将两个Consumer接口按照顺序组合到一起使用

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"张三,30", "李四,21", "王五,18"};
        printInfo(strArray,
                s1 -> System.out.print("姓名：" + s1.split(",")[0] + ","),
                s2 -> System.out.println("年龄：" + s2.split(",")[1]));
    }

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

2.1.3 Predicate接口

Predicate< T >：常用的四个方法

• boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
• default Predicate< T > negate()：返回一个逻辑的否定，对应逻辑非
• default Predicate< T > and()：返回一个组合判断，对应短路与
• default Predicate< T > or()：返回一个组合判断，对应短路或
• isEqual()：测试两个参数是否相等
• Predicate< T >：接口通常用于判断参数是否满足指定的条件

test(T t) 、negate()

import java.util.function.Predicate;

public class ConsumerTest {
    public static void main(String[] args) {
        boolean string = chenkString("张三", s -> s.equals("张三"));
        System.out.println(string);

        boolean hello = chenkString("hello", s -> s.length() > 8, s -> s.length() < 18);
        System.out.println(hello);
    }

    //判定给定的字符串是否满足要求
//    private static boolean chenkString(String s, Predicate pre){
//        return pre.test(s);
//    }

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

//    private static boolean chenkString(String s, Predicate pre, Predicate pre1){
//        return pre.and(pre1).test(s);
//    }

    private static boolean chenkString(String s, Predicate<String> pre, Predicate<String> pre1){
        return pre.or(pre1).test(s);
    }
}

练习：

• String[] strArray = {“张三,30”, “李四,21”, “王五,18”};
• 字符串数组中由多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中，并遍历ArrayList集合
• 同时满足如下小球：姓名长度大于1，年龄大于20
• 分析
  • 有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
  • 必须同时满足两个条件，所以可以使用and方法连接两个判断条件

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

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"张三,30", "李四,21", "王五,18"};

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

        for (String array:
            arrayList ) {
            System.out.println(array);
        }
    }

    //通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中
    private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1,Predicate<String> pre2){
        //定义一个集合
        ArrayList<String> array = new ArrayList<>();
        //遍历数组
        for (String str :
                strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

2.1.4 Function接口

Runction：常用的两个方法

• R apply(T t)：将此函数应用于给定的参数
• default< V >：Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
• Function：接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新值

import java.util.function.Function;

public class ConsumerTest {
    public static void main(String[] args) {
        convert("18", s -> Integer.parseInt(s));

        convert(20,integer -> String.valueOf(integer+18));

        convert("245", s -> Integer.parseInt(s), integer -> String.valueOf(integer+18));
    }

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