函数式接口在Java中是指:有且仅有一个抽象方法的接口
@FunctionalInterface //检测
public interface MyFunctionalInterface {
void myMethod();
}
函数式编程
lambda延迟执行(性能提升)
@FunctionalInterfacepublic
interface MessageBuilder {
String buildMessage();
}
private static void log(int level, MessageBuilder builder) {
if (level == 1){
System.out.println(builder.buildMessage());
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(1, () ‐> msgA + msgB + msgC );
}}
常用函数式接口
java.util.function
Supplier接口
import java.util.function.Supplier;
public class Demo {
public static String getString(Supplier<String> function) {
return function.get();
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
System.out.println(getString(() -> msgA + msgB));
}
}
Consumer接口
java.util.function.Consumer 接口则正好与Supplier接口相反,它不是生产一个数据,而是消费一个数据,
其数据类型由泛型决定。
抽象方法:accept
private static void consumeString(Consumer<String> function) {
function.accept("Hello");
}
public static void main(String[] args) {
consumeString(s -> System.out.println(s));
}
默认方法:andThen
消费数据的时候,首先做一个操作,
然后再做一个操作,实现组合
谁写前面,谁先消费
import java.util.function.Consumer;
public class Demo10ConsumerAndThen {
private static void consumeString(Consumer<String> one, Consumer<String> two) {
one.andThen(two).accept("Hello");
}
public static void main(String[] args) {
consumeString(
s -> System.out.println(s.toUpperCase()),
s -> System.out.println(s.toLowerCase()));
}
}
import java.util.function.Consumer;
public class Demo {
public static void main(String[] args) {
String[] array = {"张威,女", "王五,女", "张特立,男"};
printInfo(s -> System.out.print("姓名:" + s.split(",")[0]),
s -> System.out.println("。性别:" + s.split(",")[1] + "。"),
array);
}
private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
for (String info : array) {
one.andThen(two).accept(info); // 姓名:王五。性别:女。
}
}
}
Predicate接口
java.util.function.Predicate 接口
要对某种类型的数据进行判断,从而得到一个boolean值结果
抽象方法:test
boolean test(T t)
默认方法:and
默认方法:or
import java.util.function.Predicate;
public class Demo16PredicateAnd {
private static void method(Predicate<String> one, Predicate<String> two) {
boolean isValid = one.or(two).test("Helloworld");
System.out.println("字符串符合要求吗:" + isValid);
}
public static void main(String[] args) {
method(s -> s.contains("H"), s -> s.contains("W"));
}
}
默认方法:negate
取反
Function接口
抽象方法:apply
默认方法:andThen
Function 接口中有一个默认的 andThen 方法,用来进行组合操作
public class Demo02Function_andThen {
/*
定义一个方法
参数串一个字符串类型的整数
参数再传递两个Function接口
一个泛型使用Function<String,Integer>
一个泛型使用Function<Integer,String>
*/
public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s = "123";
//调用change方法,传递字符串和两个Lambda表达式
change(s,(String str)->{
//把字符串转换为整数+10
return Integer.parseInt(str)+10;
},(Integer i)->{
//把整数转换为字符串
return i+"";
});
//优化Lambda表达式
change(s,str->Integer.parseInt(str)+10,i->i+"");
}
}