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 + "]";
	}
	
}

关于Guava中的absent()方法返回的是一个单例类型，看了下源代码就知道了，这里把源码中关键段代码显示出来

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() {}
........
.......
................

最后附上Optional类的方法和意思图：