是时候了解Java8新特性了

于 2021-11-09 16:58:20 发布
阅读量1.2k 收藏
点赞数
分类专栏： Java 文章标签： java 后端 jdk1.8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cicci_/article/details/121231247
版权

Java8 新特性的使用

Java 8新特性简介

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Java 8 是 oracle 公司于 2014 年 3 月发布，可以看成是自 Java 5 以来最具革命性的版本。Java 8 为 Java 语言、编译器、类库、开发 工具与 JVM 带来了大量新特性。

优点

  • 速度更快
  • 代码更少 (增加了新的语法：Lambda 表达式)
  • 强大的 Stream API
  • 便于并行
  • 最大化减少空指针异常：Optional
  • Nashorn 引擎，允许在 JVM 上运行 JS 应用

并行流与串行流

  • 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

  • Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

Lambda 表达式

为什么使用 Lambda 表达式

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

Lambda 表达式的本质：作为函数式接口的实例（也可以理解为接口的具体实现类）

从匿名类到 Lambda 的转换举例

package com.java.test.day1;

import org.junit.Test;
import java.util.Comparator;

/**
 * @ClassName LambadaTest
 * @Description： Lambda表达式的举例
 * @Author Laoyang
 * @Date 2021/11/6 10:53
 */
public class LambdaTestA {
    @Test
    public void testOne() {
        // 匿名类写法
        Runnable runnableA = new Runnable() {
            @Override
            public void run() {
                System.out.println("奥利给！");
            }
        };

        runnableA.run();

        System.out.println("-----------------------");

        // 使用 Lambda 表达式的写法
        Runnable runnableB = () -> System.out.println("坚持就是胜利！");
        runnableB.run();
    }

    @Test
    public void testTwo() {
        // 匿名类写法
        Comparator<Integer> comparatorA = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare = comparatorA.compare(18, 22);
        System.out.println(compare);

        System.out.println("-----------------------");

        // 使用 Lambda 表达式的写法
        Comparator<Integer> comparatorB = (o1, o2) -> Integer.compare(o1, o2);
        int compare1 = comparatorB.compare(22, 17);
        System.out.println(compare1);

        System.out.println("-----------------------");

        // 方法引用的写法
        Comparator<Integer> comparatorC = Integer :: compare;
        int compare2 = comparatorC.compare(45, 33);
        System.out.println(compare2);
    }
}

语法说明

Lambda 表达式：在 Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->”

->：Lambda 操作符（也可以称为箭头操作符），它将  Lambda  分为两个部分：
操作符左边的值：称为 Lambda 形参列表（其实就是接口中的抽象方法的形参列表）
操作符右边的值：称为 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能（其实就是重写的抽象方法的方法体）

Lambda 表达式六种语法格式

语法格式一：无参，无返回值
package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @ClassName LambdaTestB
 * @Description： Lambda表达式的使用
 * @Author Laoyang
 * @Date 2021/11/6 11:33
 */
public class LambdaTestB {
    /**
     * 语法格式一：无参，无返回值
     */
    @Test
    public void testOne() {
        Runnable runnableA = new Runnable() {
            @Override
            public void run() {
                System.out.println("奥利给！");
            }
        };
        runnableA.run();

        System.out.println("-----------------------");

        // 使用 Lambda 表达式的写法
        Runnable runnableB = () -> System.out.println("坚持就是胜利！");
        runnableB.run();
    }
}
语法格式二：Lambda 需要一个参数，但是没有返回值。
package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @ClassName LambdaTestB
 * @Description： Lambda表达式的使用
 * @Author Laoyang
 * @Date 2021/11/6 11:33
 */
public class LambdaTestB {
    /**
     * 语法格式二：Lambda 需要一个参数，但是没有返回值
     */
    @Test
    public void testTwo() {
        Consumer<String> consumerA = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumerA.accept("嘿嘿嘿");

        System.out.println("-----------------------");

        // 使用 Lambda 表达式的写法，大括号可省略
        Consumer<String> consumerB = (String s) -> {
            System.out.println(s);
        };
        consumerB.accept("哈哈哈");
    }
}
语法格式三：数据类型可以省略，因为可由编译器推断得出，称为 “类型推断”
package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @ClassName LambdaTestB
 * @Description： Lambda表达式的使用
 * @Author Laoyang
 * @Date 2021/11/6 11:33
 */
public class LambdaTestB {
    /**
     * 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为 “类型推断”
     */
    @Test
    public void testThree() {
        Consumer<String> consumerA = (String s) -> {
            System.out.println(s);
        };
        consumerA.accept("嘿嘿嘿");

        System.out.println("-----------------------");

        // 使用类型推断进行优化
        Consumer<String> consumerB = (s) -> {
            System.out.println(s);
        };
        consumerB.accept("哈哈哈");

        System.out.println("-----------------------");

        // 以前使用过的类型推断
        ArrayList<String> list = new ArrayList<>(); // new 出来的 ArrayList 泛型就是 String

        int[] arr = {1, 2, 3};  // 这种也属于类型推断
    }
}
语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @ClassName LambdaTestB
 * @Description： Lambda表达式的使用
 * @Author Laoyang
 * @Date 2021/11/6 11:33
 */
public class LambdaTestB {
    /**
     * 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
     */
    @Test
    public void testFour() {
        Consumer<String> consumerA = (String s) -> {
            System.out.println(s);
        };
        consumerA.accept("嘿嘿嘿");

        System.out.println("-----------------------");

        // 使用语法格式四优化
        Consumer<String> consumerB = s -> {
            System.out.println(s);
        };
        consumerA.accept("嘿嘿嘿");
    }
}
语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @ClassName LambdaTestB
 * @Description： Lambda表达式的使用
 * @Author Laoyang
 * @Date 2021/11/6 11:33
 */
public class LambdaTestB {
    /**
     * 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
     */
    @Test
    public void testFive() {
        Comparator<Integer> comparatorA = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        int compare = comparatorA.compare(18, 22);
        System.out.println(compare);

        System.out.println("-----------------------");

        // 使用 Lambda 表达式的写法
        Comparator<Integer> comparatorB = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        int compare1 = comparatorB.compare(22, 17);
        System.out.println(compare1);
    }
}
语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @ClassName LambdaTestB
 * @Description： Lambda表达式的使用
 * @Author Laoyang
 * @Date 2021/11/6 11:33
 */
public class LambdaTestB {
    /**
     * 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
     */
    @Test
    public void testSix() {
        Comparator<Integer> comparatorA = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        int compare1 = comparatorA.compare(22, 17);
        System.out.println(compare1);

        System.out.println("-----------------------");

        // 使用语法格式六优化
        Comparator<Integer> comparatorB = (o1, o2) -> o1.compareTo(o2);
        int compare2 = comparatorB.compare(22, 56);
        System.out.println(compare2);

        System.out.println("-----------------------");

        Consumer<String> consumerA = s -> {
            System.out.println(s);
        };
        consumerA.accept("奥利给！");

        // 使用语法格式六进行优化
        Consumer<String> consumerB= s -> System.out.println(s);
        consumerB.accept("冲冲冲！");
    }
}
总结

->左边的值：Lambda 形参列表的参数类型可以省略；如果 Lambda 形参列表只有一个参数，() 小括号也可以省略

->右边的值：Lambda 体应该使用一对大括号 {} 包裹，如果 Lambda 体只有一条执行语句（可能是 return 语句），则可以省略大括号和 return 关键字）

注意：如果要写大括号，又返回值的时候则必须加上 return；如果要写 return，则必须加上大括号；否则语法不通过！！！

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “类型推断”。比如：

package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * @ClassName LambdaTestB
 * @Description： 类型推断
 * @Author Laoyang
 * @Date 2021/11/6 11:55
 */
public class TypeInference {
    @Test
    public void test(){
        // 前面设置泛型后，后面的泛型则可以省略，因为会自动跟前面设置的类型对应
        ArrayList<String> list = new ArrayList<>();

        HashMap<Integer, String> map = new HashMap<>();
    }
}

函数式(Functional)接口

什么是函数式(Functional)接口

  • 只包含一个抽象方法的接口，称为函数式接口。
  • 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常 (即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。
  • 我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
  • 在 java.util.function 包下定义了 Java 8 的丰富的函数式接口

如何理解函数式接口

  • Java 从诞生日起就是一直倡导 “一切皆对象”，在 Java 里面面向对象 (OOP) 编程是一切。但是随着 python、scala 等语言的兴起和新技术的挑战，Java 不得不做出调整以便支持更加广泛的技术要求，也即 java 不但可以支持 OOP 还可以支持 OOF（面向函数编程）
  • 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda 表达式的类型是函数。但是在Java8 中，有所不同。在 Java8 中，Lambda 表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
  • 简单的说，在 Java8 中，Lambda 表达式就是一个函数式接口的实例。这就是 Lambda 表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用 Lambda 表达式来表示。
  • 以前用匿名实现类表示的现在都可以用 Lambda 表达式来写。

函数式接口举例

package com.java.test.day1;

/**
 * @ClassName MyInterface
 * @Description： 自定义函数式接口
 * @Author Laoyang
 * @Date 2021/11/6 16:08
 */
@FunctionalInterface
public interface MyInterface {
    /**
     * 一个接口中只有一个抽象方法的话，那这个接口就是函数式接口
     * 添加 @FunctionalInterface 注解可以检查当前接口是否是一个函数式接口
     */
    void method();
}

作为参数传递 Lambda 表达式

在这里插入图片描述

作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收 Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

如果想要使用 Lambda 表达式，则必须使用 函数式接口

Java 内置四大核心函数式接口

函数式接口参数类型返回类型作用
Consumer< T>
消费型接口		Tvoid对类型为T的对象应用操作，包含方法： void accept(T t)
Supplier< T>
供给型接口		无T返回类型为T的对象，包含方法：T get()
Function<T, R>
函数型接口		TR对类型为T的对象应用操作，并返回结果。结 果是R类型的对象。
包含方法：R apply(T t)
Predicate< T>
断定型接口		Tboolean确定类型为T的对象是否满足某约束，并返回 boolean 值。
包含方法：boolean test(T t)

案例

package com.java.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * @ClassName LambdaTestC
 * @Description： Java内置的 4 大核心函数式接口
 * @Author Laoyang
 * @Date 2021/11/6 16:19
 */
public class LambdaTestC {
    /**
     消费型接口：Consume<T>       void accept(T t)
     供给型接口：Supplier<T>      T get()
     函数型接口：Function<T, R>   R apply(T t)
     断定时接口：Predicate<T>     boolean test(T t)
     */
    @Test
    public void testOne() {
        // 消费型接口
        happyTime(3.1415926, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("圆周率为：" + aDouble);
            }
        });

        System.out.println("-------------------------------");

        // Lambda 写法
        happyTime(998, money -> System.out.println("一瓶水的价格为：" + money));
    }

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

    @Test
    public void testTwo() {
        List<String> list = Arrays.asList("北京", "上海", "广州", "深圳", "南京");

        // 断定时接口
        List<String> filterString = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        for (String s : filterString) {
            System.out.println(s);
        }

        System.out.println("-------------------------------");

        // Lambda 写法
        List<String> filterStringB = filterString(list, s -> s.contains("京"));
        for (String s : filterStringB) {
            System.out.println(s);
        }

    }

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

这里只使用了两个函数式接口进行演示，不过大家方向，在后面的案例中都会一 一用到的

其他接口

函数式接口参数类型返回类型作用
BiFunction<T, U, R>T, UR对类型为 参数应用操作，返回 R 类型的结 果。包含方法为： R apply(T t, U u);
UnaryOperator< T>
(Function子接口)		TT对类型为T的对象进行一元运算，并返回T类型的 结果。包含方法为：T apply(T t);
BinaryOperator< T>
(BiFunction 子接口)		T, TT对类型为T的对象进行二元运算，并返回T类型的 结果。包含方法为： T apply(T t1, T t2);
BiConsumer<T, U>T, Uvoid对类型为T, U 参数应用操作。 包含方法为： void accept(T t, U u)
BiPredicate<T,U>T, Uboolean包含方法为： boolean test(T t,U u)
ToIntFunction< T>
ToLongFunction< T>
ToDoubleFunction< T>		Tint
long
double		分别计算int、long、double值的函数
IntFunction< R>
LongFunction< R>
DoubleFunction< R>		int
long
double		R参数分别为int、long、double 类型的函数

方法引用与构造器引用

方法引用 (Method References)

说明

  1. 什么时候使用方法引用？

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

  2. 方法引用本质上就是 Lambda 表达式，而 Lambda 表达式作为函数时接口的实例；所以方法引用，也就是函数式接口的实例。

  3. 使用格式：类（或对象） :: 方法名

  4. 具体分为如下三种情况

    • 情况一：对象 :: 非静态方法

    • 情况二：类 :: 静态方法

    • 情况三：类 :: 非静态方法

    非静态方法又被称为实例方法

  5. 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型 与 方法引用的方法的形参列表和返回值类型相同

    针对于情况一和情况二

  6. 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数 (或无参数) 时：ClassName :: methodName

    针对于情况三

案例

package com.java.test.day2;

import org.junit.Test;
import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodRefTest {
   /**
    *情况一：对象 :: 实例方法
    * Consumer中的void accept(T t)
    * PrintStream中的void println(T t)
    */
   @Test
   public void test1() {
      // Lambda 表达式的写法
      Consumer<String> consumerA = str -> System.out.println(str);
      consumerA.accept("深圳");

      System.out.println("---------------------------");

      // 方法引用的写法
      PrintStream ps = System.out;
      Consumer<String> consumerB = ps :: println;
      consumerB.accept("广州");
   }

   /**
    * Supplier 中的 T get()
    * Employee 中的 String getName()
    */
   @Test
   public void test2() {
      Employee employee = new Employee(1001, "Tom", 23, 5000);

      // Lambda 表达式的写法
      Supplier<String> supplier = () -> employee.getName();
      System.out.println(supplier.get());

      System.out.println("---------------------------");

      // 方法引用的写法
      Supplier<String> stringSupplier = employee :: getName;
      System.out.println(stringSupplier.get());
   }

   /**
    * 情况二：类 :: 静态方法
    * Comparator中的int compare(T t1,T t2)
    * Integer中的int compare(T t1,T t2)
    */
   @Test
   public void test3() {
      // Lambda 表达式的写法
      Comparator<Integer> comparatorA = (o1, o2) -> Integer.compare(o1, o2);
      int compare = comparatorA.compare(18, 26);
      System.out.println(compare);

      System.out.println("---------------------------");

      // 方法引用的写法
      Comparator<Integer> comparatorB = Integer :: compare;
      int compare1 = comparatorB.compare(32, 22);
      System.out.println(compare1);
   }

   /**
    * Function中的R apply(T t)
    * Math中的Long round(Double d)
    */
   @Test
   public void test4() {
      // 普通写法
      Function<Double, Long> functionA = new Function<Double, Long>() {
         @Override
         public Long apply(Double aDouble) {
            return Math.round(aDouble);
         }
      };

      System.out.println("---------------------------");

      // Lambda 表达式写法
      Function<Double, Long> functionB = d -> Math.round(d);
      System.out.println(functionB.apply(12.8));

      System.out.println("---------------------------");

      // 方法引用的写法
      Function<Double, Long> functionC = Math::round;
      System.out.println(functionC.apply(9.2));
   }

   /**
    * 情况三：类 :: 实例方法
    * Comparator中的int comapre(T t1,T t2)
    * String中的int t1.compareTo(t2)
    */
   @Test
   public void test5() {
      // Lambda 表达式写法
      Comparator<String> comparatorA = (o1, o2) -> o1.compareTo(o2);
      System.out.println(comparatorA.compare("abc", "opq"));

      System.out.println("---------------------------");

      // 方法引用的写法
      Comparator<String> comparatorB = String :: compareTo;
      System.out.println(comparatorB.compare("QQ", "WX"));
   }

   /**
    * BiPredicate中的boolean test(T t1, T t2);
    * String中的boolean t1.equals(t2)
    */
   @Test
   public void test6() {
      // Lambda 表达式写法
      BiPredicate<String, String> biPredicateA = (s1, s2) -> s1.equals(s2);
      System.out.println(biPredicateA.test("A", "a"));

      System.out.println("---------------------------");

      // 方法引用的写法
      BiPredicate<String, String> biPredicateB = String :: equals;
      System.out.println(biPredicateB.test("abc", "abc"));
   }

   /**
    * Function中的R apply(T t)
    * Employee中的String getName();
    */
   @Test
   public void test7() {
      Employee employee = new Employee(1001, "Tom", 23, 5000);

      // Lambda 表达式写法
      Function<Employee, String> functionA = e -> e.getName();
      System.out.println(functionA.apply(employee));

      System.out.println("---------------------------");

      // 方法引用的写法
      Function<Employee, String> functionB = Employee::getName;
      System.out.println(functionB.apply(employee));
   }
}

构造器引用与数组引用

构造器引用

  1. 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致；抽象方法的返回值类型即为构造器所属的类的类型。
  2. 格式： ClassName :: new

数组引用

  1. 大家可以把数组看做是一个特殊的类，写法与构造器引用一致。
  2. 格式： type[] :: new

案例

package com.java.test.day2;

import org.junit.Test;
import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

public class ConstructorRefTest {
    //--------------------构造器引用--------------------
    /**
     * Supplier中的T get()
     * Employee 空参构造器：Employee()
     */
    @Test
    public void test1(){
        // 普通写法
        Supplier<Employee> supplierA = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        System.out.println("---------------------------");

        // Lambda 表达式的写法
        Supplier<Employee> supplierB = () -> new Employee();
        System.out.println(supplierB.get());

        System.out.println("---------------------------");

        // 构造器引用的写法
        Supplier<Employee> supplierC = Employee::new;
        System.out.println(supplierC.get());
    }

   /**
    * Function中的R apply(T t)
    */
    @Test
    public void test2(){
        // Lambda 表达式的写法
        Function<Integer, Employee> functionA = id -> new Employee(id);
        System.out.println(functionA.apply(1001));

        System.out.println("---------------------------");

        // 构造器引用的写法，因为这里我们规定了参数类型为 Integer 类型的，所以会默认去 Employee 类中找到对应的构造器进行创建
        Function<Integer, Employee> functionB = Employee::new;
        System.out.println(functionB.apply(1002));
    }

   /**
    * BiFunction中的R apply(T t,U u)
    */
    @Test
    public void test3(){
        // Lambda 表达式的写法
        BiFunction<Integer, String, Employee> biFunctionA = (id, name) -> new Employee(id, name);
        System.out.println(biFunctionA.apply(1001, "Tom"));

        System.out.println("---------------------------");

        // 构造器引用的写法
        BiFunction<Integer, String, Employee> biFunctionB = Employee::new;
        System.out.println(biFunctionB.apply(1002, "Jerry"));
    }

   //--------------------数组引用--------------------

    /*
     * Function中的R apply(T t)
     */
    @Test
    public void test4(){
        // Lambda 表达式的写法
        Function<Integer, String[]> functionA = length -> new String[length];
        System.out.println(Arrays.toString(functionA.apply(10)));
        System.out.println(functionA.apply(10).length);

        System.out.println("---------------------------");

        // 数组引用的写法
        Function<Integer, String[]> functionB = String[]::new;
        System.out.println(Arrays.toString(functionB.apply(5)));
        System.out.println(functionB.apply(5).length);

    }
}

强大的 Stream API

Stream 的概述

  1. Stream 关注的是对数据的运算，与 CPU 打交道；集合关注的是数据的存储，与内存打交道

  2. 注意点：

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

  3. Stream 执行流程

    ① Stream 实例化
    ② 一系列的中间操作（比如：过滤、映射等…)
    ③ 终止操作

  4. 说明
    ① 一个中间操作，对数据源的数据进行处理
    ② 一旦执行终止操作，就会执行中间操作，并产生结果。之后，该 Stream 不会再被使用！！！

    具体的大家可以看案例代码

  5. Stream到底是什么呢？
    是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，Stream 讲的是计算！”

Stream 说明

  • Java8 中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。
  • Stream API ( java.util.stream) 把真正的函数式编程风格引入到 Java 中。这是目前为止对 Java 类库最好的补充，因为 Stream API 可以极大提供 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。
  • Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用 Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。 也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

为什么要使用Stream API

  • 实际开发中，项目中多数数据源都来自于 Mysql，Oracle 等。但现在数据源可以更多了，有 MongDB，Radis 等，而这些 NoSQL 的数据就需要 Java 层面去处理。
  • Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中， 后者主要是面向 CPU，通过 CPU 实现计算。

Stream 的操作三个步骤

  1. 创建 Stream
    一个数据源（如：集合、数组），获取一个流
  2. 中间操作
    一个中间操作链，对数据源的数据进行处理
  3. 终止操作(终端操作)
    一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

步骤一：创建 Stream

创建方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流 的方法：

  • default Stream< E> stream()：返回一个顺序流

  • default Stream< E> parallelStream()：返回一个并行流

package com.java.test.day3;

import com.java.test.day2.Employee;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @ClassName StreamTest
 * @Description： Stream API 的使用
 * @Author Laoyang
 * @Date 2021/11/7 16:06
 */
public class StreamTestA {
    /**
     * 创建 Stream方式一：通过集合
     */
    @Test
    public void testOne() {
        List<Employee> employees = EmployeeData.getEmployees();

        // default Stream<E> stream() : 返回一个顺序流（顺序打印）
        Stream<Employee> stream = employees.stream();

        // default Stream<E> parallelStream() : 返回一个并行流（随机打印）
        Stream<Employee> employeeStream = employees.parallelStream();
    }
}

创建方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

  • static < T> Stream< T> stream(T[] array)：返回一个流

重载形式，能够处理对应基本类型的数组：

  • public static IntStream stream(int[] array)
  • public static LongStream stream(long[] array)
  • public static DoubleStream stream(double[] array)
package com.java.test.day3;

import com.java.test.day2.Employee;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @ClassName StreamTest
 * @Description： Stream API 的使用
 * @Author Laoyang
 * @Date 2021/11/7 16:06
 */
public class StreamTestA {
    /**
     * 创建 Stream方式二：通过数组
     */
    @Test
    public void testTwo() {
        int[] array = {1, 2, 3, 4, 5};

        // static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(array);

        Employee employeeA = new Employee(1001, "Tom");
        Employee employeeB = new Employee(1002, "Jerry");
        Employee[] employees = new Employee[]{employeeA, employeeB};
        Stream<Employee> stream1 = Arrays.stream(employees);
    }
}

创建方式三：通过 Stream 的 of()

可以调用 Stream 类静态方法 of()，通过显示值创建一个流。它可以接收任意数量的参数。

  • public static< T> Stream< T> of(T… values)：返回一个流
package com.java.test.day3;

import com.java.test.day2.Employee;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @ClassName StreamTest
 * @Description： Stream API 的使用
 * @Author Laoyang
 * @Date 2021/11/7 16:06
 */
public class StreamTestA {
    /**
     * 创建 Stream方式三：通过Stream的of()
     */
    @Test
    public void testThree() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
        Stream<Object> objectStream = Stream.of(1, 2, "QQ");
    }
}

创建方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate()，创建无限流。

  • 迭代：public static< T> Stream< T> iterate(final T seed, final UnaryOperator< T> f)
  • 生成：public static< T> Stream< T> generate(Supplier< T> s)
package com.java.test.day3;

import com.java.test.day2.Employee;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @ClassName StreamTest
 * @Description： Stream API 的使用
 * @Author Laoyang
 * @Date 2021/11/7 16:06
 */
public class StreamTestA {
    /**
     * 创建 Stream方式四：创建无限流
     * > 这种方式用的比较少
     * Ps：因为是无限流，所以在获取对应数据之后如果不限制，则会一直执行，下面演示了两个案例
     */
    @Test
    public void testFour() {
        // 迭代：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);

        System.out.println("------------------------");

        // 生成：public static<T> Stream<T> generate(Supplier<T> s)
        // 案例：遍历10个随机数
        Stream.generate(Math :: random).limit(10).forEach(System.out :: println);
    }
}

步骤二：中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为 “惰性求值”。

常用方法

筛选与切片
方法作用
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)产生一个新流，其中按比较器顺序排序（定制排序）

案例

package com.java.test.day3;

import com.java.test.day2.Employee;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * @ClassName StreamTestB
 * @Description： Stream的中间操作
 * @Author Laoyang
 * @Date 2021/11/7 16:35
 */
public class StreamTestB {
    /**
     * 筛选与切片
     */
    @Test
    public void testOne() {
        List<Employee> employees = EmployeeData.getEmployees();

        // filter(Predicate p)：接收 Lambda，从流中排除某些元素
        Stream<Employee> streamA = employees.stream();
        // 查询员工表中薪资大于 7000 的员工信息
        streamA.filter(e -> e.getSalary() > 7000).forEach(System.out :: println);

        System.out.println("------------------------------");

        // limit(long maxSize)：截断流，使其元素不超过给定数量
        Stream<Employee> streamB = employees.stream();
        // 默认情况下，limit() 方法会从头到尾截取数据，所以这里就是获取到了员工表中的前三条信息
        streamB.limit(3).forEach(System.out :: println);

        System.out.println("------------------------------");

        // skip(long n)：跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        Stream<Employee> streamC = employees.stream();
        // 跳过指定条数的数据，然后在往后获取
        streamC.skip(3).forEach(System.out :: println);
        // 如果要跳过的数据大于表中现有的数据，则不返回数据
//        streamC.skip(99).forEach(System.out :: println);

        System.out.println("------------------------------");

        // distinct()：筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        employees.add(new Employee(1010, "Tom", 12, 3500));
        employees.add(new Employee(1010, "Tom", 12, 3500));
        employees.add(new Employee(1010, "Tom", 24, 3500));
        System.out.println(employees);  // 添加重复数据进行测试

        System.out.println();

        // 去重，只留下一个（只会去除所有信息完全一直的员工）
        Stream<Employee> streamD = employees.stream();
        streamD.distinct().forEach(System.out :: println);
    }

    /**
     * 映射
     */
    @Test
    public void testTwo() {
        // map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("ab", "cd", "qq");
        Stream<String> stream = list.stream();
        stream.map(str -> str.toUpperCase()).forEach(System.out :: println);    // 将所有元素转换为大写格式

        System.out.println("------------------------------");

        // 练习一：获取员工姓名长度大于3的员工的姓名
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Employee> stream1 = employees.stream();
        // 获取所有员工姓名
        Stream<String> nameStream = stream1.map(Employee::getName);
        // 使用 filter 进行排除
        nameStream.filter(name -> name.length() > 3).forEach(System.out :: println);

        System.out.println("------------------------------");

        // 练习二：将字符串中的多个字符构成的集合转换为对于的 Stream 实例
        Stream<String> stream2 = list.stream();
        Stream<Stream<Character>> streamStream = stream2.map(StreamTestB::formStringToStream);
        // 类似于 for 循环嵌套
        streamStream.forEach(s -> {
            s.forEach(System.out :: println);
        });

        System.out.println("------------------------------");

        // flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流（跟 addAll() 方法类似的效果）
        Stream<String> stream3 = list.stream();
        Stream<Character> characterStream = stream3.flatMap(StreamTestB::formStringToStream);
        characterStream.forEach(System.out :: println);
    }

    /**
     * 将字符串中的多个字符构成的集合转换为对于的 Stream 实例
     * @param str
     * @return
     */
    public static Stream<Character> formStringToStream(String str) {
        ArrayList<Character> list = new ArrayList<>();
        for (Character character : str.toCharArray()) {
            list.add(character);
        }
        return list.stream();
    }

    /**
     * List中集合添加集合的写法
     */
    @Test
    public void testGather() {
        List list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);

        List list2 = new ArrayList<>();
        list2.add(12);
        list2.add(23);

        /*
         3个元素，因为 add() 方法会把 list2 当做是一整个元素
         如果想要打印出 list2 中的元素，则需要使用嵌套循环，导致效率较低
         */
//        list1.add(list2);
//        System.out.println(list1);

        // 4个元素，将 list2 中的所有元素添加到 list1 中，遍历的时候只需要使用一层循环结构即可遍历所有元素
        list1.addAll(list2);
        System.out.println(list1);
    }

    /**
     * 排序
     */
    @Test
    public void testThree() {
        List<Integer> list = Arrays.asList(2, 44, 66, 7, 13, 180, 99);
        List<Employee> employees = EmployeeData.getEmployees();

        // sorted() 产生一个新流，其中按自然顺序排序
        Stream<Integer> stream = list.stream();
        stream.sorted().forEach(System.out :: println);

        // 抛异常，因为 Employee 类没有实现 Comparable 接口
//        Stream<Employee> stream1 = employees.stream();
//        stream1.sorted().forEach(System.out :: println);

        System.out.println("------------------------------");

        // sorted(Comparator com) 产生一个新流，其中按比较器顺序排序（定制排序）
        Stream<Employee> stream1 = employees.stream();
        stream1.sorted((e1, e2) -> {
            int compare = Integer.compare(e1.getAge(), e2.getAge());
            if (compare != 0) {
                return compare;
            } else {
                // 从小到大排序，如果想要从大到小，只需要在前面加上负号（-）即可
//                return Integer.compare(e1.getId(), e2.getId());
                return -Integer.compare(e1.getId(), e2.getId());
            }
        }).forEach(System.out :: println);
    }
}

步骤三：终止操作

  • 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。
  • 流进行了终止操作后，就不能再次使用。

常用方法

匹配与查找
方法作用
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 接口中方法的实现决定了如何对流执行收集的操作 (如收集到 List、Set、 Map)。

另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例， 具体方法与实例如下图：

在这里插入图片描述
在这里插入图片描述

有对应的方法和对应的例子，大家可自行测试

案例

package com.java.test.day3;

import com.java.test.day2.Employee;
import org.junit.Test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @ClassName StreamTestC
 * @Description： Stream的终止操作
 * @Author Laoyang
 * @Date 2021/11/7 20:22
 */
public class StreamTestC {
    /**
     * 匹配与查找
     */
    @Test
    public void testOne() {
        List<Employee> employees = EmployeeData.getEmployees();

        // allMatch(Predicate p)：检查是否匹配所有元素
        // 练习：是否所有的员工年龄都大于 18 岁
        Stream<Employee> streamA = employees.stream();
        boolean allMatch = streamA.allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

        System.out.println("------------------------------");

        // anyMatch(Predicate p)：检查是否至少匹配一个元素
        // 练习：是否存在员工的工资大于 9000
        Stream<Employee> streamB = employees.stream();
        boolean anyMatch = streamB.anyMatch(e -> e.getSalary() > 9000);
        System.out.println(anyMatch);

        System.out.println("------------------------------");

        // noneMatch(Predicate p)：检查是否没有匹配所有元素（注意！这个方法找的是没有某某东西的数据！！！）
        // 练习：是否存在员工姓 “马”
        Stream<Employee> streamC = employees.stream();
        boolean noneMatch = streamC.noneMatch(e -> e.getName().startsWith("马"));
        System.out.println(noneMatch);

        System.out.println("------------------------------");

        // findFirst()：返回第一个元素
        Stream<Employee> streamD = employees.stream();
        Optional<Employee> first = streamD.findFirst();
        System.out.println(first);

        System.out.println("------------------------------");

        // findAny()：返回当前流中的任意元素
        Stream<Employee> streamE = employees.parallelStream();
        Optional<Employee> any = streamE.findAny();
        System.out.println(any);
    }

    @Test
    public void testTwo() {
        List<Employee> employees = EmployeeData.getEmployees();

        // count()：返回流中元素总数
        Stream<Employee> streamA = employees.stream();
        long count = streamA.count();
        System.out.println(count);

        System.out.println("------------------------------");

        // max(Comparator c)：返回流中最大值
        // 练习：找最高的工资
        Stream<Employee> streamB = employees.stream();
        Stream<Double> doubleStream = streamB.map(e -> e.getSalary());
        Optional<Double> max = doubleStream.max(Double::compare);
        System.out.println(max);

        System.out.println("------------------------------");

        // min(Comparator c)：返回流中最小值
        // 练习：返回最低工资的员工
        Stream<Employee> streamC = employees.stream();
        Optional<Employee> min = streamC.min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);

        System.out.println("------------------------------");

        // forEach(Consumer c)：内部迭代 (使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
        Stream<Employee> streamD = employees.stream();
        streamD.forEach(System.out :: println);
    }

    /**
     * 归纳
     */
    @Test
    public void testThree() {
        // reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回 T
        // 练习：计算1-10的自然数的和
       List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Stream<Integer> stream = list.stream();
        Integer reduce = stream.reduce(0, Integer::sum);
        System.out.println(reduce);

        System.out.println("------------------------------");

        // reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
        // 练习：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Employee> stream1 = employees.stream();
        Stream<Double> doubleStream = stream1.map(e -> e.getSalary());
//        Optional<Double> reduce1 = doubleStream.reduce(Double::sum);  // 方式一
        Optional<Double> reduce1 = doubleStream.reduce((d1, d2) -> d1 + d2);    // 方式二
        System.out.println(reduce1);
    }

    /**
     * 收集
     */
    @Test
    public void testFour() {
        List<Employee> employees = EmployeeData.getEmployees();
        // collect(Collector c)：将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
        // 练习：查找工资大于 6000 的员工，结果返回一个 List 或 Set
        // 返回List
        Stream<Employee> stream = employees.stream();
        Stream<Employee> employeeStream = stream.filter(e -> e.getSalary() > 6000);
        List<Employee> collect = employeeStream.collect(Collectors.toList());
        collect.forEach(System.out :: println);

        System.out.println("------------------------------");

        // 返回Set
        Stream<Employee> streamA = employees.stream();
        Stream<Employee> employeeStreamA = streamA.filter(e -> e.getSalary() > 8000);
        Set<Employee> collectA = employeeStreamA.collect(Collectors.toSet());
        collectA.forEach(System.out :: println);

        System.out.println("------------------------------");

        // 返回 Collector，实际上也是根据 toCollectors() 方法中的参数来返回对应类型的数据
        Stream<Employee> streamB = employees.stream();
        Stream<Employee> employeeStreamB = streamB.filter(e -> e.getSalary() > 3500);
        HashSet<Employee> collectB = employeeStreamB.collect(Collectors.toCollection(HashSet::new));
        collectB.forEach(System.out :: println);
    }
}

Optional 类

说明

Optional类：为了在程序中避免出现空指针异常而创建的

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

常用方法

  • ofNullable(T t)：t 可以为 null
  • T orElse(T other) ：如果当前的 Optional 内部封装的 t 是非空的，则返回内部的 t；如果内部的 t 是空的，则返回 orElse() 方法中的参数 t1

常用方法

Optional 提供很多有用的方法，这样我们就不用显式进行空值检测

创建Optional类对象的方法

方法作用
Optional.of(T t)创建一个 Optional 实例，t 必须非空
Optional.empty()创建一个空的 Optional 实例
Optional.ofNullable(T t)t 可以为 null

判断Optional容器中是否包含对象

方法作用
boolean isPresent()判断是否包含对象
void ifPresent(Consumer<? super T> consumer)如果有值，就执行 Consumer 接口的实现代码，并且该值会作为参数传给它

判断Optional容器中是否包含对象

方法作用
T get()如果调用对象包含值，返回该值，否则抛异常
T orElse(T other)如果有值则将其返回，否则返回指定的other对象
T orElseGet(Supplier<? extends T> other)如果有值则将其返回，否则返回由Supplier接口实现提供的对象
T orElseThrow(Supplier<? extends X> exceptionSupplier)如果有值则将其返回，否则抛出由Supplier接口实现提供的异常

案例

Optional 类创建 & 部分方法的使用

package com.java.test.day4;

import org.junit.Test;
import java.util.Optional;

/**
 * @ClassName OptionalTest
 * @Description： Optional 类的使用
 * @Author Laoyang
 * @Date 2021/11/8 10:32
 */
public class OptionalTest {
    /**
     * 创建Optional类对象的方法：
     * Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
     * Optional.empty() : 创建一个空的 Optional 实例
     * Optional.ofNullable(T t)：t可以为null
     */
    @Test
    public void testOne() {
        Girl girl = new Girl();
        girl = null;
        // of(T t)：必须保证 t 是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);
        System.out.println(optionalGirl);
    }

    @Test
    public void testTwo() {
        Girl girl = new Girl();
        /*
         注释前把 girl 设置为空（null），注释后把 girl = new Girl()
         > 大家可以自己测试一下
         */
        girl = null;

        // ofNullable(T t)：t可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);

        /*
         T orElse(T other) ：如果当前的 Optional 内部封装的 t 是非空的，则返回内部的 t
                             如果内部的 t 是空的，则返回 orElse() 方法中的参数 t1
          从该案例中可以理解为：如果 Optional.ofNullable(girl) 中的 girl 不为空，则返回 girl 的值（）
                             如果为空，则返回 optionalGirl.orElse(new Girl("Tom")) 方法中 new Girl("Tom")
         */
        Girl tom = optionalGirl.orElse(new Girl("Tom"));
        System.out.println(tom);
    }

    @Test
    public void testThree() {
        Boy boy = new Boy();
//        String girlName = getGirlNameA(boy);

        String girlName = getGirlNameB(boy);
        System.out.println(girlName);
    }

    public String getGirlNameA(Boy boy) {
        return boy.getGirl().getName();
    }

    /**
     * 优化 getGirlNameA()
     */
    public String getGirlNameB(Boy boy) {
        if (boy != null) {
            Girl girl = boy.getGirl();
            if (girl != null) {
                return girl.getName();
            }
        }
        return null;
    }

    @Test
    public void testFour() {
        Boy boy = null;
        String girlNameC = getGirlNameC(boy);
        System.out.println(girlNameC);  // Jerry

        System.out.println("---------------");

        Boy boy1 = new Boy();
        String girlNameC1 = getGirlNameC(boy1);
        System.out.println(girlNameC1);  // Lisa

        System.out.println("---------------");

        Boy boy2 = new Boy(new Girl("小白"));
        String girlNameC2 = getGirlNameC(boy2);
        System.out.println(girlNameC2);  // 小白
    }

    /**
     * 使用Optional类优化 getGirlNameA()
     */
    public String getGirlNameC(Boy boy) {
        Optional<Boy> optionalBoy = Optional.ofNullable(boy);
        // 此时的 jerry 一定非空
        Boy jerry = optionalBoy.orElse(new Boy(new Girl("Jerry")));
        Girl girl = jerry.getGirl();

        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        // lisa 一定非空
        Girl lisa = optionalGirl.orElse(new Girl("Lisa"));
        return lisa.getName();
    }
}

常用方法的使用

package com.java.test.day4;

import org.junit.Test;
import java.util.Optional;

/**
 * @ClassName OptionalMethodTest
 * @Description： Option 类的常用方法
 * @Author Laoyang
 * @Date 2021/11/8 21:08
 */
public class OptionalMethodTest {
    /**
     * empty()：这个方法了解一下即可
     */
    @Test
    public void testOne() {
        // empty()：创建的 Optional 对象内部的 value = null
        Optional<Object> empty = Optional.empty();
        // isPresent()：Optional 封装的数据是否包含数据
        if (!empty.isPresent()) {
            System.out.println("数据为空");
        }
        System.out.println(empty);  // 空
        System.out.println(empty.isPresent());     // Optional.empty
        /*
         如果 Optional 封装的数据 value 为空，则 get() 报错，value 不为空时，返回 value
         Optional 部分源码：
         public final class Optional<T> {
              private final T value;
         }
         */
        //    System.out.println(empty.get());  // 报错
    }

    /**
     * of() 与 get()
     */
    @Test
    public void testTwo() {
        String str = "hello";
        str = null;

        // of(T t)：封装数据 t 生成 Optional 对象，要求 t 不为空，否则会报错
        Optional<String> str1 = Optional.of(str);

        // get() 通常与 of() 方法搭配使用，用于获取内部的封装数据
        String s = str1.get();
        System.out.println(s);  // hello，str 设置为 null 后，get() 报错
    }

    /**
     * ofNullable() 与 orElse()
     */
    @Test
    public void testThree() {
        String str = "Tom";
        str = null;

        // ofNullable(T t)：封装数据 t 赋给 Optional 内部的 value，不要求 t 不为空
        Optional<Object> optional = Optional.ofNullable(str);

        // orElse(T t1)：如果 Optional 内部的 value 非空，则返回此 value 值，如果 value 为空，则返回 t1
        Object jerry = optional.orElse("Jerry");
        System.out.println(jerry);  // str 不为空，则打印 str，如果为空，则打印 t1
    }
}
万能的小白。
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值