本篇文章为你整理了这些JDK8 新特性，我还是第一次听说（jdk8新特性lambda）的详细内容，包含有jdk8新功能 jdk8新特性lambda jdk8介绍 jdk8到jdk15新特性 这些JDK8 新特性，我还是第一次听说，希望能帮助你了解 这些JDK8 新特性，我还是第一次听说。
什么是函数式接口？简单来说就是只有一个抽象函数的接口。为了使得函数式接口的定义更加规范，java8 提供了@FunctionalInterface 注解告诉编译器在编译器去检查函数式接口的合法性，以便在编译器在编译出错时给出提示。为了更加规范定义函数接口，给出如下函数式接口定义规则：
可以看出函数式接口的编写定义非常简单，不知道大家有没有注意到，其实我们经常会用到函数式接口，如Runnable 接口，它就是一个函数式接口：
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();
现在我们使用Lambda 表达式，这里函数式接口的使用没有体现函数式编程思想，这里输出字符到标准输出流中，产生了副作用，起到了简化代码的作用，当然还有装B。
COPYnew Thread(()- {
System.out.println("Hello FunctionalInterface");
}).start();
Java8 util.function 包下自带了43个函数式接口，大体分为以下几类：
* 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
何为Function呢？比如电视机，给你带来精神上的愉悦，但是它需要用电啊，电视它把电转换成了你荷尔蒙，这就是Function，简单电说，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 -
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
可以简单理解成算术中的各种运算操作，当然不仅仅是运算这么简单，因为它只定义了运算这个定义，但至于运算成什么样你说了算。由于没有最基础的Operator，这里将通过 BinaryOperator、IntBinaryOperator来理解Operator 函数式接口，先从简单的IntBinaryOperator开始。
IntBinaryOperator
从名字可以知道，这是一个二元操作，并且是Int 类型的二元操作，那么这个接口可以做什么呢，除了加减乘除，还可以可以实现平方（两个相同int 数操作起来不就是平方吗），还是先看看它的定义吧：
@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
BinaryOperator 二元操作，看起来它和IntBinaryOperator 是父子关系，实际上这两者没有半点关系，但他们在功能上还是有相似之处的：
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
断言、判断，对输入的数据根据某种标准进行评判，最终返回boolean值：
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
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.compose(e- e/2))) //先平方然后除2再平方
.forEach(System.out::println);
结果如下
COPY1
------
------
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
筛选出大于0最小的两个数
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
这里一直生产2这个数字，为了能停下来，使用limit
COPYpublic class Main {
public static void main(String[] args) {
Stream.generate(()- 2)
.limit(10)
.forEach(System.out::println);
输出结果
COPY2
Java8的Stream 基本上都是使用util.function包下的函数式接口来实现函数式编程的，而函数式接口也就只分为 Function、Operator、Consumer、Predicate、Supplier 这五大类，只要能理解掌握最基础的五大类用法，其他变种也能触类旁通。
本文由传智教育博学谷狂野架构师教研团队发布。
如果本文对您有帮助，欢迎关注和点赞；如果您有任何建议也可留言评论或私信，您的支持是我坚持创作的动力。
转载请注明出处！
以上就是这些JDK8 新特性，我还是第一次听说（jdk8新特性lambda）的详细内容，想要了解更多 这些JDK8 新特性，我还是第一次听说的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。