这些JDK8 新特性，我还是第一次听说
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了这些JDK8 新特性，我还是第一次听说相关的知识，希望对你有一定的参考价值。
概述
- 有且仅有一个抽象函数
- 必须要有@FunctionalInterface 注解
- 可以有默认方法
COPY@FunctionalInterface
public interface Runnable
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the objects
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
COPYnew Thread(new Runnable()
@Override
public void run()
System.out.println("Hello FunctionalInterface");
).start();
COPYnew Thread(()->
System.out.println("Hello FunctionalInterface");
).start();
- Consumer 消费接口
- Function 功能接口
- Operator 操作接口
- Predicate 断言接口
- Supplier 生产接口
其他接口都是在此基础上变形定制化罢了。
函数式接口详细介绍
Consumer
COPY@FunctionalInterface
public interface Consumer<T>
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
/**
* Returns a composed @code Consumer that performs, in sequence, this
* operation followed by the @code after operation. If performing either
* operation throws an exception, it is relayed to the caller of the
* composed operation. If performing this operation throws an exception,
* the @code after operation will not be performed.
*
* @param after the operation to perform after this operation
* @return a composed @code Consumer that performs in sequence this
* operation followed by the @code after operation
* @throws NullPointerException if @code after is null
*/
default Consumer<T> andThen(Consumer<? super T> after)
Objects.requireNonNull(after);
return (T t) -> accept(t); after.accept(t); ;
Consumer 接口中有accept 抽象方法，accept接受一个变量，也就是说你在使用这个函数式接口的时候，给你提供了数据，你只要接收使用就可以了；andThen 是一个默认方法，接受一个Consumer 类型，当你对一个数据使用一次还不够爽的时候，你还能再使用一次，当然你其实可以爽无数次，只要一直使用andThan方法。
Function
COPY@FunctionalInterface
public interface Function<T, R>
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
/**
* Returns a composed function that first applies the @code before
* function to its input, and then applies this function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of input to the @code before function, and to the
* composed function
* @param before the function to apply before this function is applied
* @return a composed function that first applies the @code before
* function and then applies this function
* @throws NullPointerException if before is null
*
* @see #andThen(Function)
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before)
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
/**
* Returns a composed function that first applies this function to
* its input, and then applies the @code after function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of output of the @code after function, and of the
* composed function
* @param after the function to apply after this function is applied
* @return a composed function that first applies this function and then
* applies the @code after function
* @throws NullPointerException if after is null
*
* @see #compose(Function)
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after)
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
/**
* Returns a function that always returns its input argument.
*
* @param <T> the type of the input and output objects to the function
* @return a function that always returns its input argument
*/
static <T> Function<T, T> identity()
return t -> t;
Function 接口 最主要的就是apply 函数，apply 接受T类型数据并返回R类型数据，就是将T类型的数据转换成R类型的数据，它还提供了compose、andThen、identity 三个默认方法，compose 接受一个Function，andThen也同样接受一个Function，这里的andThen 与Consumer 的andThen 类似，在apply之后在apply一遍，compose 则与之相反，在apply之前先apply（这两个apply具体处理内容一般是不同的），identity 起到了类似海关的作用，外国人想要运货进来，总得交点税吧，然后货物才能安全进入中国市场，当然了想不想收税还是你说了算的。
Operator
IntBinaryOperator
@FunctionalInterface
public interface IntBinaryOperator
/**
* Applies this operator to the given operands.
*
* @param left the first operand
* @param right the second operand
* @return the operator result
*/
int applyAsInt(int left, int right);
IntBinaryOperator 接口内只有一个applyAsInt 方法，其接收两个int 类型的参数，并返回一个int 类型的结果，其实这个跟Function 接口的apply 有点像，但是这里限定了，只能是int类型。
BinaryOperator
COPY@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T>
/**
* Returns a @link BinaryOperator which returns the lesser of two elements
* according to the specified @code Comparator.
*
* @param <T> the type of the input arguments of the comparator
* @param comparator a @code Comparator for comparing the two values
* @return a @code BinaryOperator which returns the lesser of its operands,
* according to the supplied @code Comparator
* @throws NullPointerException if the argument is null
*/
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator)
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
/**
* Returns a @link BinaryOperator which returns the greater of two elements
* according to the specified @code Comparator.
*
* @param <T> the type of the input arguments of the comparator
* @param comparator a @code Comparator for comparing the two values
* @return a @code BinaryOperator which returns the greater of its operands,
* according to the supplied @code Comparator
* @throws NullPointerException if the argument is null
*/
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator)
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
BinaryOperator 是 BiFunction 生的，而IntBinaryOperator 是从石头里蹦出来的，BinaryOperator 自身定义了minBy、maxBy默认方法，并且参数都是Comparator，就是根据传入的比较器的比较规则找出最小最大的数据。
Predicate
COPY@FunctionalInterface
public interface Predicate<T>
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return @code true if the input argument matches the predicate,
* otherwise @code false
*/
boolean test(T t);
/**
* Returns a composed predicate that represents a short-circuiting logical
* AND of this predicate and another. When evaluating the composed
* predicate, if this predicate is @code false, then the @code other
* predicate is not evaluated.
*
* <p>Any exceptions thrown during evaluation of either predicate are relayed
* to the caller; if evaluation of this predicate throws an exception, the
* @code other predicate will not be evaluated.
*
* @param other a predicate that will be logically-ANDed with this
* predicate
* @return a composed predicate that represents the short-circuiting logical
* AND of this predicate and the @code other predicate
* @throws NullPointerException if other is null
*/
default Predicate<T> and(Predicate<? super T> other)
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
/**
* Returns a predicate that represents the logical negation of this
* predicate.
*
* @return a predicate that represents the logical negation of this
* predicate
*/
default Predicate<T> negate()
return (t) -> !test(t);
/**
* Returns a composed predicate that represents a short-circuiting logical
* OR of this predicate and another. When evaluating the composed
* predicate, if this predicate is @code true, then the @code other
* predicate is not evaluated.
*
* <p>Any exceptions thrown during evaluation of either predicate are relayed
* to the caller; if evaluation of this predicate throws an exception, the
* @code other predicate will not be evaluated.
*
* @param other a predicate that will be logically-ORed with this
* predicate
* @return a composed predicate that represents the short-circuiting logical
* OR of this predicate and the @code other predicate
* @throws NullPointerException if other is null
*/
default Predicate<T> or(Predicate<? super T> other)
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
/**
* Returns a predicate that tests if two arguments are equal according
* to @link Objects#equals(Object, Object).
*
* @param <T> the type of arguments to the predicate
* @param targetRef the object reference with which to compare for equality,
* which may be @code null
* @return a predicate that tests if two arguments are equal according
* to @link Objects#equals(Object, Object)
*/
static <T> Predicate<T> isEqual(Object targetRef)
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
Predicate的test 接收T类型的数据，返回 boolean 类型，即对数据进行某种规则的评判，如果符合则返回true，否则返回false；Predicate接口还提供了 and、negate、or，与 取反 或等，isEqual 判断两个参数是否相等等默认函数。
Supplier
COPY@FunctionalInterface
public interface Supplier<T>
/**
* Gets a result.
*
* @return a result
*/
T get();
非常easy，get方法返回一个T类数据，可以提供重复的数据，或者随机种子都可以，就这么简单。
函数式接口实战
Consumer
COPYpublic class Main
public static void main(String[] args)
Stream.of(1,2,3,4,5,6)
.forEach(integer -> System.out.println(integer)); //输出1，2，3，4，5，6
这里使用标准输出，还是产生了副作用，但是这种程度是可以允许的
Function
COPYpublic class Main
public static void main(String[] args)
Stream.of("hello","FunctionalInterface")
.map(e->e.length())
.forEach(System.out::println);
COPYpublic class FunctionTest
public static void main(String[] args)
public static void main(String[] args)
Function<Integer, Integer> square = integer -> integer * integer; //定义平方运算
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.stream()
.map(square.andThen(square)) //四次方
.forEach(System.out::println);
System.out.println("------");
list.stream()
.map(square.compose(e -> e - 1)) //减一再平方
.forEach(System.out::println);
System.out.println("------");
list.stream().map(square.andThen(square.compose(e->e/2))) //先平方然后除2再平方
.forEach(System.out::println);
COPY1
16
81
256
------
0
1
4
9
------
0
4
16
64
Operator
BinaryOperator
COPYpublic class BinaryOperatorTest
public static void main(String[] args)
Stream.of(2,4,5,6,7,1)
.reduce(BinaryOperator.maxBy(Comparator.comparingInt(Integer::intValue))).ifPresent(System.out::println);
IntOperator
COPYpublic class BinaryOperatorTest
public static void main(String[] args)
IntBinaryOperator intBinaryOperator = (e1, e2)->e1+e2; //定义求和二元操作
IntStream.of(2,4,5,6,7,1)
.reduce(intBinaryOperator).ifPresent(System.out::println);
Predicate
COPYpublic class Main
public static void main(String[] args)
IntStream.of(200,45,89,10,-200,78,94)
.filter(e->e>0) //过滤小于0的数
.sorted() //自然顺序排序
.limit(2) //取前两个
.forEach(System.out::println);
Supplier
COPYpublic class Main
public static void main(String[] args)
Stream.generate(()->2)
.limit(10)
.forEach(System.out::println);
COPY2
2
2
2
2
2
2
2
2
2
总结
Java8的Stream 基本上都是使用util.function包下的函数式接口来实现函数式编程的，而函数式接口也就只分为 Function、Operator、Consumer、Predicate、Supplier 这五大类，只要能理解掌握最基础的五大类用法，其他变种也能触类旁通。
以上是关于这些JDK8 新特性，我还是第一次听说的主要内容，如果未能解决你的问题，请参考以下文章