函数式接口的特征
1、三种方法
- 唯一的抽象方法
- 使用default定义普通方法(默认方法),通过对象调用。
- 使用static定义静态方法,通过接口名调用。
2、一个新注解@FunctionInterface
- 注解@FunctionalInterface告诉编译器这是一个函数式接口,明确这个函数中只有一个抽象方法,当你尝试在接口中编写多个抽象方法的时候编译器将不允许,但是可以有多个非抽象方法。
- 不过Object类的方法可以定义为抽象方法,因为接口的实现类一定是Object的子类
- 如果接口被标注了@FunctionalInterface,这个类就必须符合函数式接口的规范
- 即使一个接口没有标注@FunctionalInterface,如果这个接口满足函数式接口规则,依旧被当作函数式接口。
3、实现方式
JDK8以前,通过匿名内部类实现函数式接口
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello world !");
}
}).start();
JDK8以后可以使用lambda 表达式来实现,lambda表达式就是为了优化匿名内部类而生。
Runnable r = () -> System.out.println("task running !");
new Thread(() -> System.out.println("task running !")).start();
JDK提供的函数式接口
1. JDK 1.8之前已有函数式接口,比如:
java.lang.Runnable
java.util.concurrent.Callable
java.util.Comparator
…
2. JDK 1.8 新增加的函数接口包:
java.util.function.*
java.util.function 它包含了很多接口,用来支持 Java的 函数式编程,它们大致分为五类:
类型 | 接口 | 参数 | 返回值 | 描述 |
---|---|---|---|---|
供给型接口 | Supplier<T> | None | T | 没有输入,返回一个对象T |
功能型函数式接口 | Function<T, R> | T | R | 对象转换,T->R |
消费型接口 | Consumer<T> | T | void | 改变对象T内部属性的值 |
断言型接口 | Predicate<T> | T | boolean | 进行逻辑判断,返回boolean值 |
其他 |
供给型接口 Supplier<T>
JDK 8 源码
@FunctionalInterface
public interface Supplier<T> {
//返回T
T get();
}
使用
Supplier<String> supplier = ()-> "Hello World!";
Supplier<String> supplier = ()-> new User();
功能型函数式接口 Function<T, R>
接受一个输入参数T,返回一个结果R。
JDK8 源码如下
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
lambda 表达式实现Function接口
Function<String,Long> fun = str -> Long.valueOf(str);
Function<Integer,String> fun = item -> item+"";
Consumer<T> 消费型接口
An operation which accepts a single input argument and returns no result. Unlike most other functional interfaces, Consumer is expected to operate via side-effects.
一个接受单个输入参数并且不返回结果的操作。 与大多数其他函数接口不同, Consumer接口期望通过副作用进行操作。
Consumer接口JDK8 源码如下
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
* 对给定的参数执行此操作
* @param t the input argument
*/
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
//after == null 则抛异常 NullPointerException()
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
accept()接受并改变某个对象的内部值
user -> user.setAge(20);
Predicate<T> 断言型接口
JDK8 源码如下
@FunctionalInterface
public interface Predicate<T> {
//进行某些逻辑判断并返回一个boolean值
boolean test(T t);
//与
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
//取反
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
lambda 表达式实现Predicate接口
Predicate<Integer> predicate = age -> age > 18;
Predicate<String> predicate = str -> str != null;
Predicate常用于集合的过滤,得到一个新的集合
Stream filter(Predicate<? super T> predicate);
List<Long> supplierIds = page.getContent().stream().map(item -> item.getSupplierId()).distinct()
.filter(item -> item != null).collect(Collectors.toList());