Java常用的函数式接口
Supplier<T>
接口
- java.util.function.Supplier
<T>
接口仅包含一个无参的方法:T get()
:用来获取一个泛型参数指定类型的对象数据。
- Supplier
<T>
接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的 get方法就会产生什么类型的数据。 - 示例
package cn.last.demo;
/*
Supplier<T>接口的使用
*/
import java.util.function.Supplier;
public class Test {
// 定义一个方法,方法的参数传递Supplier<T>接口,泛型指定为String,get方法就返回一个String
public static String getString(Supplier<String> sup) {
return sup.get();
}
public static void main(String[] args) {
// 调用getString方法,方法的参数是一个Supplier<T>接口,即函数式接口,可以使用Lambda表达式
// 重写其中的 get方法
String s1 = getString(() -> {
return "hello";
});
System.out.println(s1);
// 优化Lambda表达式
String s2 = getString(() -> "hello");
System.out.println(s2);
}
}
Consumer<T>
接口
- java.util.function.Consumer
<T>
接口则正好与 Supplier<T>
接口相反,它不是生产一个数据,而是消费一个数据,其数据类型由泛型决定。 - Comsumer接口中包含抽象方法:
void accept(T t)
,意为消费一个指定泛型的数据。 - Comsumer接口是一个消费型接口,泛型指定什么类型,就可以使用 accept方法消费什么类型的数据,至于具体怎么消费(使用),需要自定义(输出,计算……)
- 示例
package cn.last.demo;
import java.util.function.Consumer;
public class Test {
/*
定义一个方法,参数:字符串和 Consumer<T>接口,泛型指定 String
用来使用 Consumer接口消费字符串
*/
public static void consume(String name, Consumer<String> con) {
con.accept(name);
}
public static void main(String[] args) {
consume("hello", (String name) -> {
// 消费方式 打印输出
System.out.println(name);
// 消费方法 反转
/*
StringBuilder是一个字符串缓冲区,里面有一个方法
reverse方法可以将此字符序列反转,再使用 toString方法转换成String类
*/
String rename = new StringBuilder(name).reverse().toString();
System.out.println(rename);
});
}
}
默认方法:andThen
如果一个方法参数和返回值都是Consumer
类型,那么就可以实现效果:消费数据的时候,首先做一个操作,然后再做一个操作,实现组合(连接),而这个方法就是Consumer
接口中的 default方法andThen
方法,下面式 JDK源码:
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
备注:
java.util.Objects
的requireNonNull
静态方法将会在参数为 null 时主动抛出NullPointerException
异常。这省去了重复编写 if语句和抛出空指针异常的麻烦。
- 示例:
package cn.last.demo;
import java.util.function.Consumer;
/*
Consumer接口的默认方法:andThen
作用:需要两个 Consumer接口,可以把两个Consumer接口组合到一起,对数据进行消费
注:谁写前边,谁先消费
*/
public class Test {
/*
定义一个方法,参数传递一个字符串和两个 Consumer接口,泛型都使用 String
*/
public static void method(String s, Consumer<String> con1, Consumer<String> con2) {
con1.andThen(con2).accept(s);
}
public static void main(String[] args) {
String s = "Hello";
method(s,
(t) -> {
// 消费方式:把字符串变成大写
System.out.println(s.toUpperCase());
},
(t) -> {
// 消费方式:把字符串变成小写
System.out.println(s.toLowerCase());
}
);
}
}
Predicate<T>
接口
- java.util.function.Predicate
<T>
接口 - 作用:对某种数据类型的数据进行判断,结果返回一个 boolean值
- Predicate接口中包含一个抽象方法:
boolean test(T t)
:用来对指定的数据类型进行判断- 结果:
- 符合条件,返回 true
- 不符合条件,返回 false
- 示例:
package cn.last.demo;
import java.util.function.Predicate;
public class Test {
/*
定义一个方法,参数传递一个字符串
和一个Predicate接口,泛型使用String
使用Predicate中的方法 test对字符串进行判断,并把判断的结果返回
*/
public static boolean checkString(String s, Predicate<String> pre) {
return pre.test(s);
}
public static void main(String[] args) {
String s = new String("abcdef");
// 调用checkString方法,函数式接口,使用Lambda表达式
boolean b = checkString(s, str -> str.length() > 5);
System.out.println(b);
}
}
默认方法:and
- JDK源码:
copydefault Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
- 示例:
package cn.last.demo;
import java.util.function.Predicate;
/*
需求:
判断一个字符串,有两个判断条件
1. 字符串的长度是否大于5
2. 字符串中是否包含a
两个条件必须同时满足,我们就可以使用 && 运算符连接
*/
public class Test {
public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.and(pre2).test(s);
// 等价于 return pre1.test(s) && pre2.test(s);
}
public static void main(String[] args) {
String s = "I Love Java!";
boolean b = checkString(s, (String str) -> {
// 对字符串长度是否大于5进行判断
return str.length() > 5;
}, (String str) -> {
// 对字符串中是否包含a进行判断
return str.contains("a");
});
System.out.println(b);
}
}
默认方法:or
- JDK源码:
copydefault Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
默认方法:negate
- JDK源码:
copy default Predicate<T> negate() {
return (t) -> !test(t);
}
Function<T, R>
接口
java.util.function.Function<T,R>
接口用来根据一个类型的数据,得到另一个类型的数据。前者称为前置条件,后者称为后置条件。
Function接口中最主要的抽象方法为:R apply(T t)
,根据类型T的参数获取类型R的结果。
使用场景例如:将String类型转换为Integer类型。
注意事项:
Function的前置条件泛型和后置条件泛型可以相同。
- 示例:
package cn.last.demo;
import java.util.function.Function;
public class Test {
/*
定义一个方法,
方法的参数传递一个字符串类型的整数
方法的参数传递一个Function<String, Integer>类型的接口
使用Function接口中的方法apply,把字符串类型的整数转换为Integer类型
*/
public static Integer change(String s, Function<String, Integer> fun) {
// 自动拆箱 Integer --> int
return fun.apply(s);
}
public static void main(String[] args) {
int in = change("123", Integer::parseInt);
System.out.println(in + 1);
}
}
默认方法:andThen
- Function接口中的默认方法
andThen
:用来进行组合操作。 - 示例
package cn.last.demo;
import java.util.function.Function;
/*
需求:
把String类型的"123"转换为Integer类型,再加上10
把Integer类型转换为String类型
分析:
转换了两次
1. String --> Integer
Function<String, Integer> fun1
Integer in = fun1.apply("123") + 10;
2. Integer --> String
Function<Integer, String> fun2
String s = fun2.apply(in);
使用andThen方法,把两次转换组合在一起使用
*/
public class Test {
public static void change(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
String str = fun1.andThen(fun2).apply(s);
System.out.println(str);
}
public static void main(String[] args) {
change("1234", s -> Integer.parseInt(s) + 100, String::valueOf);
}
}