Java StreamAPI和Optional类的使用

作者: 程序员汪汪 | 来源:发表于2021-03-27 19:03 被阅读0次

Stream API概述

流（Stream）是与任何特定存储机制无关的元素序列，它关注的是对数据的运算操作，与CPU打交道；集合关注的数据的存储，与内存打交道。

Stream API是Java8提供的一套API，使用这套API可以对内存中的数据进行过滤、排序、映射、规约等操作，和sql对数据库中数据的操作类似，也可以近似地看成是集合中的迭代器Iterator的增强版。

需要注意的点：

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

Stream使用流程

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

需要注意的点：

一个中间操作链，是对数据源的数据进行处理。
执行终止操作，中间操作链才会执行，然后产生结果。之后，不会再次，如果想要再次获得这个结果，就要重新执行前面的流程。

下面按照使用流程来进行使用

创建Stream

创建Stream总共有四种方式，直接看示例代码：

public class StreamAPITest {

    //创建Stream方式一：通过集合
    @Test
    public void test() {
        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);

        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jerry");
        Employee[] arr1 = {e1, e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);

    }

    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3() {

        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

    }

    //创建Stream方式四：创建无限流
    @Test
    public void test4() {

        //迭代
        //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);

        //生成
        //static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }
}

上述例子中有两个类EmployeeData和Employee，后续操作会用到，这里给出相关代码。

Employee类：

public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Employee() {

    }

    public Employee(int id) {

        this.id = id;
    }

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Employee(int id, String name, int age, double salary) {

        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;

        Employee employee = (Employee) o;

        if (id != employee.id)
            return false;
        if (age != employee.age)
            return false;
        if (Double.compare(employee.salary, salary) != 0)
            return false;
        return name != null ? name.equals(employee.name) : employee.name == null;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + age;
        temp = Double.doubleToLongBits(salary);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
}

EmployeeData类：

public class EmployeeData {
    
    public static List<Employee> getEmployees(){
        List<Employee> list = new ArrayList<>();
        
        list.add(new Employee(1001, "马化腾", 34, 6000.38));
        list.add(new Employee(1002, "马云", 12, 9876.12));
        list.add(new Employee(1003, "刘强东", 33, 3000.82));
        list.add(new Employee(1004, "雷军", 26, 7657.37));
        list.add(new Employee(1005, "李彦宏", 65, 5555.32));
        list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
        list.add(new Employee(1007, "任教主", 26, 4333.32));
        list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
        
        return list;
    }
    
}

中间操作

多个中间操作可以连接起来就像火车的车厢，而终止操作就像是一个火车头，在没有火车头的情况下，单独连接在一起的车厢不会动，只有接上火车头，那么车厢才能动，也就是说一个或多个中间操作在没有终止操作的时候，是不执行的。

筛选与切片

方法	描述
filter(Predicate p)	接收Lambda表达式，从流中排除某些元素
distinct()	筛选，通过流所生成元素的hashCode()和equals()去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定的数量
skip(long n)	跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补

代码示例：

//执行终止操作后，Stream流就被关闭了，使用时需要再次创建Stream流
@Test
public void test1() {
    List<Employee> employees = EmployeeData.getEmployees();
    // filter(Predicate p) -- 接收 Lambda表达式，从流中排除某些元素。
    Stream<Employee> employeeStream = employees.stream();
    // 练习：查询员工表中薪资大于7000的员工信息
    employeeStream.filter(employee -> employee.getSalary() > 7000).forEach(System.out::println);
    System.out.println();//换行

    // 每次执行完终止操作后，流就被关闭了，
    // 如果不重新生成一个，继续操作就会报错java.lang.IllegalStateException: stream has already been operated upon or closed
    employeeStream = employees.stream();
    // limit(n) -- 截断流，使其元素不超过给定数量。
    employeeStream.limit(3).forEach(System.out::println);
    System.out.println();

    // skip(n) -- 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补
    employees.stream().skip(3).forEach(System.out::println);
    System.out.println();

    // distinct() -- 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素。
    employees.add(new Employee(10086, "周鸿祎", 50, 88888));
    employees.add(new Employee(10086, "周鸿祎", 50, 88888));
    employees.add(new Employee(10086, "周鸿祎", 50, 88888));
    employees.add(new Employee(10086, "周鸿祎", 50, 88888));
    employees.stream().distinct().forEach(System.out::println);

}
/**
运行结果：
    Employee{id=1002, name='马云', age=12, salary=9876.12}
    Employee{id=1004, name='雷军', age=26, salary=7657.37}
    Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}

    Employee{id=1001, name='马化腾', age=34, salary=6000.38}
    Employee{id=1002, name='马云', age=12, salary=9876.12}
    Employee{id=1003, name='刘强东', age=33, salary=3000.82}

    Employee{id=1004, name='雷军', age=26, salary=7657.37}
    Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
    Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
    Employee{id=1007, name='任教主', age=26, salary=4333.32}
    Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}

    Employee{id=1001, name='马化腾', age=34, salary=6000.38}
    Employee{id=1002, name='马云', age=12, salary=9876.12}
    Employee{id=1003, name='刘强东', age=33, salary=3000.82}
    Employee{id=1004, name='雷军', age=26, salary=7657.37}
    Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
    Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
    Employee{id=1007, name='任教主', age=26, salary=4333.32}
    Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
    Employee{id=10086, name='周鸿祎', age=50, salary=88888.0}

*/

映射

方法	描述
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStrream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

代码示例：

@Test
public void test2() {
    List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
    // map(Function f) -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，
    // 该函数会被应用到每个元素上，，并将其映射成一个新的元素。
    list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
    System.out.println();

    // 练习1：获取员工姓名长度大于3的员工的姓名。
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<String> namesStream = employees.stream().map(Employee::getName);
    namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
    System.out.println();

    // 练习2: 使用map()中间操作实现flatMap()中间操作方法
    Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
    streamStream.forEach(s -> {
        s.forEach(System.out::println);
    });
    System.out.println();

    // flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
    Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
    characterStream.forEach(System.out::println);

}
// 将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str) {
    ArrayList<Character> list = new ArrayList<>();
    for (Character c : str.toCharArray()) {
        list.add(c);
    }
    return list.stream();
}
// map()和flatMap()方法类似于List中的add()和addAll()方法
// add()方法直接将list2集合作为元素添加到list1中，addAll()方法将list2中的元素添加到list1中
@Test
public void test() {
    ArrayList list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    list1.add(4);

    ArrayList list2 = new ArrayList<>();
    list2.add(5);
    list2.add(6);
    list2.add(7);

    //list1.add(list2);
    //System.out.println(list1); //[1, 2, 3, 4, [5, 6, 7]]
    list1.addAll(list2);
    System.out.println(list1); //[1, 2, 3, 4, 5, 6, 7]
}

/**
运行结果：
    AA
    BB
    CC
    DD

    比尔盖茨
    扎克伯格

    a
    a
    b
    b
    c
    c
    d
    d

    a
    a
    b
    b
    c
    c
    d
    d
*/

排序

方法	描述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序

代码示例：

@Test
public void Test3() {
    // sorted() -- 自然排序
    List<Integer> list = Arrays.asList(12, -34, 84, 64, 33);
    list.stream().sorted().forEach(System.out::println);
    System.out.println();

    // 抛异常，原因：Employee没有实现Comparable接口；如果不想修改Employee类，
    // 就需要使用定制排序sorted(Comparator com)
    //        List<Employee> employees = EmployeeData.getEmployees();
    //        employees.stream().sorted().forEach(System.out::println);

    // sorted(Comparator com) -- 定制排序
    List<Employee> employees1 = EmployeeData.getEmployees();
    employees1.stream().sorted((e1, e2) -> {
        int ageValue = Integer.compare(e1.getAge(), e2.getAge());
        if (ageValue != 0) {
            return ageValue;
        } else {
            return -Double.compare(e1.getSalary(), e2.getSalary());
        }
    }).forEach(System.out::println);
}
/**
运行结果：
    -34
    12
    33
    64
    84

    Employee{id=1002, name='马云', age=12, salary=9876.12}
    Employee{id=1004, name='雷军', age=26, salary=7657.37}
    Employee{id=1007, name='任教主', age=26, salary=4333.32}
    Employee{id=1003, name='刘强东', age=33, salary=3000.82}
    Employee{id=1001, name='马化腾', age=34, salary=6000.38}
    Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
    Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
    Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
*/

终止操作（终止操作）

终端操作会从流的流管道生成结果，其结果可以使任何不是流的值，例如：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使用内部迭代——它帮你把迭代做了）

代码示例：

public class StreamAPITest2 {

    @Test
    public void Test1() {
        List<Employee> employees = EmployeeData.getEmployees();
        // allMatch(Predicate p) -- 检查是否匹配所有元素。
        // 练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

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

        // noneMatch(Predicate p) -- 检查是否没有匹配的元素。注意，这里没有匹配的元素才会返回true
        // 练习：是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
        System.out.println();

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

        // findAny -- 返回当前流中的任意元素，配合并行流才能看到效果，串行流只会返回第一个
        Optional<Employee> employee = employees.parallelStream().findAny();
        System.out.println(employee);
        
        /**
        运行结果：
            false
            true
            false
            Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
            Optional[Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}]
        */
    }

    @Test
    public void Test2() {
        List<Employee> employees = EmployeeData.getEmployees();
        // count() -- 返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

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

        // min(COmparator c) -- 返回流中最小值
        // 练习：返回最低的工资
        Optional<Double> minSalary = employees.stream().map(e -> e.getSalary()).min(Double::compareTo);
        System.out.println(minSalary);

        // forEach(Consumer c) -- 内部迭代
        employees.stream().forEach(System.out::println);
        System.out.println();
        // 使用集合的遍历操作
        employees.forEach(System.out::println);
        
        /**
        运行结果：
            5
            Optional[9876.12]
            Optional[2500.32]
            Employee{id=1001, name='马化腾', age=34, salary=6000.38}
            Employee{id=1002, name='马云', age=12, salary=9876.12}
            Employee{id=1003, name='刘强东', age=33, salary=3000.82}
            Employee{id=1004, name='雷军', age=26, salary=7657.37}
            Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
            Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
            Employee{id=1007, name='任教主', age=26, salary=4333.32}
            Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}

            Employee{id=1001, name='马化腾', age=34, salary=6000.38}
            Employee{id=1002, name='马云', age=12, salary=9876.12}
            Employee{id=1003, name='刘强东', age=33, salary=3000.82}
            Employee{id=1004, name='雷军', age=26, salary=7657.37}
            Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
            Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
            Employee{id=1007, name='任教主', age=26, salary=4333.32}
            Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
        */
    }
    
}

规约

方法	描述
reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回Optional<T>

map和reduce的连接通常称为 map-reduce模式，因Google用它来进行网络搜索而出名

代码示例：

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

        // reduce(BinaryOperator) -- 可以将流中元素反复结合起来，得到一个值，返回Optional<T>
        // 练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> sumSalary = employees.stream().map(e -> e.getSalary()).reduce(Double::sum);
        System.out.println(sumSalary);
    }
/**
运行结果：
    55
    Optional[48424.08]
*/

收集

方法	描述
collect(Collector c)	将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List、Set、Map）

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

Collectors类的静态方法

代码示例：

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

        System.out.println();

        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        employeeSet.forEach(System.out::println);

    }

/**
运行结果：
    Employee{id=1001, name='马化腾', age=34, salary=6000.38}
    Employee{id=1002, name='马云', age=12, salary=9876.12}
    Employee{id=1004, name='雷军', age=26, salary=7657.37}
    Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}

    Employee{id=1001, name='马化腾', age=34, salary=6000.38}
    Employee{id=1002, name='马云', age=12, salary=9876.12}
    Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
    Employee{id=1004, name='雷军', age=26, salary=7657.37}
*/

Optional类的概述

在Java中，空指针异常极为常见，Optional类就是为了解决Java中的空指针问题而生的

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

Optional类提供的方法

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 接口实现提供的异常。

搭配使用

of()和get()搭配使用，明确对象非空
ofNullable()和orElse()搭配使用，不确定对象非空

应用举例

代码示例：

public class OptionalTest {
    @Test
    public void test1() {
        // empty()：创建的Optional独享内部的value = null
        Optional<Object> opl = Optional.empty();
        if (!opl.isPresent()) { // Optional封装的数据是否包含数据
            System.out.println("数据为空");
        }
        System.out.println(opl);
        System.out.println(opl.isPresent());

        // 如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value
        System.out.println(opl.get()); // java.util.NoSuchElementException: No value present
        
        /**
        运行结果：
            数据为空
            Optional.empty
            false
        */
    }

    @Test
    public void Test2() {
        String str = "Java";

        //str = null;
        // of(T t)：封装数据t生成Optional对象。要求t非空，否则报错 java.lang.NullPointerException
        Optional<String> opl = Optional.of(str);
        // get()通常与of()搭配使用，用于获取内部封装的数据value
        String str1 = opl.get();
        System.out.println(str1);
        
        /**
        运行结果：
            Java
        */
    }

    @Test
    public void test3() {
        String str = "MySQL";
        str = null;
        // ofNullable(T t)：封装数据t赋值给Optional内部的value 。不要求t非空
        Optional<String> opl = Optional.ofNullable(str);
        System.out.println(opl);
        // orElse(T t1)：如果Optional内部的value非空，则返回此value值。如果value为空，则返回t1
        String str2 = opl.orElse("Spring");
        System.out.println(str2);
        
        /**
        运行结果：
            Optional.empty
            Spring
        */
    }


}

使用Optional类避免产生空指针异常。

public class OptionalTest2 {

    // 不使用Optional类 进行非空校验
    public String getGirlName1(Boy boy) {

        if (boy != null) {
            Girl girl = boy.getGirl();
            if (girl != null) {
                return girl.getName();
            }
        }

        return null;
    }
    // 使用Optional类进行非空校验
    public String getGirlName2(Boy boy) {
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        // 此时的boy1一定非空，boy为空时返回“雏田”
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("雏田")));

        Girl girl = boy1.getGirl();
        // girl1一定非空，girl为空时返回“冯宝宝”
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        Girl girl1 = girlOptional.orElse(new Girl("冯宝宝"));
        return girl1.getName();
    }

    // 测试getGirlName1(Boy boy)
    @Test
    public void test1() {
        Boy boy = null;
        System.out.println(getGirlName1(boy));

        boy = new Boy();
        System.out.println(getGirlName1(boy));

        boy = new Boy(new Girl("冯宝宝"));
        System.out.println(getGirlName1(boy));
        
        /**
        运行结果：
            null
            null
            冯宝宝
        */

    }

    // 测试getGirlName2(Boy boy)
    @Test
    public void test2() {
        Boy boy = null;
        System.out.println(getGirlName2(boy));

        boy = new Boy();
        System.out.println(getGirlName2(boy));

        boy = new Boy(new Girl("冯宝宝"));
        System.out.println(getGirlName2(boy));
        
        /**
        运行结果：
            雏田
            冯宝宝
            冯宝宝
        */
    }
}

Girl类：

public class Girl {

    private String name;

    public Girl() {
    }

    public Girl(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                '}';
    }
}

Boy类：

public class Boy {

    private Girl girl;

    public Boy() {
    }

    public Boy(Girl girl) {
        this.girl = girl;
    }

    public Girl getGirl() {
        return girl;
    }

    public void setGirl(Girl girl) {
        this.girl = girl;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "girl=" + girl +
                '}';
    }
}

Java StreamAPI和Optional类的使用

Stream API概述

Stream使用流程

创建Stream

中间操作

筛选与切片

映射

排序

终止操作（终止操作）

匹配与查找

规约

收集

Optional类的概述

Optional类提供的方法

创建Optional类对象的方法

判断Optional容器是否包含对象

获取Optional容器的对象

搭配使用

应用举例

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读