JavaSE 函数式接口
1. 函数式接口
1.1 函数式接口概述
函数式接口：有且仅有一个抽象方法的接口
Java中的函数式编程体现的就是Lambda表达式，所以函数式接口就是可以使用于Lambda表达式的接口
如何检测一个接口是不是函数接口？
- @FunctionalInterface
- 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意：
- 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要满足函数式接口定义的条件，也照样是函数式接口。但是，建议 加上该注解
1.2 函数式接口作为方法的参数
package cappuccino.interface02;
/*
定义一个类（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() + "线程启动了"));
}
private static void startThread(Runnable r){
// Thread t = new Thread(r);
// t.start();
new Thread(r).start();
}
}
如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
- startThread(() -> System.out.println(Thread.currentThread().getName() + “线程启动了”));
1.3 函数式接口作为方法的返回值
package cappuccino.interface03;
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("bug");
array.add("cappuccino");
array.add("njust");
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();
}
}
如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回
private static Comparator<String> getComparator(){
return (s1,s2) -> s1.length()-s2.length();
}
1.4 常用的函数式接口
Java 8 在 java.util.function 包下预定义了大量的函数式接口供我们使用
重点学习下面4个接口：
- Supplier 接口
- Consumer 接口
- Predicate 接口
- Function 接口
1.4.1 Supplier 接口
Supplier<T>:包含一个无参的方法
- T get():获得结果
- 该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
- Supplier<T>接口也被称为生产型接口，如果指定了接口的泛型是什么类型，那么接口中的 get() 方法就会产生什么类型的数据供我们使用
package cappuccino.interface04;
import java.util.function.Supplier;
/*
Supplier<T>:包含一个无参的方法
T get():获得结果
该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
Supplier<T>接口也被称为生产型接口，如果指定了接口的泛型是什么类型，那么接口中的 get() 方法就会产生什么类型的数据供我们使用
*/
public class SupplierDemo {
public static void main(String[] args) {
// String s = getString(() ->{
// return "半仙儿努力考研";
// });
// System.out.println(s);
String s = getString(() -> "半仙儿努力考研");
System.out.println(s);
Integer i = getInteger(() -> 376);
System.out.println(i);
}
//定义一个方法，返回一个字符串数据
private static String getString(Supplier<String> sup){
return sup.get();
}
//定义一个方法，返回一个整数数据
private static Integer getInteger(Supplier<Integer> sup){
return sup.get();
}
}
练习：
package cappuccino.interface04;
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 = {67,76,27,376,367};
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();
}
}
1.4.2 Consumer 接口
Consumer<T>:包含两个方法
- void accept(T t):对给定的参数执行此操作
- default Consumer<T> andThen(Consumer after): 返回一个组合的Consumer，依次执行此操作，然后执行 after 操作
- Consumer<T>接口也被称为消费型接口，它消费的数据的类型由泛型指定
package cappuccino.interface05;
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("半仙儿", 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> con) {
con.accept(name);
}
//定义一个方法，用不同的方式消费同一个字符串数据两次
private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
con1.accept(name);
con2.accept(name);
con1.andThen(con2).accept(name);
}
}
练习：
package cappuccino.interface05;
import java.util.function.Consumer;
/*
String[] strArr = {"苦瓜,21","半仙儿,22","bug,24"}
字符串数组中有多条信息，请按照格式："姓名:xx,年龄:xx"的格式将信息打印出来
要求：
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
*/
public class ConsumerTest {
public static void main(String[] args) {
String[] strArr = {"苦瓜,21", "半仙儿,22", "bug,24"};
// printInfo(strArr,(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(strArr, str -> System.out.print("姓名:" + str.split(",")[0]),
str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1])));
}
private static void printInfo(String[] strArr, Consumer<String> con1, Consumer<String> con2) {
for (String str : strArr) {
con1.andThen(con2).accept(str);
}
}
}
1.4.3 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 cappuccino.interface06;
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("bug",(String s) -> {
// return s.length() > 3;
// });
boolean b1 = checkString("bug", s -> s.length() > 3);
System.out.println(b1);
boolean b2 = checkString("cappuccino", s -> s.length() > 6);
System.out.println(b2);
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre) {
// return pre.test(s);
return pre.negate().test(s);
}
}
package cappuccino.interface06;
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 PredicateDemo02 {
public static void main(String[] args) {
boolean b1 = checkString("bug", s -> s.length() > 3);
System.out.println(b1);
boolean b2 = checkString("cappuccino", s -> s.length() > 6);
System.out.println(b2);
boolean b3 = check("bug",s->s.length()<3,s -> s.length()>2);
System.out.println(b3);
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre){
return pre.test(s);
}
//同一个字符串给出两个不同的判断条件，最后把这两个判断结果做逻辑与运算的结果作为最终结果
private static boolean check(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);
}
}
练习：
package cappuccino.interface06;
import java.util.ArrayList;
import java.util.function.Predicate;
/*
String[] strArray = {"苦瓜,350","半仙儿,376","bug,367"};
字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到ArrayList集合中，并遍历集合
要求：
1.姓名长度大于2
2.分数大于370
分析：
1.有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
2.必须同时满足两个条件，所以使用and方法连接两个判断条件
*/
public class PredicateDemo03 {
public static void main(String[] args) {
String[] strArray = {"苦瓜,350", "半仙儿,376", "bug,367"};
ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
s -> Integer.parseInt(s.split(",")[1]) > 370);
for (String str : array) {
System.out.println(str);
}
}
//通过Predicate接口的拼装将符合要求的字符串筛选到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;
}
}
1.4.4 Function 接口
Function<T,R>的两个常用方法：
- R apply(T t):将此函数应用于给定的参数
- default <V> Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
package cappuccino.interface07;
import java.util.function.Function;
/*
Function<T,R>的两个常用方法：
1. R apply(T t):将此函数应用于给定的参数
2. default <V> Function andThen(Function after):
返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
*/
public class FunctionDemo {
public static void main(String[] args) {
// convert("376",(String s)->{
// return Integer.parseInt(s);
// });
convert("376", s -> Integer.parseInt(s));
convert("376", Integer::parseInt);//方法引用
System.out.println("-------");
convert(367, i -> String.valueOf(i + 30 ));
System.out.println("-------");
convert("376",s->Integer.parseInt(s),i->String.valueOf(i+40));
}
//定义一个人方法，把一个字符串转换为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);
}
}
练习：
package cappuccino.interface07;
import java.util.function.Function;
/*
String s = "半仙儿,376";
要求：
1.将字符串截取得到数字部分
2.将上一步的数字字符串转换为int类型的数据
3.将上一步的int类型数据加40，得到一个int结果，在控制台输出
通过Predicate接口实现函数拼接
*/
public class FunctionTest {
public static void main(String[] args) {
String s = "半仙儿,376";
convert(s, (String ss) -> {
return s.split(",")[1];
}, (String ss) -> {
return Integer.parseInt(ss);
}, (Integer i) -> {
return i + 40;
});
// convert(s, ss -> ss.split(",")[1],
// ss -> Integer.parseInt(ss),
// i -> i + 40);
}
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);
}
}
127
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
