目录：Java 8 新特性-终极指南
文章目录??Java 8 新特性 – Optional????Optional源码-各个方法??Java 8 新特性 – Optional
Java应用中最常见的bug就是??空值异常???。在Java 8之前，??Google Guava??引入了Optionals类来解决NullPointerException，从而避免源码被各种null检查污染，以便开发者写出更加整洁的代码。
Java 8也将Optional加入了官方库。
Optional仅仅是一个功能：存放T类型的值或者null。它提供了一些有用的接口来避免显式的null检查，可以参考??Java 8官方文档??了解更多细节。
接下来看一点使用Optional的例子：可能为空的值或者某个类型的值：
Optional<String> fullName = Optional.ofNullable( null );System.out.println( “Full Name is set? ” + fullName.isPresent() ); System.out.println( “Full Name: ” + fullName.orElseGet( () -> “[none]” ) ); System.out.println( fullName.map( s -> “Hey ” + s + “!” ).orElse( “Hey Stranger!” ) );
如果Optional 实例持有一个非空值，则 isPresent() 方法返回true，否则返回false；
orElseGet() 方法，Optional 实例持有null，则可以接受一个lambda表达式生成的默认值；
map() 方法可以将现有的 Opetional 实例的值转换成新的值；
orElse() 方法与 orElseGet() 方法类似，但是在持有null的时候返回传入的默认值。
上述代码的输出结果如下：
Full Name is set? falseFull Name: [none]Hey Stranger!
再看下另一个简单的例子：
Optional<String> firstName = Optional.of( “Tom” );System.out.println( “First Name is set? ” + firstName.isPresent() ); System.out.println( “First Name: ” + firstName.orElseGet( () -> “[none]” ) ); System.out.println( firstName.map(s -> “Hey ” + s + “!” ).orElse( “Hey Stranger!” ) );System.out.println();
这个例子的输出是：
First Name is set? trueFirst Name: TomHey Tom!
如果想了解更多的细节，请参考??官方文档??。
Optional源码-各个方法package java.util;import java.util.function.Consumer;import java.util.function.Function;import java.util.function.Predicate;import java.util.function.Supplier;/** * 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. * * <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). * * <p>This is a <a href=”../lang/doc-files/ValueBased.html”>value-based</a> * class; use of identity-sensitive operations (including reference equality * ({@code ==}), identity hash code, or synchronization) on instances of * {@code Optional} may have unpredictable results and should be avoided. * * @since 1.8 */public final class Optional<T> { /** * Common instance for {@code empty()}. */ private static final Optional<?> EMPTY = new Optional<>(); /** * If non-null, the value; if null, indicates no value is present */ private final T value; /** * Constructs an empty instance. * * @implNote Generally only one empty instance, {@link Optional#EMPTY}, * should exist per VM. * * 无参构造 */ private Optional() { this.value = null; } /** * Returns an empty {@code Optional} instance. No value is present for this * Optional. * * @apiNote Though it may be tempting to do so, avoid testing if an object * is empty by comparing with {@code ==} against instances returned by * {@code Option.empty()}. There is no guarantee that it is a singleton. * Instead, use {@link #isPresent()}. * * @param <T> Type of the non-existent value * @return an empty {@code Optional} * * 返回一个空Optional实例。 */ public static<T> Optional<T> empty() { @SuppressWarnings(“unchecked”) Optional<T> t = (Optional<T>) EMPTY; return t; } /** * Constructs an instance with the value present. * * @param value the non-null value to be present * @throws NullPointerException if value is null * * 有参构造 */ private Optional(T value) { this.value = Objects.requireNonNull(value); } /** * Returns an {@code Optional} with the specified present non-null value. * * @param <T> the class of the value * @param value the value to be present, which must be non-null * @return an {@code Optional} with the value present * @throws NullPointerException if value is null * * 返回一个具有指定当前非空值的Optional实例。 */ public static <T> Optional<T> of(T value) { return new Optional<>(value); } /** * Returns an {@code Optional} describing the specified value, if non-null, * otherwise returns an empty {@code Optional}. * * @param <T> the class of the value * @param value the possibly-null value to describe * @return an {@code Optional} with a present value if the specified value * is non-null, otherwise an empty {@code Optional} * * 如果非空，返回一个指定值Optional实例，否则返回一个空Optional。 */ public static <T> Optional<T> ofNullable(T value) { return value == null ? empty() : of(value); } /** * If a value is present in this {@code Optional}, returns the value, * otherwise throws {@code NoSuchElementException}. * * @return the non-null value held by this {@code Optional} * @throws NoSuchElementException if there is no value present * * @see Optional#isPresent() * * 如果 this 中存在Optional值，则返回该值，否则抛出NoSuchElementException。 */ public T get() { if (value == null) { throw new NoSuchElementException(“No value present”); } return value; } /** * Return {@code true} if there is a value present, otherwise {@code false}. * * @return {@code true} if there is a value present, otherwise {@code false} * * 如果存在值（不为null）则返回true，否则返回false。 */ public boolean isPresent() { return value != null; } /** * If a value is present, invoke the specified consumer with the value, * otherwise do nothing. * * @param consumer block to be executed if a value is present * @throws NullPointerException if value is present and {@code consumer} is * null * * 如果存在值，则使用该值调用指定的使用者，否则不执行任何操作。 */ public void ifPresent(Consumer<? super T> consumer) { if (value != null) consumer.accept(value); } /** * If a value is present, and the value matches the given predicate, * return an {@code Optional} describing the value, otherwise return an * empty {@code Optional}. * * @param predicate a predicate to apply to the value, if present * @return an {@code Optional} describing the value of this {@code Optional} * if a value is present and the value matches the given predicate, * otherwise an empty {@code Optional} * @throws NullPointerException if the predicate is null * * 如果存在一个值，并且该值与给定的谓词匹配，则返回一个Optional描述该值的值，否则返回一个空值Optional。 */ public Optional<T> filter(Predicate<? super T> predicate) { Objects.requireNonNull(predicate); if (!isPresent()) return this; else return predicate.test(value) ? this : empty(); } /** * If a value is present, apply the provided mapping function to it, * and if the result is non-null, return an {@code Optional} describing the * result. Otherwise return an empty {@code Optional}. * * @apiNote This method supports post-processing on optional values, without * the need to explicitly check for a return status. For example, the * following code traverses a stream of file names, selects one that has * not yet been processed, and then opens that file, returning an * {@code Optional<FileInputStream>}: * * <pre>{@code * Optional<FileInputStream> fis = * names.stream().filter(name -> !isProcessedYet(name)) * .findFirst() * .map(name -> new FileInputStream(name)); * }</pre> * * Here, {@code findFirst} returns an {@code Optional<String>}, and then * {@code map} returns an {@code Optional<FileInputStream>} for the desired * file if one exists. * * @param <U> The type of the result of the mapping function * @param mapper a mapping function to apply to the value, if present * @return an {@code Optional} describing the result of applying a mapping * function to the value of this {@code Optional}, if a value is present, * otherwise an empty {@code Optional} * @throws NullPointerException if the mapping function is null * * 如果存在值，则对其应用提供的映射函数，如果结果为非 null，则返回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)); } } /** * If a value is present, apply the provided {@code Optional}-bearing * mapping function to it, return that result, otherwise return an empty * {@code Optional}. This method is similar to {@link #map(Function)}, * but the provided mapper is one whose result is already an {@code Optional}, * and if invoked, {@code flatMap} does not wrap it with an additional * {@code Optional}. * * @param <U> The type parameter to the {@code Optional} returned by * @param mapper a mapping function to apply to the value, if present * the mapping function * @return the result of applying an {@code Optional}-bearing mapping * function to the value of this {@code Optional}, if a value is present, * otherwise an empty {@code Optional} * @throws NullPointerException if the mapping function is null or returns * a null result * * 如果存在值，则将提供的Optional-bearing 映射函数应用于它，返回该结果，否则返回空 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)); } } /** * Return the value if present, otherwise return {@code other}. * * @param other the value to be returned if there is no value present, may * be null * @return the value, if present, otherwise {@code other} * * 对自身判断，如果存在则返回自身，否则返回other。 * 对自身判断，如果不为null则返回自身，否则返回一个指定的值。 */ public T orElse(T other) { return value != null ? value : other; } /** * Return the value if present, otherwise invoke {@code other} and return * the result of that invocation. * * @param other a {@code Supplier} whose result is returned if no value * is present * @return the value if present otherwise the result of {@code other.get()} * @throws NullPointerException if value is not present and {@code other} is * null * * 如果存在则返回该值，否则调用other并返回该调用的结果。 */ public T orElseGet(Supplier<? extends T> other) { return value != null ? value : other.get(); } /** * Return the contained value, if present, otherwise throw an exception * to be created by the provided supplier. * * @apiNote A method reference to the exception constructor with an empty * argument list can be used as the supplier. For example, * {@code IllegalStateException::new} * * @param <X> Type of the exception to be thrown * @param exceptionSupplier The supplier which will return the exception to * be thrown * @return the present value * @throws X if there is no value present * @throws NullPointerException if no value is present and * {@code exceptionSupplier} is null * * 如果存在（不为null），则返回该值，否则抛出由提供的供应商创建的异常。 */ public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X { if (value != null) { return value; } else { throw exceptionSupplier.get(); } } /** * Indicates whether some other object is “equal to” this Optional. The * other object is considered equal if: * <ul> * <li>it is also an {@code Optional} and; * <li>both instances have no value present or; * <li>the present values are “equal to” each other via {@code equals()}. * </ul> * * @param obj an object to be tested for equality * @return {code true} if the other object is “equal to” this object * otherwise {@code false} * * 判断某个其他对象是否“等于”此 Optional。 相等返回true，不想等返回false */ @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof Optional)) { return false; } Optional<?> other = (Optional<?>) obj; return Objects.equals(value, other.value); } /** * Returns the hash code value of the present value, if any, or 0 (zero) if * no value is present. * * @return hash code value of the present value or 0 if no value is present * * 返回当前值的哈希码值（如果有）；如果不存在值，则返回 0（零）。 */ @Override public int hashCode() { return Objects.hashCode(value); } /** * Returns a non-empty string representation of this Optional suitable for * debugging. The exact presentation format is unspecified and may vary * between implementations and versions. * * @implSpec If a value is present the result must include its string * representation in the result. Empty and present Optionals must be * unambiguously differentiable. * * @return the string representation of this instance * * 返回此 Optional 适合调试的非空字符串表示形式。 */ @Override public String toString() { return value != null ? String.format(“Optional[%s]”, value) : “Optional.empty”; }}
【转自：外国服务器 shsgf.html转载请说明出处】再长的路，一步步也能走完，再短的路，不迈开双脚也无法到达。
