java8中的Optional容器类，避免空指针异常

java8中的Optional容器类，避免空指针异常

java8中使用Optional容器类来尽可能的避免或快速定位空指针异常

Optional类的基本使用

public class Person {

private Integer age;

private Double salary;

public Person() {
}

public Person(Integer age, double salary) {
    this.age = age;
    this.salary = salary;

}

public Integer getAge() {
    return age;
}

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

public double getSalary() {
    return salary;
}

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

@Override
public String toString() {
    return "Person{" +
            "age=" + age +
            ", salary=" + salary +
            '}';
}

}
//of方法 创建一个Optional对象
Optional of = Optional.of(new Person());
Optional of1 = Optional.of(null);

    System.out.println(of.get());
    System.out.println(of1.get());//java.lang.NullPointerException

    //empty方法 创建一个空的Optional实例
    Optional<Person> empty = Optional.empty();
    System.out.println(empty.get());  //java.util.NoSuchElementException: No value present

    //ofNullable(T t) 如果T不为空，创建Optional实例，如果为空，创建空实例，下面就是这个方法的实现，综合了上面两个方法

// public static Optional ofNullable(T value) {
// return value == null ? empty() : of(value);
// }
Optional ofNullable = Optional.ofNullable(new Person());

    //isPersent方法 判断是否包含空值
    Optional<Person> isPer= Optional.ofNullable(new Person());
        //如果不为空 输出
    if(isPer.isPresent()){
        System.out.println(isPer.get());
    }

    //orElse(T t) 如果调用对象包含值 返回该值，否则返回t
    Optional<Person> orEl = Optional.ofNullable(null);
    System.out.println(orEl.orElse(new Person(12, 222))); //输出 Person{age=12, salary=222.0}

    //orElseGet(Supplier s) 如果调用对象包含值 返回该值，否则返回s获取的值
    Optional<Object> orEG = Optional.ofNullable(null);
    System.out.println(orEG.orElseGet(() -> new Integer(33))); //输出33

    //map(Function f) 如果有值 对其处理，并返回处理后的Optional，否则返回Optional.empty()
    Optional<Person> oMap = Optional.ofNullable(new Person(12, 2222));
    Optional<Integer> oAge = oMap.map(e -> e.getAge());
    System.out.println(oAge.get()); //输出12

    //flatMap(Function mapper) 与map类似，就是返回值必须是Optional   进一步避免空指针异常
    Optional<Person> oFlatMap = Optional.ofNullable(new Person(12, 2222));
    Optional<Integer> oFlatAge = oMap.flatMap(e -> Optional.of(e.getAge()));
    System.out.println(oAge.get());  //输出12

这里放一个例子

有一个Teacher类，Teacher中有一个Student属性，

public class Teacher {
private Optional student = Optional.empty();

public void setStudent(Optional<Student> student) {
    this.student = student;
}

public Optional<Student> getStudent() {
    return student;
}

}
Student类有一个name属性

public class Student {
private String name;

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

public String getName() {
    return name;
}

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

}
使用Optional容器来避免空指针异常

public static void main(String[] args) {

    Optional<Teacher> op = Optional.ofNullable(null);
    String studentName = getStudentName(op);
    System.out.println(studentName);

}
public static String getStudentName(Optional<Teacher> teacher){
    return teacher.orElse(new Teacher())
            .getStudent()
            .orElse(new Student("小明"))
            .getName();
}