001/* 002 * Copyright (C) 2011 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 */ 014 015package com.google.common.base; 016 017import static com.google.common.base.Preconditions.checkNotNull; 018 019import com.google.common.annotations.GwtCompatible; 020import com.google.errorprone.annotations.DoNotMock; 021import java.io.Serializable; 022import java.util.Iterator; 023import java.util.Set; 024import javax.annotation.CheckForNull; 025 026/** 027 * An immutable object that may contain a non-null reference to another object. Each instance of 028 * this type either contains a non-null reference, or contains nothing (in which case we say that 029 * the reference is "absent"); it is never said to "contain {@code null}". 030 * 031 * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable {@code T} 032 * reference. It allows you to represent "a {@code T} that must be present" and a "a {@code T} that 033 * might be absent" as two distinct types in your program, which can aid clarity. 034 * 035 * <p>Some uses of this class include 036 * 037 * <ul> 038 * <li>As a method return type, as an alternative to returning {@code null} to indicate that no 039 * value was available 040 * <li>To distinguish between "unknown" (for example, not present in a map) and "known to have no 041 * value" (present in the map, with value {@code Optional.absent()}) 042 * <li>To wrap nullable references for storage in a collection that does not support {@code null} 043 * (though there are <a 044 * href="https://github.com/google/guava/wiki/LivingWithNullHostileCollections">several other 045 * approaches to this</a> that should be considered first) 046 * </ul> 047 * 048 * <p>A common alternative to using this class is to find or create a suitable <a 049 * href="http://en.wikipedia.org/wiki/Null_Object_pattern">null object</a> for the type in question. 050 * 051 * <p>This class is not intended as a direct analogue of any existing "option" or "maybe" construct 052 * from other programming environments, though it may bear some similarities. 053 * 054 * <p>An instance of this class is serializable if its reference is absent or is a serializable 055 * object. 056 * 057 * <p><b>Comparison to {@code java.util.Optional} (JDK 8 and higher):</b> A new {@code Optional} 058 * class was added for Java 8. The two classes are extremely similar, but incompatible (they cannot 059 * share a common supertype). <i>All</i> known differences are listed either here or with the 060 * relevant methods below. 061 * 062 * <ul> 063 * <li>This class is serializable; {@code java.util.Optional} is not. 064 * <li>{@code java.util.Optional} has the additional methods {@code ifPresent}, {@code filter}, 065 * {@code flatMap}, and {@code orElseThrow}. 066 * <li>{@code java.util} offers the primitive-specialized versions {@code OptionalInt}, {@code 067 * OptionalLong} and {@code OptionalDouble}, the use of which is recommended; Guava does not 068 * have these. 069 * </ul> 070 * 071 * <p><b>There are no plans to deprecate this class in the foreseeable future.</b> However, we do 072 * gently recommend that you prefer the new, standard Java class whenever possible. 073 * 074 * <p>See the Guava User Guide article on <a 075 * href="https://github.com/google/guava/wiki/UsingAndAvoidingNullExplained#optional">using {@code 076 * Optional}</a>. 077 * 078 * @param <T> the type of instance that can be contained. {@code Optional} is naturally covariant on 079 * this type, so it is safe to cast an {@code Optional<T>} to {@code Optional<S>} for any 080 * supertype {@code S} of {@code T}. 081 * @author Kurt Alfred Kluever 082 * @author Kevin Bourrillion 083 * @since 10.0 084 */ 085@DoNotMock("Use Optional.of(value) or Optional.absent()") 086@GwtCompatible(serializable = true) 087public abstract class Optional<T> implements Serializable { 088 /** 089 * Returns an {@code Optional} instance with no contained reference. 090 * 091 * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's 092 * {@code Optional.empty}. 093 */ 094 public static <T> Optional<T> absent() { 095 return Absent.withType(); 096 } 097 098 /** 099 * Returns an {@code Optional} instance containing the given non-null reference. To have {@code 100 * null} treated as {@link #absent}, use {@link #fromNullable} instead. 101 * 102 * <p><b>Comparison to {@code java.util.Optional}:</b> no differences. 103 * 104 * @throws NullPointerException if {@code reference} is null 105 */ 106 public static <T> Optional<T> of(T reference) { 107 return new Present<>(checkNotNull(reference)); 108 } 109 110 /** 111 * If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that 112 * reference; otherwise returns {@link Optional#absent}. 113 * 114 * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's 115 * {@code Optional.ofNullable}. 116 */ 117 public static <T> Optional<T> fromNullable(@CheckForNull T nullableReference) { 118 return (nullableReference == null) ? Optional.<T>absent() : new Present<T>(nullableReference); 119 } 120 121 /** 122 * Returns the equivalent {@code com.google.common.base.Optional} value to the given {@code 123 * java.util.Optional}, or {@code null} if the argument is null. 124 * 125 * @since 21.0 (but only since 33.4.0 in the Android flavor) 126 */ 127 @CheckForNull 128 public static <T> Optional<T> fromJavaUtil(@CheckForNull java.util.Optional<T> javaUtilOptional) { 129 return (javaUtilOptional == null) ? null : fromNullable(javaUtilOptional.orElse(null)); 130 } 131 132 /** 133 * Returns the equivalent {@code java.util.Optional} value to the given {@code 134 * com.google.common.base.Optional}, or {@code null} if the argument is null. 135 * 136 * <p>If {@code googleOptional} is known to be non-null, use {@code googleOptional.toJavaUtil()} 137 * instead. 138 * 139 * <p>Unfortunately, the method reference {@code Optional::toJavaUtil} will not work, because it 140 * could refer to either the static or instance version of this method. Write out the lambda 141 * expression {@code o -> Optional.toJavaUtil(o)} instead. 142 * 143 * @since 21.0 (but only since 33.4.0 in the Android flavor) 144 */ 145 @SuppressWarnings("AmbiguousMethodReference") // We chose the name despite knowing this risk. 146 @CheckForNull 147 public static <T> java.util.Optional<T> toJavaUtil(@CheckForNull Optional<T> googleOptional) { 148 return googleOptional == null ? null : googleOptional.toJavaUtil(); 149 } 150 151 /** 152 * Returns the equivalent {@code java.util.Optional} value to this optional. 153 * 154 * <p>Unfortunately, the method reference {@code Optional::toJavaUtil} will not work, because it 155 * could refer to either the static or instance version of this method. Write out the lambda 156 * expression {@code o -> o.toJavaUtil()} instead. 157 * 158 * @since 21.0 (but only since 33.4.0 in the Android flavor) 159 */ 160 @SuppressWarnings("AmbiguousMethodReference") // We chose the name despite knowing this risk. 161 public java.util.Optional<T> toJavaUtil() { 162 return java.util.Optional.ofNullable(orNull()); 163 } 164 165 Optional() {} 166 167 /** 168 * Returns {@code true} if this holder contains a (non-null) instance. 169 * 170 * <p><b>Comparison to {@code java.util.Optional}:</b> no differences. 171 */ 172 public abstract boolean isPresent(); 173 174 /** 175 * Returns the contained instance, which must be present. If the instance might be absent, use 176 * {@link #or(Object)} or {@link #orNull} instead. 177 * 178 * <p><b>Comparison to {@code java.util.Optional}:</b> when the value is absent, this method 179 * throws {@link IllegalStateException}, whereas the {@code java.util} counterpart throws {@link 180 * java.util.NoSuchElementException NoSuchElementException}. 181 * 182 * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns {@code 183 * false}); depending on this <i>specific</i> exception type (over the more general {@link 184 * RuntimeException}) is discouraged 185 */ 186 public abstract T get(); 187 188 /** 189 * Returns the contained instance if it is present; {@code defaultValue} otherwise. If no default 190 * value should be required because the instance is known to be present, use {@link #get()} 191 * instead. For a default value of {@code null}, use {@link #orNull}. 192 * 193 * <p>Note about generics: The signature {@code public T or(T defaultValue)} is overly 194 * restrictive. However, the ideal signature, {@code public <S super T> S or(S)}, is not legal 195 * Java. As a result, some sensible operations involving subtypes are compile errors: 196 * 197 * <pre>{@code 198 * Optional<Integer> optionalInt = getSomeOptionalInt(); 199 * Number value = optionalInt.or(0.5); // error 200 * 201 * FluentIterable<? extends Number> numbers = getSomeNumbers(); 202 * Optional<? extends Number> first = numbers.first(); 203 * Number value = first.or(0.5); // error 204 * }</pre> 205 * 206 * <p>As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code 207 * Optional<T>}. Casting either of the above example {@code Optional} instances to {@code 208 * Optional<Number>} (where {@code Number} is the desired output type) solves the problem: 209 * 210 * <pre>{@code 211 * Optional<Number> optionalInt = (Optional) getSomeOptionalInt(); 212 * Number value = optionalInt.or(0.5); // fine 213 * 214 * FluentIterable<? extends Number> numbers = getSomeNumbers(); 215 * Optional<Number> first = (Optional) numbers.first(); 216 * Number value = first.or(0.5); // fine 217 * }</pre> 218 * 219 * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code 220 * Optional.orElse}, but will not accept {@code null} as a {@code defaultValue} ({@link #orNull} 221 * must be used instead). As a result, the value returned by this method is guaranteed non-null, 222 * which is not the case for the {@code java.util} equivalent. 223 */ 224 public abstract T or(T defaultValue); 225 226 /** 227 * Returns this {@code Optional} if it has a value present; {@code secondChoice} otherwise. 228 * 229 * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's 230 * {@code Optional} class; write {@code thisOptional.isPresent() ? thisOptional : secondChoice} 231 * instead. 232 */ 233 public abstract Optional<T> or(Optional<? extends T> secondChoice); 234 235 /** 236 * Returns the contained instance if it is present; {@code supplier.get()} otherwise. 237 * 238 * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code 239 * Optional.orElseGet}, except when {@code supplier} returns {@code null}. In this case this 240 * method throws an exception, whereas the Java 8+ method returns the {@code null} to the caller. 241 * 242 * @throws NullPointerException if this optional's value is absent and the supplier returns {@code 243 * null} 244 */ 245 public abstract T or(Supplier<? extends T> supplier); 246 247 /** 248 * Returns the contained instance if it is present; {@code null} otherwise. If the instance is 249 * known to be present, use {@link #get()} instead. 250 * 251 * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's 252 * {@code Optional.orElse(null)}. 253 */ 254 @CheckForNull 255 public abstract T orNull(); 256 257 /** 258 * Returns an immutable singleton {@link Set} whose only element is the contained instance if it 259 * is present; an empty immutable {@link Set} otherwise. 260 * 261 * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's 262 * {@code Optional} class. However, this common usage: 263 * 264 * <pre>{@code 265 * for (Foo foo : possibleFoo.asSet()) { 266 * doSomethingWith(foo); 267 * } 268 * }</pre> 269 * 270 * ... can be replaced with: 271 * 272 * <pre>{@code 273 * possibleFoo.ifPresent(foo -> doSomethingWith(foo)); 274 * }</pre> 275 * 276 * <p><b>Java 9 users:</b> some use cases can be written with calls to {@code optional.stream()}. 277 * 278 * @since 11.0 279 */ 280 public abstract Set<T> asSet(); 281 282 /** 283 * If the instance is present, it is transformed with the given {@link Function}; otherwise, 284 * {@link Optional#absent} is returned. 285 * 286 * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code 287 * Optional.map}, except when {@code function} returns {@code null}. In this case this method 288 * throws an exception, whereas the Java 8+ method returns {@code Optional.absent()}. 289 * 290 * @throws NullPointerException if the function returns {@code null} 291 * @since 12.0 292 */ 293 public abstract <V> Optional<V> transform(Function<? super T, V> function); 294 295 /** 296 * Returns {@code true} if {@code object} is an {@code Optional} instance, and either the 297 * contained references are {@linkplain Object#equals equal} to each other or both are absent. 298 * Note that {@code Optional} instances of differing parameterized types can be equal. 299 * 300 * <p><b>Comparison to {@code java.util.Optional}:</b> no differences. 301 */ 302 @Override 303 public abstract boolean equals(@CheckForNull Object object); 304 305 /** 306 * Returns a hash code for this instance. 307 * 308 * <p><b>Comparison to {@code java.util.Optional}:</b> this class leaves the specific choice of 309 * hash code unspecified, unlike the Java 8+ equivalent. 310 */ 311 @Override 312 public abstract int hashCode(); 313 314 /** 315 * Returns a string representation for this instance. 316 * 317 * <p><b>Comparison to {@code java.util.Optional}:</b> this class leaves the specific string 318 * representation unspecified, unlike the Java 8+ equivalent. 319 */ 320 @Override 321 public abstract String toString(); 322 323 /** 324 * Returns the value of each present instance from the supplied {@code optionals}, in order, 325 * skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are 326 * evaluated lazily. 327 * 328 * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's 329 * {@code Optional} class; use {@code 330 * optionals.stream().filter(Optional::isPresent).map(Optional::get)} instead. 331 * 332 * <p><b>Java 9 users:</b> use {@code optionals.stream().flatMap(Optional::stream)} instead. 333 * 334 * @since 11.0 (generics widened in 13.0) 335 */ 336 public static <T> Iterable<T> presentInstances( 337 final Iterable<? extends Optional<? extends T>> optionals) { 338 checkNotNull(optionals); 339 return new Iterable<T>() { 340 @Override 341 public Iterator<T> iterator() { 342 return new AbstractIterator<T>() { 343 private final Iterator<? extends Optional<? extends T>> iterator = 344 checkNotNull(optionals.iterator()); 345 346 @Override 347 @CheckForNull 348 protected T computeNext() { 349 while (iterator.hasNext()) { 350 Optional<? extends T> optional = iterator.next(); 351 if (optional.isPresent()) { 352 return optional.get(); 353 } 354 } 355 return endOfData(); 356 } 357 }; 358 } 359 }; 360 } 361 362 private static final long serialVersionUID = 0; 363}