28_Java中的函数式接口
Java中的函数式接口
可作为一个局部变量，或者参数传递
一、函数式接口概述
函数式接口：有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中有且只有一个抽象方法，Java中的Lambda才能够顺利进行推导
如何表示一个接口是函数式接口？
@FunctionalInterface //使用这个注解放在接口定义的上方，这样可以检验接口是否为函数式接口
注意：
我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要满足接口中只有一个抽象方法就仍是函数是接口，但是推荐添加注释
参考代码：
package com.itheima_01;
@FunctionalInterface
public interface MyInterface {
void show();
//接口中的：默认、静态、私有方法都是实现体，不是“抽象方法”
default void show3(){
}
static void show4(){
}
private static void show5(){
}
}
package com.itheima_01;
/*
函数式接口：有且仅有一个抽象方法的接口
*/
public class MyInterfaceDemo {
public static void main(String[] args){
MyInterface my = () -> System.out.println("函数式接口");
my.show();
}
}
二、函数式接口作为方法的参数
需求：
定义一个类（RunnableDemo），在类中提供两个方法
一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用startThread方法
如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
参考代码：
package com.itheima_02;
/*
定义一个类（RunnableDemo），在类中提供两个方法
一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用startThread方法
*/
public class RunnableDemo {
public static void main(String[] args){
//在主方法中调用startThread方法
//使用匿名内部类的方式
/*startThread(new Runnable() {
@Override
public void run() {
//currentThread() 静态方法，获取当前线程对象
System.out.println(Thread.currentThread().getName() + "线程启动了");
}
});*/
//使用Lambda表达式
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
}
private static void startThread(Runnable r){
/*Thread t = new Thread(r);
t.start();*/
new Thread(r).start();
}
}
三、函数式接口作为方法的返回值
需求：
定义一个类（ComparatorDemo），在类中提供两个方法
一个方法是：Comparator
一个方法是主方法，在方法中调用getComparator方法
如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回
参考代码：
package com.itheima_02;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
定义一个类（ComparatorDemo），在类中提供两个方法
一个方法是：Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
一个方法是主方法，在方法中调用getComparator方法
*/
public class ComparatorDemo {
public static void main(String[] args){
//构造使用的场景
//定义一个集合存储字符串元素
ArrayList<String> array = new ArrayList<String>();
array.add("cccc");
array.add("aa");
array.add("b");
array.add("ddd");
System.out.println("排序前：" + array);
// 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 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();
};
}
}
四、常用的函数式接口
Java8在java.util.function包下预定了大量的函数式接口供我们使用
我们重点了解一下一下四个接口：
Supplier接口
Consumer接口
Predicate接口
Function接口
1、Supplier接口（生产数据）：
Supplier
T get()：获得结果
该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
Supplier
参考代码：
package com.itheima_03;
import java.util.function.Supplier;
public class SupplierDemo {
public static void main(String[] args){
// String s = getString(() -> {
// return "张三";
// });
String s = getString(() -> "张三");
System.out.println(s);
Integer i = getInteger(() -> 30);
System.out.println(i);
}
//定义一个方法，返回一个整数数据
private static Integer getInteger(Supplier<Integer> s){
return s.get();
}
//定义一个方法，返回一个字符串数据
private static String getString(Supplier<String> s){
return s.get();
}
}
练习：
定义一个类（SupplierTest），在类中提供两个方法
一个方法是：int getMax(Supplier
一个方法是主方法，在主方法中调用getMax方法
参考代码：
package com.itheima_03;
import java.util.function.Supplier;
/*
定义一个类（SupplierTest），在类中提供两个方法
一个方法是：int getMax(Supplier<Integer> sup) 用于返回一个int数组中的最大值
一个方法是主方法，在主方法中调用getMax方法
*/
public class SupplierTest {
public static void main(String[] args){
//定义一个int数组
int[] arr = {19, 50, 28, 37, 46};
int maxValue = getMax(() -> {
int max = arr[0];
for(int i = 1; i < arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
return max;
});
System.out.println(maxValue);
}
//用于返回一个int数组中的最大值
private static int getMax(Supplier<Integer> sup){
return sup.get(); //具体的实现动作由Lambda表达式来完成
}
}
2、Consumer接口（处理数据）：
Consumer
void accept(T t)：对给定的参数执行此操作
default Consumer
Consumer
参考代码：
package com.itheima_04;
import java.util.function.Consumer;
/*
Consumer<T>：包含两个方法
void accept(T t)：对给定的参数执行此操作
default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
Consumer<T> 接口也被称为消费型接口（处理数据），它消费的数据的数据类型由泛型指定
*/
public class ConsumerDemo {
public static void main(String[] args){
//使用Lambda表达式
/*operatorString("张三", (String s) -> {
System.out.println(s); //对这个传递的参数进行输出操作
});*/
operatorString("张三", (s) -> System.out.println(s));
/*//使用方法引用
operatorString("李四", System.out::println);*/
operatorString("王五", (s) -> {
//将通过StringBuilder将字符串反转后，再进行字符串转换输出
System.out.println(new StringBuilder(s).reverse().toString());
});
System.out.println("----------------------");
operatorString("张三", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
}
//定义一个方法，用不同的方式消费同一个字符串数据两次
private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2){
//常规操作
// con1.accept(name);
// con2.accept(name);
//使用接口中的默认方法
//其实本质也是分别调用accept方法
con1.andThen(con2).accept(name);
}
//定义一个方法，消费字符串数据
private static void operatorString(String name, Consumer<String> con){
con.accept(name);
}
}
练习：
String[] strArray = {"张三,30", "李四,33","王五,34"};
字符串数组中有多条信息，请按照格式："姓名：XX, 年龄：XX"的格式将信息打印出来
要求：
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
参考代码：
package com.itheima_04;
import java.util.function.Consumer;
/*
String[] strArray = {"张三,30", "李四,33","王五,34"};
字符串数组中有多条信息，请按照格式："姓名：XX, 年龄：XX"的格式将信息打印出来
要求：
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
*/
public class ConsumerTest {
public static void main(String[] args) {
String[] strArray = {"张三,30", "李四,33","王五,34"};
//使用Lambda表达式的方法传递
/*printInfo(strArray, (String str) -> {
String name = str.split(",")[0]; //split方法返回一个String[] 此处根据下标所以获取对应位置值
System.out.print("姓名：" + name + ", ");
}, (String str) -> {
int age = Integer.parseInt(str.split(",")[1]);
System.out.println("年龄：" + age);
});*/
printInfo(strArray, str -> System.out.print("姓名：" + str.split(",")[0] + ", "), str -> System.out.println(Integer.parseInt(str.split(",")[1])));
}
private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2){
for(String str : strArray){
con1.andThen(con2).accept(str);
}
}
}
3、Predicate接口（判断参数是否满足条件）：
Predicate
boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
default Predicate
default Predicate
default Predicate
Predicate
参考代码（前两个方法）：
package com.itheima_05;
import java.util.function.Predicate;
/*
Predicate<T>：常用的四个方法中的两个
boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非
*/
public class PredicateDemo01 {
public static void main(String[] args){
/*boolean b1 = checkString("hello", (String s) -> {
return s.length() > 8; //这个字符串的长度是否大于八
});*/
//简化Lambda表达式参数
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<String> pre){
// return pre.test(s); //具体逻辑用Lambda表达式来实现
//对结果进行一个逻辑非的运算
// return !pre.test(s);
return pre.negate().test(s); //negate对这个对象进行逻辑非操作，并返回这个对象
}
}
参考代码（后两个方法）：
package com.itheima_05;
import java.util.function.Predicate;
/*
后两个方法
default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与
default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或
*/
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){
/*boolean b1 = pre1.test(s);
boolean b2 = pre2.test(s);
boolean b = b1 && b2;
return b;*/
// return pre1.and(pre2).test(s);
return pre1.or(pre2).test(s);
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre){
return pre.test(s);
}
}
练习：
String[] strArray = {"张三,30","李四,34","王五,36","赵六,33","小老七,34"};
字符串数组中有多条信息，请通过Predicate接口的拼装将符合条件的字符串筛选到集合ArrayList中，并遍历ArrayList集合
同时满足如下要求：姓名长度大于2，年龄大于33
参考代码：
package com.itheima_05;
import java.util.ArrayList;
import java.util.function.Predicate;
/*
String[] strArray = {"张三,30","李四,34","王五,36","赵六,33","小老七,34"};
字符串数组中有多条信息，请通过Predicate接口的拼装将符合条件的字符串筛选到集合ArrayList中，并遍历ArrayList集合
同时满足如下要求：姓名长度大于2，年龄大于33
*/
public class PredicateTest {
public static void main(String[] args){
//定义一个字符串数组
String[] strArray = {"张三,30","李四,34","王五,36","赵六,33","小老七,34"};
ArrayList<String> array = null;
array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
s -> Integer.parseInt(s.split(",")[1]) > 33);
System.out.println("满足条件的数据：" + array);
}
//通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
private static ArrayList<String> myFilter(String[] str, Predicate<String> pre1, Predicate<String> pre2){
//定义一个集合
ArrayList<String> array = new ArrayList<String>();
//遍历字符串数组
for(String s : str){
if(pre1.and(pre2).test(s)){
array.add(s);
}
}
return array;
}
}
4、Function接口（将前一个泛型数据 转换 为后一个泛型数据）：
Function<T, R>：常用的两个方法
R apply(T t)：将此函数应用于给定的参数
default
Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑用Lambda表达式实现），然后返回一个新的值
参考代码：
package com.itheima_06;
import java.util.function.Function;
/*
Function<T, R>：常用的两个方法
R apply(T t)：将此函数应用于给定的参数
default<V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑用Lambda表达式实现），然后返回一个新的值
*/
public class FunctionDemo {
public static void main(String[] args){
/* convert("100", (String s) -> {
return Integer.parseInt(s);
});*/
convert("100", s -> Integer.parseInt(s)); //Lambda表达式
// convert("100", Integer::parseInt); //方法引用，将Lambda参数传递给类中的静态方法
System.out.println("----------");
convert(100, i -> String.valueOf(i + 566));
System.out.println("----------");
convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 899));
}
//定义一个方法，把字符串转换为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){
/*Integer i = fun1.apply(s);
String str = fun2.apply(i);*/
String str = fun1.andThen(fun2).apply(s);
System.out.println(str);
}
}
练习：
String s = "林青霞,30";
请按照我指定的要求进行操作：
1、将字符串截取得到数字即年龄部分
2、将上一步的年龄字符串转换成int类型的数据
3、将上一步的int数据加70，得到一个int结果，在控制台输出
请通过Function接口来实现函数拼接
参考代码：
package com.itheima_06;
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, (String ss) -> {
return s.split(",")[1]; //截取得到数字即年龄部分
}, (String ss) -> {
return Integer.parseInt(ss); //年龄字符串转换成int类型的数据
}, (Integer i) -> {
return i + 70; //数据加70，得到一个int结果
});*/
//简化后
convert(s, ss -> s.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){
int i = fun1.andThen(fun2).andThen(fun3).apply(s);
System.out.println(i);
}
}
