java8新特性

2022-01-14 20:58:22 阅读：114 来源： 互联网

标签：Stream list System 特性 java8 println public out

Java 8新特性

一、简介

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

新特性带来的作用

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

二、Lambda表达式

/**
 * Lambda表达式的使用
 *
 * 1.举例：(o1,o2) -> Integer.compare(o1,o2);
 * 2.格式：
 *      ->:lambda操作符或箭头操作符
 *      ->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）
 *      ->右边：lambda体（其实就是重写的抽象方法的方法体）
 * 3.Lambda表达式的是使用：（分为6种情况介绍）
 *
 *      总结：
 *      ->左边：Lambda形参列表的参数列表类型可以省略，如果Lambda形参列表只有一个参数
 *      其一对（）也可以省略
 *      ->右边：Lambda体应使用一对{}包裹，如果Lambda体只有一条执行语句（可能是return语句）
 *      可以省略这一对{}和return
 * 4.Lambda表达式的本质：作为函数式接口的实例
 *
 * 5.如果一个接口中只声明了一个抽象方法，则此接口就称为函数式接口
 *
 */
public class LambdaTest {
    //语法格式一：无参，无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("我爱西安");
            }
        };
        r1.run();
        System.out.println("**********************");
        //优化
        Runnable r2 = () -> System.out.println("我爱宝鸡");
        r2.run();
    }

    //语法格式二：Lambda需要一个参数，但是没有返回值
    @Test
    public void test2(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别？");

        System.out.println("**********************");
		//优化
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了，一个是说的人当真了");
    }

    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    @Test
    public void test3(){
        /*
            类型推断在之前学习中也见过
            ArrayList<String> list = new ArrayList<>();
            int[] arr = {1,2,3};
         */
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了，一个是说的人当真了");
        System.out.println("**********************");
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("优化后的可省略数据类型");
    }

    //语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("优化后的可省略数据类型");
        System.out.println("**********************");
		//优化
        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("优化后的可省略小括号");
    }

    //语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5(){
        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, 5));
        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(12, 5));

    }

    //语法格式六：当Lambda体只是一条语句时，return与大括号若有，都可以省略
    @Test
    public void test6(){
        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12, 5));
        System.out.println("********************");
        //根据语法格式优化
        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12,5));
    }
}

在Lambda中我们提到了函数式接口，下面我们深入了解一下

三、函数式（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表达式来写。

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

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

/**
 * Java内置的四大核心函数式接口
 *
 * 消费型接口 Consumer<T>     accept(T t)
 * 供给型接口 Supplier<T>     T get()
 * 函数式接口 Function<T,R>   R apply(T t)
 * 断定型接口 Predicate<T>    boolean test(T t)
 */
public class LambdaTest2 {
    @Test
    public void test1(){
        //消费型接口
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("学习太累了，买瓶矿泉水，价格为："+aDouble);
            }
        });
        System.out.println("*************************");
        happyTime(400,money -> System.out.println("学习太累了，买瓶矿泉水，价格为："+money));}
    
    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }
    @Test
    public void test2(){
        //传统做法，使用匿名实现类，重写方法
        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(filterString);
        System.out.println("*********************");
        //使用Lambda表达式
        List<String> filterStr = filterString(list,s -> s.contains("京"));
        System.out.println(filterStr);
    }
    //以给定的规则，过滤集合中的字符串，此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();

        for (String s : list) {
            if (pre.test(s)){//如果符合规则，就添加到filterList数组中
                filterList.add(s);
            }
        }
        return filterList;
    }
}

四、方法引用和构造器引用

方法引用（Method References）

方法引用可以看作是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致
格式：使用操作符"::"将类（或对象）与方法名分隔开来
如下三种主要使用情况：
- 对象::实例方法名
- 类::静态方法名
- 类::实例方法名

/**
 * 一、构造器引用
 *      和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致
 *      抽象方法的返回值类型即为构造器所属的类的类型
 * 二、数组引用
 *      将数组堪称一个特殊的类，所以写法和构造器引用类似
 */
public class ConstructorRefTest {
    //构造器引用
    //Supplier中的T get()
    @Test
    public void test1(){
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        //Lambda表达式
        Supplier<Employee> sup1 = () -> new Employee();
        //方法引用之构造器引用
        Supplier<Employee> sup2 = Employee :: new;
        System.out.println(sup2.get());
    }
    //数组引用
    //Function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,String[]> func1 = length -> new String[5];
        String[] arr1 = func1.apply(4);
        System.out.println(Arrays.toString(arr1));
        System.out.println("***********");
        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(4);
        System.out.println(Arrays.toString(arr2));
    }
}

如何使用方法引用

/**
 * 方法引用
 *
 * 1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用"方法引用"
 *
 * 2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例，所以方法引用，也是函数式接口的实例
 *
 * 3.使用格式：    类（或对象）:: 方法名
 *
 * 4.具体分为如下三种情况：
 *     情况1 对象 :: 非静态方法
 *     情况2 类  ::  静态方法
 *     情况3 类  ::  非静态方法
 *
 * 5.方法引用使用的要求：要求接口中的抽象方法的形参列表和
 * 返回值类型与方法引用的方法的形参列表和返回值类型相同。
 */
public class MethodRefTest {
    /* 情况一：对象 :: 实例方法
       Consumer中的void accept(T t)
       PrintStream中的void println(T t)
     */
    @Test
    public void test1(){
        //消费型接口
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("****************");
        PrintStream ps = System.out;
        Consumer<String> con2 = ps :: println;
        con2.accept("北京");
    }
    //Supplier中的T get()
    //Employee中的String getName()
    @Test
    public void test2(){
        Employee emp = new Employee(1001,"tom",23,5600);
        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());
        System.out.println("********************");
        Supplier<String> sup2 = emp :: getName;
        System.out.println(sup2.get());
    }
    //情况二：类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3(){
        //使用lambda表达式需要清楚接口中的方法格式及参数
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(12, 21));//-1
        System.out.println("******************");
        Comparator<Integer> com2 = Integer :: compare;
        System.out.println(com2.compare(21, 12));
    }
    //Function中的R apply(T t)  传入一个T类型返回一个R类型
    //Math中的Long round(Double d) 四舍五入方法
    @Test
    public void test4(){
        //方式一
        Function<Double,Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        System.out.println(func.apply(10.0));//10
        //方式二Lambda表达式
        Function<Double,Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(50.6));//51
        //方式三方法引用
        Function<Double,Long> func2 = Math :: round;
        System.out.println(func2.apply(15.2));//15
    }
    //情况三：类 :: 实例方法(有难度)
    //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", "bcd"));
        System.out.println("*******************");
        Comparator<String> com2 = String :: compareTo;
        System.out.println(com2.compare("xyz", "ace"));
    }
    //Function中的R apply(T t)
    //Employee中的String getName()
    @Test
    public void test6(){
        Employee emp = new Employee(1002,"孙悟空",10,500);
        Function<Employee,String> func1 = employee -> employee.getName();
        System.out.println(func1.apply(emp));//孙悟空
        Function<Employee,Integer> func2 = Employee :: getAge;
        System.out.println(func2.apply(emp));//10
    }
}

五、Stream API

1.介绍

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

集合讲的是数据，Stream讲的是计算

注意：

Stream自己不会存储元素
Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream
Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行
Java 8中有两个最为重要的改变，第一个是Lambda表达式：另外一个则是Stream API
Stream API(java.util.stream)把真正的函数式编程风格引入到Java中，这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。

2.为什么要使用Stream API

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

3.使用Stream API

/**
 * 1.Stream关注的是对数据的运算，与CPU打交道
 *      集合关注的是数据的存储，与内存打交道
 *
 * 2. Stream自己不会存储元素
 *    Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream
 *    Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行
 *
 * 3.Stream 执行流程
 *      3.1  Stream的实例化
 *      3.2  一系列的中间操作（过滤、映射...）
 *      3.3  中止操作
 *      ps：如果不调用中止操作，则中间操作不会执行
 * 4.说明：
 *      4.1  一个中间操作链，对数据源的数据进行处理
 *      4.2  一旦执行中止操作，就执行中间操作链，并产生结果。之后，不会再被使用
 */
public class StreamAPITest {
    //创建Stream的方式一:通过集合
    @Test
    public void test1(){
        List<Employee> list = new EmployeeData().getEmployees();
        //default Stream<E> stream():返回一个顺序流
        Stream<Employee> stream = list.stream();
        //default Stream<E> parallelStream():返回一个并行流
        Stream<Employee> employeeStream = list.parallelStream();
    }

    //创建Stream方式二：通过数组
    @Test
    public void test2(){
        //调用Arrays类的static <T> Stream<T> stream(T[] array):返回一个流
        int[] arr = new int[]{1,2,3,4,5};
        IntStream stream = Arrays.stream(arr);
        //自定义类型
        Employee e1 = new Employee(1001,"aa");
        Employee e2 = new Employee(1002,"bb");
        Employee[] arr2 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr2);
    }
    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }
}

Stream API的中间操作,需要一个雇员类做演示,添加一个数据源

public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;
    ......//省略了基本的getter/setter等方法
}

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,"马云",53,67890.12));
        list.add(new Employee(1003,"刘强东",54,9876.38));
        list.add(new Employee(1004,"雷军",24,5250.18));
        list.add(new Employee(1005,"李彦宏",74,6550.10));
        list.add(new Employee(1006,"比尔盖茨",84,3040.18));
        list.add(new Employee(1007,"任正非",45,5000.38));
        list.add(new Employee(1008,"扎克伯格",14,2300.38));
        return list;
    }
}

接下来用已有的数据源进行操作，对StreamAPI中间操作进行介绍

/**
 * 测试Stream的中间操作
 */
public class StreamAPITest1 {
    //1.筛选与切片
    @Test
    public void test1(){
        //filter(Predicate p)接收Lambda，从流中排除某些元素
        List<Employee> list = EmployeeData.getEmployees();
        Stream<Employee> stream = list.stream();
        //过滤薪水小于6500的雇员foreach是终止操作
        //查询员工表中薪资大于6500的员工信息
        stream.filter(e -> e.getSalary()>6500).forEach(System.out::println);
        System.out.println();
        //limit(n)截断流，使其元素不超过给定数量
        list.stream().limit(2).forEach(System.out::println);
        //skip(n)跳过元素，返回一个扔掉了前n个元素的值。若流中元素不足n个，则返回一个空流
        list.stream().skip(2).forEach(System.out::println);
        System.out.println();
        //distinct()筛选，通过流所生成元素的hashCode()和equals去除重复元素
        list.add(new Employee(1009,"刘强东",45,8000));
        list.add(new Employee(1009,"刘强东",45,8000));
        list.add(new Employee(1009,"刘强东",45,8000));
        list.stream().distinct().forEach(System.out::println);
    }
    //2.映射
    @Test
    public void test2(){
        //map(Function f)接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase(Locale.ROOT)).forEach(System.out::println);
        //练习：获取员工姓名长度大于3的员工的姓名
        List<Employee> li = EmployeeData.getEmployees();
        Stream<String> namesStream = li.stream().map(Employee::getName);
        namesStream.filter(name -> name.length()>3).forEach(System.out::println);
        //练习
        Stream<Stream<Character>> stream = list.stream().map(StreamAPITest1::fromStringToStream);
        stream.forEach(s -> s.forEach(System.out::println));
        //flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
    //3.排序
    @Test
    public void test3(){
        //sorted()自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 97, 0, -89);
        list.stream().sorted().forEach(System.out::println);
        //抛异常，原因：Employee没有实现Comparable接口
//        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);
        //sorted(Comparator com)定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2)->Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out::println);

    }
}

中间操作以后可以用于java对数据库传入的数据进行筛选排序，然后将我们需要的数据显示给用户。

Stream API中止操作

/**
 * 测试Stream的终止操作
 */
public class StreamAPITest2 {
    //1.匹配与查找
    @Test
    public void test1(){
        //allMatch(Predicate p)检查是否匹配所有元素，
        // 练习：是否所有员工的年龄都大于18
        List<Employee> list = EmployeeData.getEmployees();
        boolean allMatch = list.stream().allMatch(employee -> employee.getAge() > 18);
        System.out.println(allMatch);//false
        //anyMatch(Predicate p)检查是否至少匹配一个元素，
        // 练习：是否存在员工的工资都大于6500
        boolean anyMatch = list.stream().anyMatch(employee -> employee.getSalary() > 6500);
        System.out.println(anyMatch);//true
        //noneMatch(Predicate p)检查是否没有匹配的元素，练习：是否存在员工姓“雷”
        boolean noneMatch = list.stream().noneMatch(employee -> employee.getName().startsWith("雷"));
        System.out.println(noneMatch);//true
        //findFirst返回第一个元素
        Optional<Employee> first = list.stream().findFirst();
        System.out.println(first.toString());
        //findAny返回当前流中的任意元素
        Optional<Employee> any = list.stream().findAny();
        System.out.println(any.toString());
        //count返回流中元素的总个数
        long count = list.stream().count();
        System.out.println(count);
    }
    @Test
    public void test2(){
        List<Employee> list = EmployeeData.getEmployees();
        //max(Comparator c)返回流中最大值，练习：返回最高的工资
        Stream<Double> salaryStream = list.stream().map(e -> e.getSalary());
        Optional<Double> max = salaryStream.max(Double::compare);
        System.out.println(max);
        //min(Comparator c)返回流中最小值，练习：返回最低的工资的员工
        Optional<Employee> employeeMinSalary = list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employeeMinSalary);
        //foreach(Consumer c)内部迭代
        list.stream().forEach(System.out::println);
    }
    //归约
    @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);
        System.out.println(sum);
        //reduce(BinaryOperator)可以将流中元素反复结合起来，得到一个值，返回Optional
        //练习：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        System.out.println(employees.stream().map(Employee::getSalary).reduce(Double::sum));
        System.out.println(employees.stream().map(Employee::getSalary).reduce((d1, d2) -> d1 + d2));
    }
    //3.收集
    @Test
    public void test4(){
        //collect(Collector c)将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
        //练习：查找工资大于6000的员工，结果返回一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> collect = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        collect.forEach(System.out::println);
        //set
        Set<Employee> employees1= employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        employees1.forEach(System.out::println);
    }
}

六、Optional类

到目前为止，臭名昭著的空指针异常时导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已成为Java8类库的一部分
Optional类(java.util.Optional)时一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
Optional类的Javadoc描述如下：这是一个可以为null容器对象，如果值存在，则isPresent()方法会返回true，调用get()方法会返回该对象。

常用的方法

Optional.of(T t)	创建一个Optional实例，t必须非空	创建Optioonal类对象的方法
Optional.empty()	创建一个新的空的Optional实例
optional.ofNullable(T t)	t可以为null
bolean isPresent()	判断是否包含对象	判断Optional容器中是否包含对象
void ifPresent(Consumer<? super T> consumer)	如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它
T get()	如果调用对象包含值，返回该值，否则抛异常	获取Optional容器的对象
T orElse(T other)	如果有值则将其返回，否则返回指定的other对象
T orElseGet(Supplier<? extends T> other)	如果有值则将其返回，否则返回由Supplier接口实现提供的对象
T ofElseThrow(Supplier<? extends X> exceptionSupplier)	如果有值则将其返回，否则抛出由Supplier接口实现提供的异常

了解了一些关于Optional类基本的知识和方法，接下来一起去看看代码吧

先提供两个类，作为测试用例

public class Girl {
    private String name;
	......//省略基本的getter/setter方法
}

public class Boy {
    private Girl girl;
	......//省略基本的getter/setter方法
    public Boy(Girl girl) {
        this.girl = girl;
    }
}

测试类：

/**
 * Optional类：为了在程序中避免出现空指针异常而创建的
 */
public class OptionalTest {
    /**
     * Optional.of(T t)创建一个Optional实例，t必须非空
     * Optional.empty()创建一个新的空的Optional实例
     * optional.ofNullable(T t)t可以为null
     */
    @Test
    public void test(){
        Girl girl = new Girl();
        //girl = null;//java.lang.NullPointerException
        //null值会出异常，of(T t)：必须保证t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);
        //null值不会出异常，of(T t)：t可以为null的
        Girl girl1 = new Girl();
        girl1 = null;
        System.out.println(Optional.ofNullable(girl1));
    }
    //会出null指针异常
    public String getGirlName(Boy boy){
        return boy.getGirl().getName();
    }

    @Test
    public void test3(){
        Boy boy = new Boy();
        String girlName = getGirlName1(boy);
        System.out.println(girlName);
    }
    //优化以后的getGirlName()
    public String getGirlName1(Boy boy){
        if (boy != null){
            Girl girl = boy.getGirl();
            if (girl != null){
                return girl.getName();
            }
        }
        return null;
    }
    @Test
    public void test4(){
        Girl girl = new Girl();
        girl = null;
        Optional<Girl> girl1 = Optional.ofNullable(girl);
        System.out.println(girl1);//Optional.empty

        Girl girl2 = girl1.orElse(new Girl("赵丽颖"));
        System.out.println(girl2);//Girl{name='赵丽颖'}
        //orElse作为备胎，如果girl1为空，则返回ofElse中的内容
    }
    //使用Optional类的getGirlName()
    public String getGirlName2(Boy boy){
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        //此时boy1非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));

        Girl girl = boy1.getGirl();
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        //girl1非空
        Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));
        return girl1.getName();
    }
    @Test
    public void test5(){
        Boy boy = null;
        boy = new Boy();
        boy = new Boy(new Girl("马儿扎哈"));
        String girlName = getGirlName2(boy);
        System.out.println(girlName);
    }
}

标签：Stream,list,System,特性,java8,println,public,out
来源： https://blog.csdn.net/m0_46533814/article/details/122502019

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9