1、函数式接口概述
函数式接口:有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式,所以函数式接口就是可以适用于Lambda使用的接口,只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口?
-
@FunctionalInterface
- 放在接口定义的上方:如果接口是函数式接口,编译通过;如果不是,编译失败
注意
- 我们自己定义函数式接口的时候,@FunctionalInterface是可选的,就算不写这个注解,只要保证满足函数式接口定义的条件,也同样是函数式接口。但是,建议加上该注解
2、函数式接口作为方法的参数
需求
- 定义一个类(RunnableDemo),在类中提供两个方法
- 一个方法是:startThread(Runnable r) 方法参数Runnable是一个函数式接口
- 一个方法是主方法,在主方法中调用startThread方法
如果方法的参数是一个函数式接口,我们可以使用Lambda表达式作为参数传递
- startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动"));
package FunctionInterface02;
/*
定义一个类(RunnableDemo),在类中提供两个方法
一个方法是:startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法,在主方法中调用startThread方法
*/
public class RunnableDemo {
public static void main(String[] args) {
//在主方法中调用startThread方法
//匿名内部类的方式
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程启动");
}
});
//Lambda表达式
startThread(() -> {
System.out.println(Thread.currentThread().getName() + "线程启动");
});
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动"));
}
private static void startThread(Runnable r) {
// Thread t = new Thread(r);
// t.start();
new Thread(r).start();
}
}
3、函数式接口作为方法的返回值
需求:
- 定义一个类(ComparatorDemo),在类中提供两个方法
- 一个方法是:Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
- 一个方法是主方法,在主方法中调用getComparator方法
如果方法的返回值是一个函数式接口,我们可以使用Lambda表达式作为结果返回
private static Comparator<String> getComparator() {
return (s1, s2) -> s1.length() - s2.length();
}
package FunctionInterface03;
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);
System.out.println("排序后:" + 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();
// };
return (s1, s2) -> s1.length() - s2.length();
}
}
4、常用的函数式接口
Java8在java.util.function包下预定义了大量的函数式接口供我们使用
- Supplier接口
- Consumer接口
- Predicate接口
- Function接口
5、Supplier接口
Supplier<T>:包含一个无参的方法
- T get():获得结果
- 该方法不需要参数,它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
- Supplier<T>接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据供我们使用
package FunctionInterface03;
import java.util.function.Supplier;
/*
Supplier<T>:包含一个无参的方法
T get():获得结果
该方法不需要参数,它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
Supplier<T>接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据供我们使用
*/
public class RunnableDemo {
public static void main(String[] args) {
// String s = getString(() -> {
// return "刘亦菲";
// });
String s = getString(() -> "刘亦菲");
System.out.println(s);
// int i = getInt(() -> {
// return 5;
// });
int i = getInt(() -> 5);
System.out.println(i);
}
//定义一个方法返回一个整数数据
private static int getInt(Supplier<Integer> i) {
return i.get();
}
//定义一个方法返回一个字符串数据
private static String getString(Supplier<String> sup) {
return sup.get();
}
}
练习:获取数组中最大值
- 定义一个类(SupplierTest),在类中提供两个方法
- 一个方法是:int getMax(Supplier<Integer> sup) 用于返回一个int数组中的最大值
- 一个方法是主方法,在主方法中调用getMax方法
package FunctionInterface03;
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 = {25, 36, 89, 65, 12, 34, 53};
int maxValue = getMax(() -> {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
});
System.out.println(maxValue);
}
private static int getMax(Supplier<Integer> sup) {
return sup.get();
}
}
6、Consumer接口
Consumer<T>:包含两个方法
- void accept(T t):对给定的参数执行此操作
- default Consumer<T> andThen(Consumer after):返回一个组合的Consumer,依次执行此操作,然后执行after操作
- Consumer<T>接口也被称为消费型接口,它消费的数据的数据类型由泛型指定
package FunctionInterface04;
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) {
operatorString("刘亦菲", (String s) -> {
System.out.println(s);
});
operatorString("刘亦菲", s -> System.out.println(s));
operatorString("刘亦菲", System.out::println);
operatorString("刘亦菲", (String s) -> {
System.out.println(new StringBuilder(s).reverse().toString());
});
operatorString("刘亦菲", s -> 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);
con1.andThen(con2).accept(name);
}
//定义一个方法,消费一个字符串数据
private static void operatorString(String name, Consumer<String> con) {
con.accept(name);
}
}
练习
- String[] strArray = {"刘亦菲,36","杨幂,30","王祖贤,40”};
- 字符串数组中有多条信息,请按照格式:“姓名:XX,年龄:XX”的格式打印信息
- 要求:
- 把打印姓名的动作作为第一个Consumer接口的Lambda实例
- 把打印年龄的动作作为第二个Consumer接口的Lambda实例
- 将两个Consumer接口按照顺序组合到一起使用
package FunctionInterface04;
import java.util.function.Consumer;
/*
String[] strArray = {"刘亦菲,36","杨幂,30","王祖贤,40”};
字符串数组中有多条信息,请按照格式:“姓名:XX,年龄:XX”的格式打印信息
要求:
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
*/
public class ConsumerTest {
public static void main(String[] args) {
String[] strArray = {"刘亦菲,36", "杨幂,30", "王祖贤,40" };
printInfo(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);
});
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);
}
}
}
7、Predicate接口
Predicate<T>:常用的四个方法
- boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
- default Predicate<T> negate():返回一个逻辑地否定,对应逻辑非
- default Predicate<T> and(Predicate other):返回一个组合判断,对应短路与
- default Predicate<T> or(Predicate other):返回一个组合判断,对应短路或
- Predicate<T>接口通常用于判断参数是否满足指定的条件
package FunctionInterface05;
import java.util.function.Predicate;
/*
Predicate<T>:常用的四个方法
boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
default Predicate<T> negate():返回一个逻辑地否定,对应逻辑非
default Predicate<T> and(Predicate other):返回一个组合判断,对应短路与
default Predicate<T> or(Predicate other):返回一个组合判断,对应短路或
Predicate<T>接口通常用于判断参数是否满足指定的条件
*/
public class PredicateDemo01 {
public static void main(String[] args) {
// boolean b1 = checkString("hello", (String s) -> {
// return s.length() > 8;
// });
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);
// return !pre.test(s);
return pre.negate().test(s);
}
}
练习:
- String[] strArray = {"林青霞,30","柳岩,34","张曼玉,35","杨幂,31","王祖贤,33"};
- 字符串数组中有多条信息,请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中,并遍历ArrayList集合
- 同时满足如下要求:姓名长度大于2;年龄大于33
- 分析
- 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
- 必须同时满足两个条件,所以可以使用and方法连接两个判断条件
package FunctionInterface05;
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 PredicateTest {
public static void main(String[] args) {
String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "杨幂,31", "王祖贤,33"};
// ArrayList<String> array = myFilter(strArray, (String s) -> {
// return s.split(",")[0].length() > 2;
// }, (String s) -> {
// return Integer.parseInt(s.split(",")[1]) > 33;
// });
ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
s -> Integer.parseInt(s.split(",")[1]) > 33);
for (String str : array) {
System.out.println(str);
}
}
//通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
//返回一个ArrayList
private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
//定义一个集合
ArrayList<String> array = new ArrayList<String>();
//遍历数组
for (String str : strArray) {
if (pre1.and(pre2).test(str)) {
array.add(str);
}
}
return array;
}
}
8、Function接口
Function<T>:常用的两个方法
- R apply(T t):将此函数应用于给定的参数
- default<V> Function andThen(Function after):返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
- Function<T,R>接口通常用于对参数进行处理,转换(处理逻辑由Lambda表达式实现),然后返回一个新的值
package FunctionInterface06;
import java.util.function.Function;
/*
Function<T>:常用的两个方法
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));
convert("100", Integer::parseInt);
// convert(100,(Integer i)->{
// return String.valueOf(i+566);
// });
convert(100, i -> String.valueOf(i + 566));
// convert("100", (String s) -> {
// return Integer.parseInt(s);
// }, (Integer i) -> {
// return String.valueOf(i + 566);
// });
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) {
// 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);
}
}
练习:
- String s = "林青霞,30";
- 需求:
- 将字符串截取得到数字年龄部分
- 将上一步的年龄字符串转换成int类型的数据
- 将上一步的int类型数据加70,得到一个int结果,在控制台输出
- 请通过Function接口来实现函数拼接
package FunctionInterface06;
import java.util.function.Function;
/*
String s = "林青霞,30";
需求:
将字符串截取得到数字年龄部分
将上一步的年龄字符串转换成int类型的数据
将上一步的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);
}, (Integer i) -> {
return i + 70;
});
//优化
convert(s, ss -> s.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
//优化
convert(s, ss -> s.split(",")[1], Integer::parseInt, i -> i + 70);
}
private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
// Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
int i = fun1.andThen(fun2).andThen(fun3).apply(s);
System.out.println(i);
}
}