Guava Optional类的使用【Guava学习笔记】

package com.lwl.guava.Optional;

import java.util.Set;

import com.google.common.base.Optional;

/**
* Optional用于包含非空对象的不可变对象。 Optional对象，用于不存在值表示null。
* 这个类有各种实用的方法，以方便代码来处理为可用或不可用，而不是检查null值。
*
* 简单说明，Optional其实就是当代码中出现null的情况下，它把null值转化为一个单例模式对象
* @author lwlong
* @create 2017-8-18 下午3:55:31
* @version 1.0
*/
public class UserOptional {

public static void main(String[] args) {
//测试实例一
Integer first = null;
Integer two = 2;

//如果nullableReference非空，返回一个包含引用Optional实例;否则返回absent()。
Optional<Integer> optFirst = Optional.fromNullable(first);
Optional<Integer> optTwo = Optional.fromNullable(two);
//返回true，如果这支架包含一个(非空)的实例。 isPresent()
System.out.println("First parameter is present: " + optFirst.isPresent());
System.out.println("Second parameter is present: " + optTwo.isPresent());

//返回所包含的实例(如果存在);否则为默认值 abstract T or(T defaultValue)
Integer value1 = optFirst.or(new Integer(0));

//返回所包含的实例，它必须存在。
Integer value2 =optTwo.get();

System.out.println(value1);
System.out.println(value2);
//继续测试实体类
test();
}

private  static void test(){
System.out.println("====================================================");

User u1 = null;

User u2 = new User("jack", "男", 22);

Optional<User> optU1 = Optional.fromNullable(u1);
Optional<User> optU2 = Optional.fromNullable(u2);

//返回此实例的字符串表示。 toString()
System.out.println(optU1.toString());//out print Optional.absent()
System.out.println(optU2.toString());//out print Optional.of(User [name=jack, sex=男, age=22])

//**********************************如果原始对象是null情况********************************************************
//返回没有包含的参考Optional的实例。absent() 其实就是获取了一个空值对应的对象而已
Optional<User> optU3 = Optional.absent();
User u4 = null;
Optional<User> optU4 = Optional.fromNullable(u4);
Optional<User> optU5 = Optional.absent();
System.out.println(optU3==optU1); //out print true  你会发现这个值是true，也就是这2个对象是相同的，也就是说这个absent()其实是个单例模式
System.out.println(optU3==optU4);
System.out.println(optU4==optU5);
System.out.println(optU4.equals(optU5));
//返回此实例的哈希码。hashCode()
System.out.println(optU4.hashCode()==optU5.hashCode());

//**********************************如果原始对象不为null,但是属性值相同，判断对象是否一致是通过hashCode********************************
User u3 = new User("jack", "男", 22);
Optional<User> optU33 = Optional.fromNullable(u3);
System.out.println(u2.equals(u3));
System.out.println(u2.hashCode());
System.out.println(u3.hashCode());
// 返回true如果对象是一个Optional实例，无论是包含引用彼此相等或两者都不存在。
System.out.println(optU33.equals(optU2)); //out print false

//返回一个不可变的单集的唯一元素所包含的实例(如果存在);否则为一个空的不可变的集合。
Set<User> u2Set =  optU2.asSet();
for (User user : u2Set) {
System.out.println(user.toString());// out print User [name=jack, sex=男, age=22]
}

}

}

package com.lwl.guava.Optional;

public class User {

private String name;

private String sex;

private int age;

public User(){}
public User(String name,String sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}

public String getName() {
return name;
}

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

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

public int getAge() {
return age;
}

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

@Override
public String toString() {
return "User [name=" + name + ", sex=" + sex + ", age=" + age + "]";
}

}

public abstract class Optional<T> implements Serializable {
/**
* Returns an {@code Optional} instance with no contained reference.
*
* <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's
* {@code Optional.empty}.
*/
public static <T> Optional<T> absent() {
return Absent.withType();
}

/**
* If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that
* reference; otherwise returns {@link Optional#absent}.
*
* <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's
* {@code Optional.ofNullable}.
*/
public static <T> Optional<T> fromNullable(@Nullable T nullableReference) {
return (nullableReference == null)
? Optional.<T>absent()
: new Present<T>(nullableReference);
}.....
........

final class Absent<T> extends Optional<T> {
static final Absent<Object> INSTANCE = new Absent<Object>();

@SuppressWarnings("unchecked") // implementation is "fully variant"
static <T> Optional<T> withType() {
return (Optional<T>) INSTANCE;
}

private Absent() {}
........
.......
................