java1.8--Optional类

身为一名Java程序员，大家可能都有这样的经历：调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。我们首先要判断这个返回值是否为null，只有在非空的前提下才能将其作为其他方法的参数。这正是一些类似Guava的外部API试图解决的问题，前面一篇博客我也整理到了Null Object模式，也可以解决这个问题。

现在不用再被这些事情恶心了，java8引入了一个新的Optional类。Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

其实也不用多说什么，我通过几个例子来整理下Optional类的用法就好了。下面我会贴出Optional类的源码然后给出使用的例子：

• of：为非null的值创建一个Optional。

public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

这里有必要看一下Optional类的构造器，下面先贴出源码：

private Optional() {
        this.value = null;
    }
private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

这里有一个Objects类，是java7之后引入的。requireNonNull()方法用来验证对象是否为空，如果对象为空，抛出空指针异常。源码如下：

public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

OK，现在来使用Optional的of方法：

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: of方法通过工厂方法创建Optional类。需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException 。
	 */
	public static void main(String[] args)
	{
		//调用工厂方法创建Optional实例
		Optional<String> name = Optional.of("LinkinPark...");
		//传入参数为null，抛出NullPointerException.
		Optional<String> someNull = Optional.of(null);
	}

• empty：Returns an empty Optional instance。返回一个对象，该对象调用isPresent()方法返回false

private static final Optional<?> EMPTY = new Optional<>();
public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: empty，直接get()会报错
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.empty();
		System.out.println(name.isPresent());//输出false
		System.out.println(name.get());//报错，输出No value present
	}

• ofNullable：为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。

 public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: ofNullable与of方法相似，唯一的区别是可以接受参数为null的情况。
	 */
	public static void main(String[] args)
	{
		//下面创建了一个不包含任何值的Optional实例
		Optional<String> op = Optional.ofNullable("LinkinPark。。。");
		Optional<String> empty = Optional.ofNullable(null);
	}

• isPresent：如果值存在返回true，否则返回false。

 public boolean isPresent() {
        return value != null;
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: isPresent方法用来检查Optional实例中是否包含值
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.of("LinkinPark");
		if (name.isPresent())
		{
			//在Optional实例内调用get()返回已存在的值
			System.out.println(name.get());//输出LinkinPark
		}
	}

• get：如果Optional有值则将其返回，否则抛出NoSuchElementException。

public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: get方法用来得到Optional实例中的值
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");
		Optional<?> empty = Optional.ofNullable(null);
		try
		{
			System.out.println(name.get());
			//在空的Optional实例上调用get()，抛出NoSuchElementException
			System.out.println(empty.get());
		}
		catch (NoSuchElementException ex)
		{
			System.out.println(ex.getMessage());//输出：No value present
		}
	}

• ifPresent：如果Optional实例有值则为其调用consumer，否则不做处理。Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。Java8支持不用接口直接通过lambda表达式传入参数。

public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: 如果Optional实例有值，调用ifPresent()可以接受接口段或lambda表达式
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");
		name.ifPresent(System.out::println);
	}

• orElse：如果有值则将其返回，否则返回指定的其它值。

public T orElse(T other) {
        return value != null ? value : other;
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: 如果Optional实例有值则将其返回，否则返回orElse方法传入的参数
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");
		Optional<String> empty = Optional.ofNullable(null);
		//如果值不为null，orElse方法返回Optional实例的值。如果为null，返回传入的消息。
		System.out.println(name.orElse("There is some value!"));//输出：LinkinPark
		System.out.println(empty.orElse("There is no value present!"));//输出：There is no value present!
	}

• orElseGet：orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法将传入的字符串作为默认值，orElseGet方法可以接受Supplier接口的实现用来生成默认值。

public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: orElseGet与orElse方法类似，区别在于orElse传入的是默认值，orElseGet可以接受一个lambda表达式生成默认值。
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");
		Optional<String> empty = Optional.ofNullable(null);
		System.out.println(name.orElseGet(() -> "Default Value"));//输出：LinkinPark
		System.out.println(empty.orElseGet(() -> "Default Value"));//输出：Default Value
	}

• orElseThrow：如果有值则将其返回，否则抛出supplier接口创建的异常。

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

public class Test
{

	/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: orElseThrow与orElse方法类似。与返回默认值不同，orElseThrow会抛出lambda表达式或方法生成的异常
	 */
	public static void main(String[] args)
	{
		Optional<String> empty = Optional.ofNullable(null);
		try
		{
			empty.orElseThrow(() -> new LinkinException("No value present in the Optional instance"));
		}
		catch (Throwable ex)
		{
			System.out.println(ex.getMessage());//输出: No value present in the Optional instance
		}
	}

}

@SuppressWarnings("serial")
class LinkinException extends RuntimeException
{

	public LinkinException()
	{
		super();
	}

	/**
	 * @param message
	 * @param cause
	 * @param enableSuppression
	 * @param writableStackTrace
	 */
	public LinkinException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace)
	{
		super(message, cause, enableSuppression, writableStackTrace);
	}

	/**
	 * @param message
	 * @param cause
	 */
	public LinkinException(String message, Throwable cause)
	{
		super(message, cause);
	}

	/**
	 * @param message
	 */
	public LinkinException(String message)
	{
		super(message);
	}

	/**
	 * @param cause
	 */
	public LinkinException(Throwable cause)
	{
		super(cause);
	}

}

上面的代码没有问题，其中这个自定义异常设计不合理，因为这里的异常信息不会经常变，也就是这个已经被定义成检查Optional类是否是空的异常了，所以重构下：

package com.linkin.maven.mavenTest;

import java.util.Optional;

public class Test
{

	/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: orElseThrow与orElse方法类似。与返回默认值不同，orElseThrow会抛出lambda表达式或方法生成的异常
	 */
	public static void main(String[] args)
	{
		Optional<String> empty = Optional.ofNullable(null);
		try
		{
			empty.orElseThrow(LinkinException::new);
		}
		catch (Throwable ex)
		{
			System.out.println(ex.getMessage());//输出: No value present in the Optional instance
		}
	}

}

@SuppressWarnings("serial")
class LinkinException extends RuntimeException
{
	/**
	 * 不带异常信息
	 */
	public LinkinException()
	{

	}

	/**
	 * @param msg
	 * 带异常信息
	 */
	public LinkinException(String msg)
	{
		super(msg);
	}

	@Override
	public String getMessage()
	{
		return "No value present in the Optional instance";
	}

}

• map：如果有值，则对其执行调用mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值，否则返回空Optional。

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: map方法用来对Optional实例的值执行一系列操作。通过一组实现了Function接口的lambda表达式传入操作。
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");
		//map方法执行传入的lambda表达式参数对Optional实例的值进行修改。为lambda表达式的返回值创建新的Optional实例作为map方法的返回值。
		Optional<String> upperName = name.map(String::toUpperCase);
		System.out.println(upperName.orElse("No value found"));//输出LINKINPARK...
	}

• flatMap：如果有值，为其执行mapping函数返回Optional类型返回值，否则返回空Optional。flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回值必须是Optional。调用结束时，flatMap不会对结果用Optional封装。

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: flatMap方法与map方法类似，区别在于mapping函数的返回值不同。map方法的mapping函数返回值可以是任何类型T，而flatMap方法的mapping函数必须是Optional。
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");

		//flatMap与map（Function）非常类似，区别在于传入方法的lambda表达式的返回类型。map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。
		//但flatMap方法中的lambda表达式返回值必须是Optionl实例。
		Optional<String> upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));
		System.out.println(upperName.orElse("No value found"));//输出LINKINPARK...
	}

• filter：通过传入限定条件对Optional实例的值进行过滤。如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。

public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: 对于filter函数我们应该传入实现了Predicate接口的lambda表达式
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");

		//filter方法检查给定的Option值是否满足某些条件。如果满足则返回同一个Option实例，否则返回空Optional。
		Optional<String> longName = name.filter((value) -> value.length() > 6);
		System.out.println(longName.orElse("The name is less than 6 characters"));//输出LinkinPark...

		//另一个例子是Optional值不满足filter指定的条件。
		Optional<String> anotherName = Optional.of("Linkin");
		Optional<String> shortName = anotherName.filter((value) -> value.length() > 6);
		//输出：name长度不足6字符
		System.out.println(shortName.orElse("The name is less than 6 characters"));//输出The name is less than 6 characters

	}

总结：

高效使用Optional的关键在于，使用一个或者接受正确值，或者返回另一个替代品的方法。

1，ofNullable()方法被设计为null值和可选值之间的一座桥梁，所以我一般使用这个，不怎么用of()。

2，在对Optional对象调用get()方法前，总是应该确认该对象包含值。

3，filter(),map(),flatMap()方法返回的都是一个经过函数式接口处理过的Optional对象，所以可以链式调用。下面给出一个例子：

/**
	 * @创建时间: 2015年10月30日
	 * @相关参数: @param args
	 * @功能描述: map(),flatMap(),filter()方法的链式调用
	 */
	public static void main(String[] args)
	{
		Optional<String> name = Optional.ofNullable("LinkinPark...");

		Optional<String> upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));
		Optional<String> lowerCase = name.flatMap((value) -> Optional.of(value.toUpperCase())).map(String::toLowerCase);
		Optional<String> lowerCase1 = name.flatMap((value) -> Optional.of(value.toUpperCase())).map(String::toLowerCase).filter((value) -> value.startsWith("Linkin"));
		System.out.println(upperName.orElse("No value found"));//输出LINKINPARK...
		System.out.println(lowerCase.get());//输出linkinpark...
		System.out.println(lowerCase1.orElse("No value found"));//No value found
	}