【Java高级编程】Java8的新特性

比眉伴天荒 2023-10-12 23:27 41阅读 0赞

![在这里插入图片描述][b8c725da5f404036847fd9d5877b5de8.png_pic_center]  
[【Java核心技术】Java基本语法][Java_Java]  
[【Java核心技术】Java面向对象编程][Java_Java 1]  
[【Java核心技术】Java异常处理][Java_Java 2]  
[【Java高级编程】Java多线程][Java_Java 3]  
[【Java高级编程】Java常用类][Java_Java 4]  
[【Java高级编程】Java枚举类&注解][Java_Java 5]  
[【Java高级编程】Java集合][Java_Java 6]  
[【Java高级编程】Java泛型][Java_Java 7]  
[【Java高级编程】JavaIO流][Java_JavaIO]  
[【Java高级编程】Java网络编程][Java_Java 8]  
[【Java高级编程】Java反射机制][Java_Java 9]  
[【Java高级编程】Java8的新特性][Java_Java8]

#### Java8的新特性 ####

*   *   *  1、Java8的新特性概述
         *  2、Lambda表达式
         *   *  2.1、Lambda表达式使用前后的对比
             *  2.2、Lambda表达式的基本语法
             *  2.3、如何使用：分为六种情况
         *  3、函数式接口
         *   *  3.1、函数式接口的使用说明
             *  3.2、Java8中关于Lambda表达式提供的4个基本的函数式接口
             *  3.3、总结
         *  4、方法引用
         *   *  4.1、理解
             *  4.2、使用情境
             *  4.3、格式
             *  4.4、分为如下的三种情况
             *  4.5、要求
             *  4.6、使用建议
             *  4.7、使用举例
         *  5、构造器引用与数组引用
         *   *  5.1、构造器引用格式
             *  5.2、构造器引用使用要求
             *  5.3、构造器引用举例
             *  5.4、数组引用格式
             *  5.5、数组引用举例
         *  6、Stream API
         *   *  6.1、Stream API的理解
             *  6.2、注意点
             *  6.3、Stream的使用流程
             *  6.4、使用流程的注意点
             *  6.5、步骤一：Stream实例化
             *  6.6、步骤二：中间操作
             *  6.7、步骤三：终止操作
         *  7、Optional类的使用
         *   *  7.1、理解
             *  7.2、常用方法

#### 1、Java8的新特性概述 ####

*  函数式接口
 *  Lambda表达式
 *  方法引用/构造器引用
 *  Stream API
    
     *  并行流
     *  串行流
 *  接口的增强
    
     *  静态方法
     *  默认方法
 *  Optional类
 *  新的时间和日期API
 *  其它新特性
    
     *  重复注解
     *  类型注解
     *  通用目标类型推断
     *  JDK的更新
        
         *  集合的流式操作
         *  并发
         *  Arrays
         *  Number和Math
         *  IO/NIO的改进
         *  Reflection获取形参名
         *  String:join()
         *  Files
     *  新编译工具：jjs、jdeps
     *  JVM中Metaspace取代PermGen空间

#### 2、Lambda表达式 ####

##### 2.1、Lambda表达式使用前后的对比 #####

@Test
    public void test1 () {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        // 使用lambda表达式
        Runnable r2 = () -> System.out.println("我爱北京天安门");
        r2.run();
    }

@Test
    public void test2 () {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(com1.compare(12, 21));
        // Lambda表达式的写法
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        System.out.println(com2.compare(32, 21));
        // 方法引用
        Comparator<Integer> com3 = Integer :: compare;
        System.out.println(com3.compare(32, 21));
    }

##### 2.2、Lambda表达式的基本语法 #####

*  举例：(o1, o2) -> Integer.compare(o1, o2);
 *  格式：
    
     *  \->：lambda操作符或箭头操作符
     *  \->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）
     *  \->右边：lambda体（其实就是重写的抽象方法的方法体）

##### 2.3、如何使用：分为六种情况 #####

*  语法格式一：无参，无返回值
    
     *  `Runnable r1 = () -> {System.out.println("Hello Lambda!");};`
 *  语法格式二：Lambda需要一个参数，但是没有返回值
    
     *  `Consumer<String> con = (String str) -> {System.out.println(str);};`
 *  语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    
     *  `Consumer<String> con = (str) -> {System.out.println(str);};`
 *  语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
    
     *  `Consumer<String> con = str -> {System.out.println(str);};`
 *  语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
    
     *  `Comparator<Integer> com = (x, y) -> {System.out.println("实现函数式接口方法！"); return Integer.compare(x, y);};`
 *  语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略
    
     *  `Comparator<Integer> com = (x, y) -> Integer.compare(x, y);`

> 总结六种情况：  
> \->左边：lambda形参列表的参数类型可以省略（类型推断）；如果lambda形参列表只有一个参数，其一对()也可以省略  
> \->右边：lambda体应该使用一对\{\}包裹；如果lambda体只有一条执行语句（可能是return语句，省略这一对\{\}和return关键字）

#### 3、函数式接口 ####

##### 3.1、函数式接口的使用说明 #####

*  如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
 *  我们可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口
 *  Lambda表达式的本质：作为函数式接口的实例

##### 3.2、Java8中关于Lambda表达式提供的4个基本的函数式接口 #####

<table> 
 <thead> 
  <tr> 
   <th align="center">函数式接口</th> 
   <th align="center">参数类型</th> 
   <th align="center">返回类型</th> 
   <th align="center">用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>Consumer&lt;T&gt;</code>消费型接口</td> 
   <td align="center">T</td> 
   <td align="center">void</td> 
   <td align="center">对类型为T的对象应用操作，包含方法：void accept(T t)</td> 
  </tr> 
  <tr> 
   <td align="center"><code>Supplier&lt;T&gt;</code>供给型接口</td> 
   <td align="center">无</td> 
   <td align="center">T</td> 
   <td align="center">返回类型为T的对象，包含方法：T get()</td> 
  </tr> 
  <tr> 
   <td align="center"><code>Function&lt;T, R&gt;</code>函数型接口</td> 
   <td align="center">T</td> 
   <td align="center">R</td> 
   <td align="center">对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)</td> 
  </tr> 
  <tr> 
   <td align="center"><code>Predicate&lt;T&gt;</code>断定型接口</td> 
   <td align="center">T</td> 
   <td align="center">boolean</td> 
   <td align="center">确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)</td> 
  </tr> 
 </tbody> 
</table>

##### 3.3、总结 #####

*  何时使用lambda表达式？
    
     *  当需要对一个函数式接口实例化的时候，可以使用lambda表达式
 *  何时使用给定的函数式接口？
    
     *  如果我们开发中需要定义一个函数式接口，首先看看在已有的JDK提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了。

#### 4、方法引用 ####

##### 4.1、理解 #####

*  方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。

##### 4.2、使用情境 #####

*  当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用

##### 4.3、格式 #####

*  类(或对象) :: 方法名

##### 4.4、分为如下的三种情况 #####

*  对象 :: 非静态方法 --> 情况1
 *  类 :: 静态方法 --> 情况2
 *  类 :: 非静态方法 --> 情况3

##### 4.5、要求 #####

*  要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）
 *  当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数（或无参数）时：ClassName :: methodName（针对于情况3）

##### 4.6、使用建议 #####

*  如果给函数式接口提供实例，恰好满足方法引用的使用情境，大家就可以考虑使用方法引用给函数式接口提供实例。如果大家不熟悉方法引用，那么还可以使用lambda表达式。

##### 4.7、使用举例 #####

// 情况一：对象 :: 实例方法
    // Consumer中的void accept(T t)
    // PrintStream中的void println(T t)
    @Test
    public void test1 () {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        // 方法引用
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("beijing");
    }
    // 情况二：类 :: 静态方法
    // Comparator中int compare(T t1, T t2)
    // Integer中的int compare(T t1, T t2)
    @Test
    public void test3 () {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12,21));
        // 方法引用
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 3));
    }
    // 情况三：类 :: 实例方法
    // Comparator中的int compare(T t1, T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5 () {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));
        // 方法引用
        Comparator<String> com2 = String :: compareTo;
        System.out.println(com2.compare("adb", "abm"));
    }

#### 5、构造器引用与数组引用 ####

##### 5.1、构造器引用格式 #####

*  类名::new

##### 5.2、构造器引用使用要求 #####

*  和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

##### 5.3、构造器引用举例 #####

// 构造器引用
    // Supplier的T get()
    // Employee的空参构造器：Employee()
    @Test
    public void test1 () {
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        // lambda表达式
        Supplier<Employee> sup1 = () -> new Employee();
        System.out.println(sup1.get());
        // 构造器引用
        Supplier<Employee> sup2 = Employee :: new;
        System.out.println(sup2.get());
    }
    // Function中的R apply(T t)
    @Test
    public void test2 () {
        Function<Integer, Employee> func1 = id -> new Employee(id);
        System.out.println(func1.apply(1001));
        // 构造器引用
        Function<Integer, Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002));
    }

##### 5.4、数组引用格式 #####

*  数组类型\[\]::new

##### 5.5、数组引用举例 #####

// 数组引用
    // Function中的R apply(T t)
    @Test
    public void test4 () {
        Function<Integer, String[]> func1 = length -> new String[length];
        System.out.println(Arrays.toString(func1.apply(5)));
        // 数组引用
        Function<Integer, String[]> func2 = String[] :: new;
        System.out.println(Arrays.toString(func2.apply(10)));
    }

#### 6、Stream API ####

##### 6.1、Stream API的理解 #####

*  Stream关注的是对数据的运算，与CPU打交道；集合关注的是数据的存储，与内存打交道
 *  Java 8提供了一套API，使用这套API可以对内存中的数据进行过滤、排序、映射、归约等操作。类似SQL对数据库中表的相关操作。

##### 6.2、注意点 #####

*  Stream自己不会存储元素
 *  Stream不会改变源对象。相反，他们会返回一个持有结果的新的Stream
 *  Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

##### 6.3、Stream的使用流程 #####

*  Stream的实例化
 *  一系列的中间操作（过滤、映射、…）
 *  终止操作

##### 6.4、使用流程的注意点 #####

*  一个中间操作链，对数据源的数据进行处理
 *  一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。

##### 6.5、步骤一：Stream实例化 #####

// 创建Stream方式一：通过集合
    @Test
    public void test1 () {
        List<Employee> employees = EmployeeData.getEmployees();
        // default Stream<E> stream()：返回一个顺序流
        Stream<Employee> stream = employees.stream();
        // default Stream<E> parallelStream()：返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }
    // 创建Stream方式二：通过数组
    @Test
    public void test2 () {
        int[] arr = new int[]{1,2,3,4,5,6};
        // 调用Arrays类的static <T> Stream<T> stream(T[] array)：返回一个流
        IntStream stream = Arrays.stream(arr);
    }
    // 创建Stream方式三：通过Stream的of()
    @Test
    public void test3 () {
        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
    }
    // 创建Stream方式四：创建无限流
    @Test
    public void test4 () {
        // 迭代
        // public static <T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        // 遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
        // 生成
        // public static <T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

##### 6.6、步骤二：中间操作 #####

*  筛选与切片
    
     *  filter(Predicate p)：接收Lambda，从流中排除某些元素
     *  distinct()：筛选，通过流所生成元素的hashCode()和equals()去除重复元素
     *  limit(long maxSize)：截断流，使其元素不超过给定数量
     *  skip(long n)：跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
 *  映射
    
     *  map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
     *  mapToDouble(ToDoubleFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
     *  mapToInt(ToIntFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
     *  mapToLong(ToLongFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
     *  flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
 *  排序
    
     *  sorted()：产生一个新流，其中按自然顺序排序
     *  sorted(Comparator com)：产生一个新流，其中按比较器顺序排序

##### 6.7、步骤三：终止操作 #####

*  匹配与查找
    
     *  allMatch(Predicate p)：检查是否匹配所有元素
     *  anyMatch(Predicate p)：检查是否至少匹配一个元素
     *  noneMatch(Predicate p)：检查是否没有匹配所有元素
     *  findFirst()：返回第一个元素
     *  findAny()：返回当前流中的任意元素
     *  count()：返回流中元素总数
     *  max(Comparator c)：返回流中最大值
     *  min(Comparator c)：返回流中最小值
     *  forEach(Consumer c)：内部迭代（使用Collection接口需要用户去做迭代，称为外部迭代。相反，Stream API使用内部迭代——它帮你把迭代做了）
 *  归约
    
     *  reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回T
     *  reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回`Optional<T>`
 *  收集
    
     *  collect(Collector c)：将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法(Collector通过Collectors提供实例)
        
         *  toList()
         *  toSet()
         *  toCollection()

#### 7、Optional类的使用 ####

##### 7.1、理解 #####

*  为了解决Java中的空指针问题而生！
 *  `Optional<T>`类(java.util.Optional)是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。

##### 7.2、常用方法 #####

@Test
    public void test1 () {
        
        // empty()：创建的Optional对象内部的value = null
        Optional<Object> op1 = Optional.empty();
        if (!op1.isPresent()) {
        
            // Optional封装的数据是否包含数据
            System.out.println("数据为空");
        }
        // 如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value
        // System.out.println(op1.get());
    }
    @Test
    public void test2 () {
        
        String str = "hello";
        // of(T t)：封装数据t生成Optional对象，要求t非空，否则报错
        Optional<String> op1 = Optional.of(str);
        // get()通常与of()方法搭配使用。用于获取内部的封装的数据value
        String str1 = op1.get();
        System.out.println(str1);
    }
    @Test
    public void test3 () {
        
        String str = "beijing";
        str = null;
        // ofNullable(T t)：封装数据t赋给Optional内部的value。不要求t非空
        Optional<String> op1 = Optional.ofNullable(str);
        // orElse(T t1)：如果Optional内部的value非空，则返回此value值。如果value为空，则返回t1
        String str2 = op1.orElse("shanghai");
        System.out.println(str2);
    }

[b8c725da5f404036847fd9d5877b5de8.png_pic_center]: https://img-blog.csdnimg.cn/b8c725da5f404036847fd9d5877b5de8.png#pic_center
[Java_Java]: https://jumper.blog.csdn.net/article/details/131418978
[Java_Java 1]: https://jumper.blog.csdn.net/article/details/131425785
[Java_Java 2]: https://jumper.blog.csdn.net/article/details/131428791
[Java_Java 3]: https://jumper.blog.csdn.net/article/details/131436162
[Java_Java 4]: https://jumper.blog.csdn.net/article/details/131443038
[Java_Java 5]: https://jumper.blog.csdn.net/article/details/131443124
[Java_Java 6]: https://jumper.blog.csdn.net/article/details/131443179
[Java_Java 7]: https://jumper.blog.csdn.net/article/details/131443217
[Java_JavaIO]: https://jumper.blog.csdn.net/article/details/131443242
[Java_Java 8]: https://jumper.blog.csdn.net/article/details/131448537
[Java_Java 9]: https://jumper.blog.csdn.net/article/details/131448541
[Java_Java8]: https://jumper.blog.csdn.net/article/details/131448546