Java8新特性

TripleH！

已于 2022-09-09 20:19:01 修改

阅读量239

点赞数

文章标签： java 开发语言

于 2022-09-09 19:31:10 首次发布

本文链接：https://blog.csdn.net/m0_56306353/article/details/126788154

版权

本文主要介绍了Java8的五大新特性：Lambda表达式、函数式接口、方法引用与构造器引用、强大的Stream API以及Optional类。Lambda表达式简化了代码，函数式接口允许将函数作为一等公民，方法引用与构造器引用提供了更简洁的代码实现，Stream API增强了对数据的处理能力，而Optional类则帮助避免了空指针异常。

摘要由CSDN通过智能技术生成

Java8新特性

听该课程做的笔记：（只听了关于java8的章节）
如有侵权，请联系作者删除
宋红康 - 全网最全Java零基础入门教程：https://www.bilibili.com/video/BV1Kb411W75N
在这里插入图片描述

速度更快

代码更少(增加了新的语法：Lambda 表达式)

强大的 Stream API

便于并行

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数

据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。

Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流

之间进行切换。

最大化减少空指针异常：Optional

Nashorn引擎，允许在JVM上运行JS应用

1.Lambda表达式

Lambda表达式的本质:作为函数式接口的实例(java:万物皆对象)

@Test
public void test2() {
   
    Comparator<Integer> com1 = new Comparator<Integer>() {
   
        @Override
        public int compare(Integer o1, Integer o2) {
   
            return Integer.compare(o1, o2);
        }
    };
    int compare1 = com1.compare(12, 21);
    System.out.println(compare1);


    Comparator<Integer> com2 = ((o1, o2) -> Integer.compare(o1, o2));
    /*
    ->:lambda操作符 或 箭头操作符
    ->左边:lambda形参列表（其实就是接口中的抽象方法的形参列表）
    ->右边:lambda体（其实就是重写的抽象方法的方法体）
    */
    int compare2 = com2.compare(32, 21);
    System.out.println(compare2);

    //方法引用
    Comparator<Integer> com3 = Integer :: compare;
    int compare3 = com2.compare(32, 21);
    System.out.println(compare2);


}

总结：

->左边：lambda形参列表的参数类型可以省略（类型推断）；如果lambda形参列表只有一个参数，其一对（）也可以省略

->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字

@Test
    public void test1(){
   
        Runnable r1 = new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println("123");
            }
        };
        r1.run();
        System.out.println("***************");
        Runnable r2 = () -> {
   
            System.out.println("456");
        };

        r2.run();
    }
    //语法格式二：Lambda 需要一个参数，但是没有返回值
    @Test
    public void test2(){
   
        Consumer<String> consumer = new Consumer<String>() {
   
            @Override
            public void accept(String s) {
   
                System.out.println(s);
            }
        };
        consumer.accept("789");
        System.out.println("***************");
        Consumer<String> consumer1 = (String s) ->{
   
            System.out.println(s);
        };
        consumer1.accept("杜兰特");
    }
//    语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    @Test
    public void test3(){
   
        Consumer<String> consumer1 = (String s) ->{
   
            System.out.println(s);
        };
        consumer1.accept("杜兰特");
        System.out.println("***************");
        Consumer<String> consumer2 = (s) ->{
   //类型推断
            System.out.println(s);
        };
        consumer1.accept("杜兰特");
    }

    @Test
    public void test4(){
   
        ArrayList<String> list = new ArrayList<>();//类型推断
        int[] arr = {
   1,2,3};//类型推断
    }
//    语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test5(){
   
        Consumer<String> consumer1 = (s) ->{
   
            System.out.println(s);
        };
        consumer1.accept("杜兰特");
        System.out.println("***************");
        Consumer<String> consumer2 = s ->{
   
            System.out.println(s);
        };
        consumer2.accept("杜兰特");
    }
    //语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test6() {
   
        Comparator<Integer> com1 = new Comparator<Integer>() {
   
            @Override
            public int compare(Integer o1, Integer o2) {
   
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12,21));
        System.out.println("***************");
        Comparator<Integer> com2 =(o1,o2) -> {
   
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(32,21));

    }
    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

    @Test
    public void test7() {
   
        Comparator<Integer> com1 =(o1,o2) -> {
   
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(32,21));
        Comparator<Integer> com2 =(o1,o2) ->  o1.compareTo(o2);
        System.out.println(com2.compare(12,21));
    }
    @Test
    public void test8() {
   
        Consumer<String> consumer1 = s ->{
   
            System.out.println(s);
        };
        consumer1.