函数式接口 - 《Java SE》

1.函数式接口概述【理解】
2.函数式接口作为方法的参数【应用】
4.常用函数式接口

1.函数式接口概述【理解】

概念
有且仅有一个抽象方法的接口
如何检测一个接口是不是函数式接口
@FunctionalInterface
放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意事项
我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

2.函数式接口作为方法的参数【应用】

需求描述
定义一个类(RunnableDemo)，在类中提供两个方法
一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用startThread方法
代码演示 ```java

/**

定义一个类(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()+"启动了");
     }
 });
 //lambda表达式
 startThread(() -> System.out.println(Thread.currentThread().getName()+"启动了"));

}

static void startThread(Runnable r){

 new Thread(r).start();

} }

<a name="9gD0P"></a>
## 3.函数式接口最为方法的返回值【应用】
- 需求描述<br />定义一个类(ComparatorDemo)，在类中提供两个方法<br />一个方法是：Comparator<String> getComparator()   方法返回值Comparator是一个函数式接口<br />一个方法是主方法，在主方法中调用getComparator方法
- 代码演示
```java
/**
 * 定义一个类(ComparatorDemo)，在类中提供两个方法
 * 一个方法是：Comparator<String> getComparator()   方法返回值Comparator是一个函数式接口
 * 一个方法是主方法，在主方法中调用getComparator方法
 */
public class ComparatorDemo {
    public static void main(String[] args) {
        Comparator<String> comparator = getComparator();
    }
    static Comparator<String> getComparator() {
        //匿名内部类的方式
//        return new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };
        //lambda表达式的方式
        return (o1, o2) -> o1.length() - o2.length();
    }
}

4.常用函数式接口

Java内置四大核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象应用操作，包含方法：void accept(T t)
Supplier 供给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function 函数式接口	T	R	对类型为T的对象应用操作，并返回结果R类型的对象。包含方法：R apply(T t)
Predicate 断定型接口	T	Boolean	确定类型为T的对象是否满足约束，并返回Boolean值。包含方法：Boolean test(T t)

4.1 Supplier —— 供给型接口（有返回值，无参数）

4.1.1常见函数式接口之Supplier【应用】

Supplier接口
Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。
常用方法
只有一个无参的方法 | 方法名 | 说明 | | —- | —- | | T get() | 按照某种实现逻辑(由Lambda表达式实现)返回一个数据 |
代码演示 ```java

import java.util.function.Supplier;

public class SupplierDemo {

public static void main(String[] args) {
    //匿名内部类的方式调用getString方法
    System.out.println(getString(new Supplier<String>() {
        @Override
        public String get() {
            return "匿名内部类方式的调用";
        }
    }));
    //lambda表达式的方式调用getString方法
    System.out.println(getString(() -> "lambda表达式的方式调用"));
    //匿名内部类的方式调用getInt方法
    System.out.println(getInt(new Supplier<Integer>() {
        @Override
        public Integer get() {
            return 123;
        }
    }));
    //lambda表达式的方式调用getString方法
    System.out.println(getInt(() -> 456));
}
//定义一个方法，返回一个字符串
static String getString(Supplier<String> supplier) {
    return supplier.get();
}
//定义一个方法，返回一个整数
static int getInt(Supplier<Integer> supplier) {
    return supplier.get();
}

}


<a name="WikbJ"></a>
#### 4.1.2Supplier接口练习----获取最大值【应用】
- 案例需求<br />定义一个类(SupplierTest)，在类中提供两个方法<br />一个方法是：int getMax(Supplier sup)   用于返回一个int数组中的最大值<br />一个方法是主方法，在主方法中调用getMax方法
- 示例代码
```java
import java.util.function.Supplier;
/**
 * 定义一个类(SupplierTest)，在类中提供两个方法
 * 一个方法是：int getMax(Supplier sup)   用于返回一个int数组中的最大值
 * 一个方法是主方法，在主方法中调用getMax方法
 */
public class SupplierTest {
    public static void main(String[] args) {
        int[] arr = {1,4,3,2,6,7,4,3};
        //匿名内部类方式
        System.out.println("maxValue="+getMax(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int max = arr[0];
                for (int i : arr) {
                    if (i > max) max = i;
                }
                return max;
            }
        }));
        //lambda表达式的方式
        System.out.println("maxValue="+getMax(() -> {
            int max = arr[0];
            for (int i : arr) {
                if (i > max) max = i;
            }
            return max;
        }));
    }
    static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

4.2Consumer —— 消费型接口（无返回值，有参数）

4.2.1 常用函数式接口之Consumer【应用】

Consumer接口
Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
常用方法
Consumer：包含两个方法 | 方法名 | 说明 | | —- | —- | | void accept(T t) | 对给定的参数执行此操作 | | default Consumer andThen(Consumer after) | 返回一个组合的Consumer，依次执行此操作，然后执行 after操作 |
代码演示 ```java

import java.util.function.Consumer;

public class ConsumerDemo2 { public static void main(String[] args) { String s = “这是一个字符串”; //=================================================================================== //调用方法消费一次字符串

    //匿名内部类的方式
    useString(s, new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
    //lambda表达式的方式
    useString(s,(s1)->System.out.println(s1));
    //方法引用
    useString(s,System.out :: println);
    System.out.println("=====================================================================================");
    //调用方法消费两次字符串
    //匿名内部类
    useString(s, new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(new StringBuffer(s).reverse().toString());
        }
    }, new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
    //lambda表达式
    useString(s,s1->System.out.println(new StringBuffer(s1).reverse().toString()),s2-> System.out.println(s2));
    //再简化--》 方法引用
    useString(s,s1->System.out.println(new StringBuffer(s1).reverse().toString()),System.out::println);
}
//定义一个方法消费字符串一次
static void useString(String s,Consumer<String> con){con.accept(s);}
//定义一个方法消费字符串两次
static void useString(String s, Consumer<String> con1, Consumer<String> con2){
    con1.andThen(con2).accept(s);
}

}


<a name="xvZOz"></a>
#### 4.2.2 Consumer接口练习之按要求打印信息【应用】
- 案例需求<br />String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};<br />字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来<br />要求：<br />把打印姓名的动作作为第一个Consumer接口的Lambda实例<br />把打印年龄的动作作为第二个Consumer接口的Lambda实例<br />将两个Consumer接口按照顺序组合到一起使用
- 示例代码
```java
import java.util.function.Consumer;
/**
 * String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
 * 字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来
 * 要求：
 * 把打印姓名的动作作为第一个Consumer接口的Lambda实例
 * 把打印年龄的动作作为第二个Consumer接口的Lambda实例
 * 将两个Consumer接口按照顺序组合到一起使用
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
        System.out.println("匿名内部类的方式");
        for (String s : strArray) {
            printFormat(s, new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.print("姓名:" + s.split(",")[0]);
                }
            }, new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println(",年龄:" + s.split(",")[1]);
                }
            });
        }
        System.out.println("lambda表达式的方式");
        for (String s : strArray) {
            printFormat(s, s1 -> System.out.print("姓名：" + s.split(",")[0]), s2 -> System.out.println("，年龄：" + s.split(",")[1]));
        }
    }
    //    定义按照格式打印的方法
    static void printFormat(String s, Consumer<String> con1, Consumer<String> con2) {
        con1.andThen(con2).accept(s);
    }
}

4.3 Predicate —— 断定型接口（返回值为boolean，有参数）

4.3.1 常用函数式接口之Predicate【应用】

Predicate接口
Predicate接口通常用于判断参数是否满足指定的条件
常用方法 | 方法名 | 说明 | | —- | —- | | boolean test(T t) | 对给定的参数进行判断（判断逻辑由lambda表达式实现），返回一个布尔值 | | default Predicate negate() | 返回一个逻辑的否定，对用逻辑非—>！ | | default Predicate and(Predicate other) | 返回一个组合判定，对应短路与—>&& | | default Predicate or(Predicate other) | 返回一个组合判断，对应短路或—>|| |
代码演示 ```java public class PredicateDemo01 { public static void main(String[] args) {
```
  boolean b1 = checkString("hello", s -> s.length() > 8);
  System.out.println(b1);
  boolean b2 = checkString("helloworld",s -> s.length() > 8);
  System.out.println(b2);
```
}

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

public class PredicateDemo02 { public static void main(String[] args) { boolean b1 = checkString(“hello”, s -> s.length() > 8); System.out.println(b1); boolean b2 = checkString(“helloworld”, s -> s.length() > 8); System.out.println(b2);

    boolean b3 = checkString("hello",s -> s.length() > 8, s -> s.length() < 15);
    System.out.println(b3);
    boolean b4 = checkString("helloworld",s -> s.length() > 8, s -> s.length() < 15);
    System.out.println(b4);
}
//同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
    return pre1.or(pre2).test(s);
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre) {
    return pre.test(s);
}

}

<a name="cwQIv"></a>
#### 4.3.2 Predicate接口练习之筛选满足条件数据【应用】
- 练习描述
   - String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
   - 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
   - 同时满足如下要求：姓名长度大于2；年龄大于33
- 分析
   - 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
   - 必须同时满足两个条件,所以可以使用and方法连接两个判断条件
- 示例代码
```java
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 PredicateDemo {
//    public static void main(String[] args) {
//        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
//        ArrayList<String> result=new ArrayList<String>();
//
//        for (String s : strArray) {
//            if (myFilter(s, new Predicate<String>() {
//                @Override
//                public boolean test(String s) {
//                    return s.split(",")[0].length()>2;
//                }
//            }, new Predicate<String>() {
//                @Override
//                public boolean test(String s) {
//                    return Integer.parseInt(s.split(",")[1])>33;
//                }
//            })) {
//                result.add(s);
//            }
//        }
//        for (String s : result) {
//            System.out.println(s);
//        }
//    }
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        ArrayList<String> result=new ArrayList<String>();
//遍历数组，把符合条件的字符串放入集合中
        for (String s : strArray) {
            if (myFilter(s, s1 -> s1.split(",")[0].length()>2, s2 -> Integer.parseInt(s.split(",")[1])>33)) {
                result.add(s);
            }
        }
        for (String s : result) {
            System.out.println(s);
        }
    }
    //定义方法筛选符合条件的字符串
    static boolean myFilter(String s, Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(s);
    }
}

4.4 Function —— 函数式接口（有参数，有返回值）

4.4.1

Function接口

Function接口通常用于对参数进行处理，转换（处理逻辑由lambda表达式实现），然后返回一个新的值

常用方法 | 方法名 | 说明 | | —- | —- | | 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(100,i -> String.valueOf(i + 566));
        //使用andThen的方式连续执行两个操作
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
    }
    //定义一个方法，把一个字符串转换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) {
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

4.4.2Function接口练习之按照指定要求操作数据【应用】

练习描述
- String s = “林青霞,30”;
- 请按照我指定的要求进行操作：
  1:将字符串截取得到数字年龄部分
  2:将上一步的年龄字符串转换成为int类型的数据
  3:将上一步的int数据加70，得到一个int结果，在控制台输出
- 请通过Function接口来实现函数拼接
示例代码