(原)
先看看上面的说明：
/**
* A container object which may or may not contain a non-null value.
* If a value is present, {@code isPresent()} will return {@code true} and
* {@code get()} will return the value.
*Optional是一个容器对象，它可能包含，也可能不包含一个非空的值,如果这个值存在，isPresent方法将返回true,get方法将会返回它本身
* <p>Additional methods that depend on the presence or absence of a contained
* value are provided, such as {@link #orElse(java.lang.Object) orElse()}
* (return a default value if value not present) and
* {@link #ifPresent(java.util.function.Consumer) ifPresent()} (execute a block
* of code if the value is present).
*Optional提供一些额外的方法，这些方法依赖于它所包含的对象存在与否，例如orElse如果这个包含的对象不存在，将会返回一个默认值和ifPresent方法，如果包含的值存在，则会执行方法块中的内容
* <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
* class; use of identity-sensitive operations (including reference equality
* ({@code ==}), hash code, or synchronization) on instances of
* {@code Optional} may have unpredictable results and should be avoided.
*这是一个基于值的class类，对于同一性（特性）敏感的操作 （包含引用的相等性如:==）,同一性的hashcode或者同步等等、对optional实例可能会产生不可预料的结果，这种结果应该被避免。
* @since 1.8
*/
再看看该类：
public final class Optional<T>
这里一个final类
这是一个基于值的类，上面给出了什么叫基于值，上面给出的链接地址不全，看这里：
http://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html
这里说的是基于值的类需要满足以下几点：
1、 final类型和不可变的（可能会包含可变对象的引用）
2、 有equals、hashCode、toString方法的实现，它是通过实例的状态计算出来的，而并不会通过其它的对象或变量去计算。
3、 不会使用身份敏感的操作，比如在二个实例之间引用相等性、hashCode或者内在的锁。
4、 判断二个值相等仅仅通过equal方法，而不会通过==去判断。
5、 它不提供构造方法，它通过工厂方法创建它的实例，这不保证返回实例的一致性。
6、 当它们相等时，它是可以自由替换的。如果x和y 调用equal方法返回true，那么可以将x和y任意交换，它的结果不会产生任何变化。
然后再回来看Optional，你能看到它是私有的：
private Optional() {
this.value = null;
}
在它的所有方法中，如果要创建Optional对象，先看看它常用的三个方法。
empty方法回一个空的 Optional对象。
of方法接收一个T参数，T必需为非null值，返回一个Optional对象。
ofNullable方法接收一个T参数，如果T为null，它会调用empty方法，如果不为null则调用of方法。
再看看这二个方法：
isPresent： 如果这个对象的值不为null返回true,否则返回false。
get：如果这个值存在，则返回这个值，如果这个值为null，则抛出异常。
在使用中，这二个方法基本是成对出现的，下面来看一个例子。
String str = "hello";
Optional<String> strValue = Optional.of(str);
System.out.println("part1-------------------");
if(str != null){
System.out.println(str);
}
System.out.println("part2-------------------");
if(strValue.isPresent()){
System.out.println(strValue.get());
}
这里，part1和part2的代码是等价的，Optional还提供了一种更简单的方法
strValue.ifPresent(s -> System.out.println(s));
ifPresent方法接收一个consumer函数式接口（之前介绍过），将自己的非空的逻辑写进去。Optioanal该方法更加简洁。
orElse方法:接收一个参数，如果存在，返回这个值本身，否则返回返回这个参数。
orElseGet方法：接收一个Supplier，如果存在，返回这个值本身，否则返回Supplier
对象。
map方法：接收一个Function,如果Optioanal为null则抛出异常（所以这里创建Optional对象时建议用Optional.ofNullable()），如果为空值则返回空，如果不为空则返回Function的返回值。
（例如：一个对象Obj，有一个List属性，如果List有值，返回List,否则返回空集合，可以这么写（
Parent parent = new Parent(); Optional<Parent> parentVal = Optional.ofNullable(parent); System.out.println(parentVal.map(m -> m.getList()).orElse(Collections.emptyList()));
）
Optioanal通常作为方法的返回值来使用，它可以有效的规避返回null的结果，如果一个类需要序列化，当Optional作为参数类型或是成员变量类型是有问题的。因为Optional没有实现序列化，所以Optioanl通常不被建议作为参数或常量使用。
下面给出一些Optional常用的例子：
package com.demo.jdk8;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
public class Test6 {
public static void main(String[] args) {
String str = "hello";
Optional<String> strValue = Optional.of(str);
System.out.println("part1-------------------");
if(str != null){
System.out.println(str);
}
System.out.println("part2-------------------");
if(strValue.isPresent()){
System.out.println(strValue.get());
}
System.out.println("part3-------------------");
strValue.ifPresent(s -> System.out.println(s));
System.out.println("part4-------------------");
Optional<String> op = Optional.ofNullable(null);
System.out.println(op.orElse("hahahaha"));
System.out.println("part5-------------------");
Optional<String> opt = Optional.ofNullable("nihao");
System.out.println(op.orElseGet(() -> "hehehe"));
System.out.println("part6-------------------");
System.out.println(opt.map(m -> m + "123").orElseGet(() -> "world"));
System.out.println("part7-------------------");
Parent parent = new Parent();
// List<Object> list = Arrays.asList("张三","李四");
// parent.setList(list);
Optional<Parent> parentVal = Optional.ofNullable(parent);
System.out.println(parentVal.map(m -> m.getList()).orElse(Collections.emptyList()));
}
public void test(Optional optional){
}
}
class Parent{
private List<Object> list;
public List<Object> getList() {
return list;
}
public void setList(List<Object> list) {
this.list = list;
}
}