Java基础学习笔记27——函数式接口
目录
1、函数式接口概述
函数式接口：有且仅有一个抽象方法的接口。
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda表达式才能顺利地进行推导。
如何检测一个接口是不是函数式接口呢？
- @FunctionalInterface
- 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。
注意：
- 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解。
代码演示：
package Inter4Package;
//函数式接口
@FunctionalInterface
public interface Inter {
void show();
}
public class Test {
public static void main(String[] args) {
Inter i = () -> System.out.println("show");
i.show;
}
}
结果：
show2、函数式接口作为方法的参数
如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递。
代码演示：
package Inter4Package;
public class Test {
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()+"线程启动了"));
}
private static void startThread(Runnable r) {
Thread t = new Thread(r);
t.start();
}
}
结果：
Thread-0线程启动了
Thread-1线程启动了3、函数式接口作为方法的返回值
如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回。
代码演示：
package Inter5Package;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Test {
public static void main(String[] args) {
//构造使用场景
//定义集合，存储字符串元素
ArrayList<String> array = new ArrayList<String>();
array.add("ccccc");
array.add("aa");
array.add("b");
array.add("ddd");
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;
//Lambda表达式
// return (String s1, String s2) -> {
// return s1.length() - s2.length();
// };
return (s1, s2) -> s1.length() - s2.length();
}
}
结果：
排序前[ccccc, aa, b, ddd]
排序后[b, aa, ddd, ccccc]4、常用的函数式接口
Java 8在java.util.function包下预定义了大量的函数式接口供我们使用。
4.1、Supplier接口
Supplier<T>：包含一个无参的方法：
- T get()：获得结果；
- 该方法不需要参数，他会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
- Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get()方法就会生产什么类型的数据供我们使用。
代码演示：
package SupplierPackage;
import java.util.function.Supplier;
public class Test {
public static void main(String[] args) {
String s1 = getString(() -> {
return "张三";
});
String s2 = getString(() -> "李四");
System.out.println(s1);
System.out.println(s2);
Integer i = getInteger(() -> 1);
System.out.println(i);
}
//定义一个方法，返回一个整数数据
private static Integer getInteger(Supplier<Integer> sup) {
return sup.get();
}
//定义一个方法，返回一个字符串数据
private static String getString(Supplier<String> sup) {
return sup.get();
}
}
结果：
张三
李四
14.2、Consumer接口
Consumer<T>：包含两个方法：
- void accept(T t)：对给定的参数执行此操作。
- default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作。
- Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定。
代码演示：
package ConsumerPackage;
import java.util.function.Consumer;
public class Test {
public static void main(String[] args) {
operateString("张三", (String s) -> {
System.out.println(s);
});
operateString("张四", s -> System.out.println(s));
operateString("张五", System.out::println);
operateString("张六", s -> {
StringBuilder sb = new StringBuilder(s);
String ss = sb.reverse().toString();
System.out.println(ss);
});
System.out.println("--------------");
operateString("李三", s -> System.out.println(s),
s -> System.out.println(new StringBuilder(s).reverse().toString()));
}
//定义一个方法，用不同的方式消费同一个字符串数据两次
private static void operateString(String name,Consumer<String> con1, Consumer<String> con2) {
// con1.accept(name);
// con2.accept(name);
con1.andThen(con2).accept(name);
}
//定义一个方法，消费一个字符串数据
private static void operateString(String name, Consumer<String> con) {
con.accept(name);
}
}
结果：
张三
张四
张五
六张
--------------
李三
三李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 PredicatePackage;
import java.util.function.Predicate;
public class Test {
public static void main(String[] args) {
boolean b1 = checkString("hello", (String s) -> {
return s.length() > 8;
});
System.out.println(b1);
boolean b2 = checkString("world", s -> s.length() > 8);
System.out.println(b2);
boolean b3 = checkString("HelloWorld", s -> s.length() > 8);
System.out.println(b3);
System.out.println("--------------");
boolean b4 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
System.out.println(b4);
boolean b5 = checkString("HelloWorld", s -> s.length() > 8, s -> s.length() < 15);
System.out.println(b5);
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre) {
return pre.test(s);
// 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); //短路逻辑或
}
}
结果：
false
false
true
--------------
false
true4.4、Function接口
Function<T,R>：常用的两个方法：
- R apply(T t)：将此函数应用于给定的参数；
- default<V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果；
- Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值。
代码演示：
package FunctionPackage;
import java.util.function.Function;
public class Test {
public static void main(String[] args) {
convert("100", (String s) -> {
return Integer.parseInt(s);
});
convert("200", s -> Integer.parseInt(s));
convert("300", Integer::parseInt);
System.out.println("-------------");
convert(400, i -> String.valueOf(i + 4));
System.out.println("-------------");
convert("500", s -> Integer.parseInt(s), i -> String.valueOf(i + 5));
}
//定义一个方法：把一个字符串转换为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 ii = fun1.apply(s);
// String ss = fun2.apply(ii);
// System.out.println(ss);
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
}
结果：
100
200
300
-------------
404
-------------
505
