对null进行处理
程序中经常需要对null情况进行处理，比如Course类中有一个List
现在想要查看某个student的name属性的长度，不负责任(不处理null)的写法如下：
Course course = new Course("数学");
Student s0 = new Student("s0");
Student s1 = new Student(null);
Student s2 = null;
course.addStudent(s0, s1, s2);
int index = 1;
String name = course.getStuList().get(index).getName(); //index = 1或2都会抛出NullPointerException
System.out.println(name.length());
String name = course.getStuList().get(index).getName()这样写固然省事，但是当s2为null或者s1对象的name为null时，都会抛出大家熟悉的NullPointerException。
所以需要使用大量的if...else语句对变量否为null进行判断。
int index = 1;
Student student = course.getStuList().get(index);
String errorMessage = "处理过程中无null";
String name = "";
if(student!=null) {
name = student.getName();
if(name!=null) {
System.out.println(name.length());
}else {
errorMessage="student对象的name为null";
}
}else {
errorMessage="student对象为null";
}
sysout
System.out.println(errorMessage);
使用Optional处理null
null是一个特殊值，并不是一个类型，student.getName()可能返回null也可能返回String类型对象，这是两种不同的情况。
Java 8中引入了Optional类型来统一处理null与对应的类型。该类型为容器类型，可以包含某个类型的非空值与空值，所以可以对他们统一处理。
Optional基本用法如下：
Optional<Student> stuNullable = Optional.empty();//代表null的Optional对象
Student stu = new Student("s0");
System.out.println(stuNullable.isPresent());//false，判断里面是否存在Student对象
//Student student = stuNullable.get();//将抛出NoSuchElementException
Optional<Student> stuNotNull = Optional.ofNullable(stu); //代表非空的Student，实际上将stu对象放入该Optional容器中
System.out.println(stuNotNull.isPresent());//true
Student student = stuNotNull.get(); //返回刚才装入的stu对象
其中 Optional.ofNullable(stu)的作用是：当stu为null时，返回Optional.empty()，否则返回包含stu对象的Optional对象（即，Optional.of(stu)）。
到现在为止我们可以使用Optional来代替前面的对null值的直接处理，代码如下：
Course course = new Course("数学");
Student s0 = new Student("s0");
Student s1 = new Student(null);
Student s2 = null;
course.addStudent(s0, s1, s2);
int index = 1;
Student student = course.getStuList().get(index);
Optional<Student> stu = Optional.ofNullable(student);//将student放入Optioanl中进行处理
String errorMessage = "处理过程中无null";
String name = "";
if (stu.isPresent()) {
Optional<String> nameOfNullable = Optional.ofNullable(stu.get().getName());
if (nameOfNullable.isPresent()) {
name = nameOfNullable.get();
System.out.println(name.length());
}else {
errorMessage="student对象的name为null";
}
}else {
errorMessage="student对象为null";
}
System.out.println(errorMessage);
呃.....代码更复杂了。但至少让你不能忽略null值了。
再看看Optional中的其他方法ifPresent与orElse
stu.ifPresent(e->System.out.println(e.getName()));//如果存在对象，则Optional中的包含的对象getName返回的值
Student defaultStudent = new Student("默认对象");
Student orElse = stu.orElse(defaultStudent); //如果存在对象直接返回该对象，否则返回defaultStudent对象
似乎无补于事。
Optional的map方法
对上面的代码可以使用map方法进行改造，如下所示：
int index = 0;
String errorMessage = "处理过程有null";
String name = "";
Optional<Course> courseNullable = Optional.ofNullable(course);
Optional<String> resultOptional = courseNullable.map(e->e.getStu(index)).map(e->e.getName());
String result = resultOptional.orElse(errorMessage);//resultOptional中可能为null，也可能有值。如果未null，则返回errorMessage。
System.out.println(result);
map方法入参为Function类型（可以将Optional中原来的类型转换成新的类型）。
map(e->e.getStu(index))就是将Courset类型转换成Student类型
map(e->e.getName())则是将Student类型转换成String类型。
map方法返回值为Optional类型，所以可以以链式风格map(e->e.getStu(index)).map(e->e.getName())取代上面复杂的if...else处理。
这个例子体现出了Optional的优越性，即可以通过其优雅的处理null值。
窃以为，相比较Optioanl带来的优越性，其语法还是有点复杂。建议先掌握其语法，这样至少看别人的相关代码的时候不会无所适从。
基础代码
class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [name=" + name + "]";
}
}
class Course {// 课程
private String name;
private List<Student> stuList;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void addStudent(Student... stus) {
for (Student student : stus) {
stuList.add(student);
}
}
public Student getStu(int i) {
return stuList.get(i);
}
public List<Student> getStuList() {
return stuList;
}
public Course(String name) {
this.name = name;
stuList = new ArrayList<>();
}
}
使用Optional改造Course
查看jdk文档，Optional的说明如下：
Optional is primarily intended for use as a method return type where there is a clear need to represent "no result," and where using null is likely to cause errors.
即，Optional主要用于修饰方法的返回类型，来表示“没有结果”这个返回结果，还用在使用null作为返回类型容易导致出错的地方。
那么，我么可以使用Optional来改造Course的Student getStu(int i)代码：
public Student getStu(int i) {
return stuList.get(i);
}
该段代码主要有两个问题：
- i可能越界。
- get(i)返回的值可能为null。
改造后代码如下：
public Optional<Student> getStu(int i) {
if (i >= stuList.size())
return Optional.empty(); // 带代表null的Optional实例
Student student = stuList.get(i);
if (student == null)
return Optional.empty();
return Optional.of(student);
}
或者进一步简化，改造成这样：
public Optional<Student> getStu(int i) {
if (i >= stuList.size())
return Optional.empty();
Student student = stuList.get(i);
return Optional.ofNullable(student);
}
Optional.ofNullable方法可以处理入参为null的情况。其相关文档描述如下
Returns an Optional describing the specified value, if non-null, otherwise returns an empty Optional.
定义测试方法如下
private static void getStuByIndex(Course course, int index) {
Student stu0 = course.getStu(index).orElse(new Student("默认学生"));//如果为null，则返回“默认学生”对象
System.out.println(stu0);
}
测试代码如下：
Course course = new Course("数学");
Student s0 = new Student("s0");
Student s1 = new Student(null);
Student s2 = null;
course.addStudent(s0, s1, s2);
getStuByIndex(course, 0);
getStuByIndex(course, 1);
getStuByIndex(course, 2);//s2为null
getStuByIndex(course, 3);//越界，返回Optional.empty()
输出：
Student [name=s0]
Student [name=null]
Student [name=默认学生]
Student [name=默认学生]
测试flatmap代码如下
Optional<Course> courseNullable = Optional.ofNullable(course);
Optional<String> r0 = courseNullable.flatMap(e->e.getStu(0)).map(Student::getName);
Optional<String> r1 = courseNullable.flatMap(e->e.getStu(1)).map(Student::getName);
Optional<String> r2 = courseNullable.flatMap(e->e.getStu(2)).map(Student::getName);
Optional<String> r3 = courseNullable.flatMap(e->e.getStu(3)).map(Student::getName);
System.out.println(r0);
System.out.println(r1);//Student的name属性为null，返回Optional.empty()
System.out.println(r2);//Student为null，返回Optional.empty()
System.out.println(r3);//数组越界，返回Optional.empty()
输出如下：
Optional[s0]
Optional.empty
Optional.empty
Optional.empty
对比以前的代码
Optional<String> resultOptional = courseNullable.map(e->e.getStu(index)).map(e->e.getName());
将map(e->e.getStu(0))改成了flatMap(e->e.getStu(0))。这是因为改造前的e->e.getStu(0)返回的是Student对象，
而改造后返回的是Optional<Student>类型对象。观察改造后的代码段：
Optional<Optional<Student>> xa = courseNullable.map(e->e.getStu(2));
Optional<Student> xb = courseNullable.flatMap(e->e.getStu(2));
可以看到xa并不是我们想要的结果，而xb才是我们想要的结果。前面已经提到Optional相当于一个容器，那么Optional<Optional<Student>>
相当于容器中嵌套一个容器，在这里我们需要关注的是大容器里面的Optional<Student>类型对象。flatMap中的flat可以理解为平坦化，相当于
从嵌套的容器中取出自己真正想要的元素。