jdk都出到16了8还没掌握吗？挽周带你玩转java8新特性（建议收藏）

Posted Cs 挽周

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了jdk都出到16了8还没掌握吗？挽周带你玩转java8新特性（建议收藏）相关的知识，希望对你有一定的参考价值。

Java 8 新特性

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 javascript 引擎，新的日期 API，新的Stream API 等。

在本文中我们将围绕以下五点学习(常用的)新特性。并用实际的例子说明在什么场景下适合使用。

文章目录

友情链接

菜鸟教程：点我跳转Java8新特性菜鸟教程地址

JDK：点我跳转Jdk8官网下载地址

一.Lambda表达式

Lambda 是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，将代码像数据一样进行传递。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格。使Java的语言表达能力得到了提升。

语法：

(o1,o2) -> Integer.compare(o1,o2);
  • ->：lambda操作符，也叫箭头操作符
  • -> 左边：lambda形参列表 (其实就是接口中的抽象方法的形参列表)
  • -> 右边：lambda体(其实就是重写的抽象方法的方法体)

案例：

  1. 格式：无参数，无返回值
    @Test
    public void test(){
        //原写法
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("无参无返回值原写法");
            }
        };
        runnable.run();

        //Lambda表达式写法
        Runnable lrunnable =()->{System.out.println("无参无返回值Lambda表达式写法");};
        lrunnable.run();
    }

  1. 格式：Lambda 需要一个参数，但是没有返回值
 @Test
    public void test(){
        //原写法
        Consumer<String> consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("需要一个参数没有返回值，原写法");

        //Lambda表达式写法
        Consumer<String> lconsumer =(String s)->{System.out.println(s);};
        lconsumer.accept("需要一个参数没有返回值，Lambda表达式写法");
    }

  1. 格式：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    @Test
    public void test(){
        //原写法
        Consumer<String> consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("需要一个参数没有返回值，原写法");

        //Lambda表达式写法
        Consumer<String> lconsumer =(s)->{System.out.println(s);};
        lconsumer.accept("需要一个参数没有返回值并且数据类型可以省略, Lambda表达式写法");
    }

  1. 格式：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test(){
        //原写法
        Consumer<String> consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("需要一个参数没有返回值，原写法");

        //Lambda表达式写法
        Consumer<String> lconsumer = s ->{System.out.println(s);};
        lconsumer.accept("需要一个参数没有返回值,数据类型可以省略,小括号也可以省略 Lambda表达式写法");
    }

  1. 格式：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test(){
        //原写法
        Comparator<Integer> comparator=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator.compare(1,2));

        //Lambda表达式写法
        Comparator<Integer> lcomparator=(o1,o2)->{return o1.compareTo(o2);};
        System.out.println(lcomparator.compare(1,2));
    }

  1. 格式：当 Lambda 体只有一条语句时， return 与大括号都可以省略
    @Test
    public void test(){
        //原写法
        Comparator<Integer> comparator=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator.compare(1,2));

        //Lambda表达式写法
        Comparator<Integer> lcomparator=(o1,o2)-> o1.compareTo(o2);
        System.out.println(lcomparator.compare(1,2));
    }


总结：

  • lambda表达式的本质：作为函数式接口的实例
  • -> 左边 ： 如果使用泛型，lambda形参列表的参数类型可以省略(类型推断)，如果lambda形参列表只有一个参数()也可以省略。
  • -> 右边：lambda体使用一对{}包裹，如果lambda体只有一条执行语句(可能是return语句)，可以省略这一对{}和return关键字 (如果省略了return关键字{}也一定要去掉) 。

二.函数式(Funcation)接口

如果一个接口中，只声明了一个抽象方法(可以有多个非抽象方法)，则此接口就称为函数式接口，函数式接口可以被隐式转换为 lambda 表达式。

学习之前先来看一下JDK 1.8 之前已有的函数式接口 Runnable

我们常用的一些接口Callable、Runnable、Comparator等在JDK8中都添加了@FunctionalInterface注解。该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上@FunctionInterface，那么编译器会报错。

自定义函数式接口：

/**
 * @author mengzhichao
 * @create 2021-06-06-18:25
 */
@FunctionalInterface
public interface MyInterface {

    void method();
    
}

总结：在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例。那么该对象就可以用Lambda表达式来表示。所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

JDK 1.8 新增加的函数接口：

接口描述
BiConsumer<T,U>代表了一个接受两个输入参数的操作，并且不返回任何结果
BiFunction<T,U,R>代表了一个接受两个输入参数的方法，并且返回一个结果
BinaryOperator< T >代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
BiPredicate<T,U>代表了一个两个参数的boolean值方法
BooleanSupplier代表了boolean值结果的提供方
Consumer代表了接受一个输入参数并且无返回的操作
DoubleBinaryOperator代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
DoubleConsumer代表一个接受double值参数的操作，并且不返回结果。
DoubleFunction< R >代表接受一个double值参数的方法，并且返回结果
DoublePredicate代表一个拥有double值参数的boolean值方法
DoubleSupplier代表一个double值结构的提供方
DoubleToIntFunction接受一个double类型输入，返回一个int类型结果。
DoubleToLongFunction接受一个double类型输入，返回一个long类型结果
DoubleUnaryOperator接受一个参数同为类型double,返回值类型也为double 。
Function<T,R>接受一个输入参数，返回一个结果。
IntBinaryOperator接受两个参数同为类型int,返回值类型也为int 。
IntConsumer接受一个int类型的输入参数，无返回值 。
IntFunction< R >接受一个int类型输入参数，返回一个结果 。
IntPredicate接受一个int输入参数，返回一个布尔值的结果。
IntSupplier无参数，返回一个int类型结果。
IntToDoubleFunction接受一个int类型输入，返回一个double类型结果 。
IntToLongFunction接受一个int类型输入，返回一个long类型结果。
IntUnaryOperator接受一个参数同为类型int,返回值类型也为int 。
LongBinaryOperator接受两个参数同为类型long,返回值类型也为long。
LongConsumer接受一个long类型的输入参数，无返回值。
LongFunction< R >接受一个long类型输入参数，返回一个结果。
LongPredicateR接受一个long输入参数，返回一个布尔值类型结果。
LongSupplier无参数，返回一个结果long类型的值。
LongToDoubleFunction接受一个long类型输入，返回一个double类型结果。
LongToIntFunction接受一个long类型输入，返回一个int类型结果。
LongUnaryOperator接受一个参数同为类型long,返回值类型也为long。
ObjDoubleConsumer< T >接受一个object类型和一个double类型的输入参数，无返回值。
ObjIntConsumer< T >接受一个object类型和一个int类型的输入参数，无返回值。
ObjLongConsumer< T >接受一个object类型和一个long类型的输入参数，无返回值。
Predicate< T >接受一个输入参数，返回一个布尔值结果。
Supplier< T >无参数，返回一个结果。
ToDoubleBiFunction<T,U>接受两个输入参数，返回一个double类型结果
ToDoubleFunction< T >接受一个输入参数，返回一个double类型结果
ToIntBiFunction<T,U>接受两个输入参数，返回一个int类型结果。
ToIntFunction< T >接受一个输入参数，返回一个int类型结果。
ToLongBiFunction<T,U>接受两个输入参数，返回一个long类型结果。
ToLongFunction< T >接受一个输入参数，返回一个long类型结果。
UnaryOperator< T >接受一个参数为类型T,返回值类型也为T。

案例(再此只演示极个别常用的，小伙伴们私底下可以自行练习)：

  • consumer即消费接口，传入一个参数，并对其进行相应的操作
public class LambdaTest {

    public void happyTime(double money,Consumer<Double> consumer){
        consumer.accept(money);
    }

    @Test
    public void test(){
        //原写法
       happyTime(500, new Consumer<Double>() {
           @Override
           public void accept(Double aDouble) {
               System.out.println("原写法，价格为："+aDouble);
           }
       });

        //Lambda表达式写法
        happyTime(500,money-> System.out.println("Lambda表达式写法，价格为："+money));
    }
}

  • supplier即供给接口，可以传入数据，作为一个容器；
public class LambdaTest {

    @Test
    public void test(){
        //原写法
        Supplier<String> supplier=new Supplier<String>() {
            @Override
            public String get() {
                return "原写法，供给型接口";
            }
        };
        System.out.println(supplier.get());

        //Lambda表达式写法
        Supplier<String> lSupplier=()->"lambda写法，供给型接口";
        System.out.println(lSupplier.get());
    }

}

  • function即方法接口，主要是用作数据类型之间的转换；
public class LambdaTest {

    @Test
    public void test(){
        //原写法(给一个int 转成字符串并返回)
        Function<Integer,String> function=new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return String.valueOf(integer);
            }
        };
        System.out.println(function.apply(10).getClass().getName());

        //Lambda表达式写法
        Function<Integer,String> lFunction=(integer) -> String.valueOf(integer);
        System.out.println(lFunction.apply(20).getClass().getName());
    }

}

  • predicate即判断接口，传入参数，而后返回判断的结果true/false；
public class LambdaTest {

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> predicate){
        List<String> filterList=new ArrayList<>();
        for (String s:list){
            if (predicate.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }

    @Test
    public void test(){
        //原写法
        List<String> list=Arrays.asList(new String[]{"上海", "香港", "澳门", "曹县"});
        List<String> filterString = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return "曹县".equals(s) ? true : false;
            }
        });
        System.out.println(filterString);


        //Lambda表达式写法
        List<String> lfilterString = filterString(list, s -> "上海".equals(s) ? true : false);
        System.out.println(lfilterString);
    }
}

三.方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用 ! 方法引用可以看作是Lambda表达式深层次的表达，换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

语法：

使用操作符 “::” 将类(或对象)与方法名分割开来。

要求：实现接口的抽象方法的参数和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

案例：

  1. 格式：对象 : : 非静态方法
    @Test
    public void test(){
        //Lambda表达式写法
        Consumer<String> consumer = str ->System.out.println(str);
        consumer.accept("Lambda表达式");

        //方法引用写法
        Consumer<String> fConsumer = System.out::println;
        fConsumer.accept("方法引用");
    }

  1. 格式：类 : : 静态方法
public class LambdaTest {

    @Test
    public void test(){
        //Lambda表达式写法 比较两个数大小
        Comparator<Integer> comparator =(t1,t2) -> Integer.compare(t1,t2);
        System.out.println(comparator.compare(10,20));

        //方法引用写法
        Comparator<Integer> fComparator = Integer::compare;
        System.out.println(fComparator.compare(20,10));
    }

}

  1. 格式：类 : : 非静态方法

public class LambdaTest {

    @Test
    public void test(){
        //Lambda表达式写法
       Comparator<String> comparator=(<
以上是关于jdk都出到16了8还没掌握吗？挽周带你玩转java8新特性（建议收藏）的主要内容，如果未能解决你的问题，请参考以下文章
 

 JDK都出到16了，8还没有掌握吗？一篇文章打包带走Java8新特性


 五分钟带你玩转SpringSecurity全网最全！带你掌握随机颜色与计算方式的验证码


 五分钟带你玩转k8s操作必备命令


 五分钟带你玩转SpringSecurity全网最全！带你掌握随机颜色与计算方式的验证码


 jQuery标杆实力派，带你玩转全部核心技术点


 带你玩转多进程编程