目录
1. 函数式接口概述
函数式接口：有且仅有一个抽象方法的接口
java中的函数式编程题就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法，java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口呢？
- @FunctionalInterface
- 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意：
- 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解
实例：
MyInterface接口：
@FunctionalInterface
public interface MyInterface {
void show();
}MyInterfaceTest类：public class MyInterfaceTest {
public static void main(String[] args) {
MyInterface my = () -> System.out.println("函数式接口");
my.show();
}
}
2. 函数式接口作为方法的参数
需求：
- 定义一个类()，在类中提供两个方法
一个方法是：startThread(Runnable r):方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用startThread方法
如果方法的参数时一个函数式接口，我们可以使用Lambda表达式作为参数传递
- startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
实例：
public class RunnableTest {
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) {
new Thread(r).start();
}
}
控制台输出：
3. 函数式接口作为方法的返回值
需求：
- 定义一个类(),在类中提供两个方法
- 一个方法是：Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
- 一个方法是主方法，在主方法中调用getComparator方法
如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回
实例：
public class ComparatorTest {
public static void main(String[] args) {
//构造使用的场景
//定义集合：存储字符串元素
ArrayList<String> list = new ArrayList<>();
list.add("eee");
list.add("eea");
list.add("abvsad");
list.add("g");
System.out.println("排序前" + list);
//Collections.sort(list);
Collections.sort(list,getComparator());
System.out.println("排序后" + list);
}
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;
//使用Lambda表达式
// return (s1,s2) -> {
// return s1.length() - s2.length();
// };
return (s1, s2) -> s1.length()-s2.length();
}
}控制台输出：
4. 常用函数式接口
java 8在java.util.function包下预定义了大量的函数式接口供我们使用
我们重点学习下面的4个接口
- Supplier接口
- Consumer接口
- Predicate接口
- Funciton接口
5. Supplier接口
Supplier<T>:包含一个无参的方法
T get()：获得结果
该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
Supplier<T>接口也被成为生产型接口，如果我们置顶了接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据供我们使用
实例：
public class SupplierTest {
public static void main(String[] args) {
String s =getString(() -> {
return "周星驰";
});
System.out.println(s);
Integer i = getInteger(() -> 30);
System.out.println(i);
}
private static Integer getInteger(Supplier<Integer> sup) {
return sup.get();
}
private static String getString(Supplier<String> sup) {
return sup.get();
}
}控制台输出：
练习：
- 定义一个类（SupplierTest）,在类中提供两个方法
一个方法是：int getMax(Supplier<Integer> sup> 用于返回一个int数组中的最大值
一个方法是主方法，在主方法中调用getMax方法
实例：
public class SupplierTest2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {13,23,234,2,56,234,4564,234};
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);
}
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>接口也被成为消费型接口，它消费的数据的数据类型由泛型指定
实例：
public class ConsumerTest {
public static void main(String[] args) {
operatorString("周星驰的迷弟",(s) -> {
System.out.println(s);
});
operatorString("周星驰的迷弟2",System.out::println);
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);
}
}控制台输出：
练习：
String[] strArray = {"周星驰,55","刘德华,50","周润发,55"}
字符串数组中有多条信息，请按照格式："姓名：XXX，年龄：XX"的格式将信息打印出来
要求：
- 把打印姓名的动作作为第一个Consumer接口的Lambda实例
- 把打印年龄的动作作为第二个Consumer接口的Lambda实例
- 将两个Consumer接口按照顺序组合到一起使用
实例：
public class ConsumerTest2 {
public static void main(String[] args) {
String[] strArray = {"周星驰,55","刘德华,50","周润发,55"};
printInfo(strArray, (String str) -> {
String name = str.split(",")[0];
System.out.print("姓名:" + name);
},(String str) -> {
String age = str.split(",")[1];
System.out.println(",年龄:" + age);
});
}
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>接口通常用于判断参数是否满足指定的条件
实例：
public class PredicateTest1 {
public static void main(String[] args) {
boolean b1 = checkString("hello,world!", s -> s.length()>8);
boolean b2 = checkString("hello", s -> s.length()>8);
System.out.println(b1);
System.out.println(b2);
System.out.println("--------");
boolean b3 = checkString("hello", s -> s.length()>8, s -> s.length()<15);
boolean b4 = checkString("hello,world!", s -> s.length()>8, s -> s.length()<15);
System.out.println(b3);
System.out.println(b4);
System.out.println("--------");
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre) {
// return pre.test(s);
return pre.negate().test(s);
}
//同一个字符串给出两个不同的判断条件，最后把两个判断你的结果做逻辑与计算的结果作为最终结果
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);
}
}控制台输出：
练习：
- String[] strArray = {"林青霞,30","周星驰,59","西施,12","王祖贤,76","刘德华,58"}
- 字符串数组找那个有多条信息，请通过Predicate接口的拼接将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
- 同时满足如下要求：姓名长度大于2，年龄大于33
分析：
- 有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
- 必须同时满足两个条件，所以可以使用and方法连接两个判断条件
实例：
public class PredicateTest2 {
public static void main(String[] args) {
String[] strArray = {"林青霞,30","周星驰,59","西施,12","王祖贤,76","刘德华,58"};
ArrayList<String> list = myFilter(strArray,s -> s.split(",")[0].length()>2,s -> Integer.parseInt(s.split(",")[1])>30);
System.out.println(list);
}
private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
ArrayList<String> list = new ArrayList<String>();
for (String s:
strArray) {
if(pre1.and(pre2).test(s)) {
list.add(s);
}
}
return list;
}
}8. Function接口
Function<T,R>：常见的两个方法
- R apply(T t)：将此函数应用于给定的参数
- default<V> Function andThen(Function after)：返回一个组合函数，首先将函数应用于输入，然后将after函数应用于结果
- Funciton<T,R>接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
实例：
public class FunctionTest {
public static void main(String[] args) {
convert("100",s -> Integer.parseInt(s));
convert("100",Integer::parseInt);
System.out.println("----------");
convert(100,i -> String.valueOf(i + 67));
System.out.println("----------");
convert("240",s -> Integer.parseInt(s),i -> String.valueOf(i + 10));
}
//定义一个方法，把字符串转换成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 str = fun1.andThen(fun2).apply(s);
System.out.println(str);
}
}控制台输出：
练习：
String s = "周星驰,57";
请按照指定的要求进行操作
- 将字符串截取得到数字年龄部分
- 将上一步的年龄字符串转换成int类型的数据
- 将上一步的int数据加20，得到一个int结果，在控制台输出
通过Function接口来实现函数拼接：
实例：
public class FunctionTest2 {
public static void main(String[] args) {
String str = "周星驰,57";
convert(str,s -> {
int age = Integer.parseInt(s.split(",")[1]);
return age;
}, i -> i + 20);
}
public static void convert(String s, Function<String,Integer> fun1, Function<Integer,Integer> fun2) {
Integer i = fun1.andThen(fun2).apply(s);
System.out.println(i);
}
}控制台输出
7614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
