Class Absent<T>

java.lang.Object
com.google.common.base.Optional<T>
com.google.common.base.Absent<T>
All Implemented Interfaces:
Serializable

final class Absent<T> extends Optional<T>
Implementation of an Optional not containing a reference.
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    (package private) static final Absent<Object>
     
    private static final long
     
  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    private
     
  • Method Summary

    Modifier and Type
    Method
    Description
    Returns an immutable singleton Set whose only element is the contained instance if it is present; an empty immutable Set otherwise.
    boolean
    equals(Object object)
    Returns true if object is an Optional instance, and either the contained references are equal to each other or both are absent.
    get()
    Returns the contained instance, which must be present.
    int
    Returns a hash code for this instance.
    boolean
    Returns true if this holder contains a (non-null) instance.
    or(Optional<? extends T> secondChoice)
    Returns this Optional if it has a value present; secondChoice otherwise.
    or(Supplier<? extends T> supplier)
    Returns the contained instance if it is present; supplier.get() otherwise.
    or(T defaultValue)
    Returns the contained instance if it is present; defaultValue otherwise.
    Returns the contained instance if it is present; null otherwise.
    private Object
     
    Returns a string representation for this instance.
    <V> Optional<V>
    transform(Function<? super T,V> function)
    If the instance is present, it is transformed with the given Function; otherwise, Optional.absent() is returned.
    (package private) static <T> Optional<T>
     

    Methods inherited from class com.google.common.base.Optional

    absent, fromJavaUtil, fromNullable, of, presentInstances, toJavaUtil, toJavaUtil

    Methods inherited from class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait
  • Field Details

  • Constructor Details

    • Absent

      private Absent()
  • Method Details

    • withType

      static <T> Optional<T> withType()
    • isPresent

      public boolean isPresent()
      Description copied from class: Optional
      Returns true if this holder contains a (non-null) instance.

      Comparison to java.util.Optional: no differences.

      Specified by:
      isPresent in class Optional<T>
    • get

      public T get()
      Description copied from class: Optional
      Returns the contained instance, which must be present. If the instance might be absent, use Optional.or(Object) or Optional.orNull() instead.

      Comparison to java.util.Optional: when the value is absent, this method throws IllegalStateException, whereas the java.util counterpart throws NoSuchElementException.

      Specified by:
      get in class Optional<T>
    • or

      public T or(T defaultValue)
      Description copied from class: Optional
      Returns the contained instance if it is present; defaultValue otherwise. If no default value should be required because the instance is known to be present, use Optional.get() instead. For a default value of null, use Optional.orNull().

      Note about generics: The signature public T or(T defaultValue) is overly restrictive. However, the ideal signature, public <S super T> S or(S), is not legal Java. As a result, some sensible operations involving subtypes are compile errors:

      
       Optional<Integer> optionalInt = getSomeOptionalInt();
       Number value = optionalInt.or(0.5); // error
      
       FluentIterable<? extends Number> numbers = getSomeNumbers();
       Optional<? extends Number> first = numbers.first();
       Number value = first.or(0.5); // error
       

      As a workaround, it is always safe to cast an Optional<? extends T> to Optional<T>. Casting either of the above example Optional instances to Optional<Number> (where Number is the desired output type) solves the problem:

      
       Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
       Number value = optionalInt.or(0.5); // fine
      
       FluentIterable<? extends Number> numbers = getSomeNumbers();
       Optional<Number> first = (Optional) numbers.first();
       Number value = first.or(0.5); // fine
       

      Comparison to java.util.Optional: this method is similar to Java 8's Optional.orElse, but will not accept null as a defaultValue (Optional.orNull() must be used instead). As a result, the value returned by this method is guaranteed non-null, which is not the case for the java.util equivalent.

      Specified by:
      or in class Optional<T>
    • or

      public Optional<T> or(Optional<? extends T> secondChoice)
      Description copied from class: Optional
      Returns this Optional if it has a value present; secondChoice otherwise.

      Comparison to java.util.Optional: this method has no equivalent in Java 8's Optional class; write thisOptional.isPresent() ? thisOptional : secondChoice instead.

      Specified by:
      or in class Optional<T>
    • or

      public T or(Supplier<? extends T> supplier)
      Description copied from class: Optional
      Returns the contained instance if it is present; supplier.get() otherwise.

      Comparison to java.util.Optional: this method is similar to Java 8's Optional.orElseGet, except when supplier returns null. In this case this method throws an exception, whereas the Java 8+ method returns the null to the caller.

      Specified by:
      or in class Optional<T>
    • orNull

      @CheckForNull public T orNull()
      Description copied from class: Optional
      Returns the contained instance if it is present; null otherwise. If the instance is known to be present, use Optional.get() instead.

      Comparison to java.util.Optional: this method is equivalent to Java 8's Optional.orElse(null).

      Specified by:
      orNull in class Optional<T>
    • asSet

      public Set<T> asSet()
      Description copied from class: Optional
      Returns an immutable singleton Set whose only element is the contained instance if it is present; an empty immutable Set otherwise.

      Comparison to java.util.Optional: this method has no equivalent in Java 8's Optional class. However, this common usage:

      
       for (Foo foo : possibleFoo.asSet()) {
         doSomethingWith(foo);
       }
       
      ... can be replaced with:
      
       possibleFoo.ifPresent(foo -> doSomethingWith(foo));
       

      Java 9 users: some use cases can be written with calls to optional.stream().

      Specified by:
      asSet in class Optional<T>
    • transform

      public <V> Optional<V> transform(Function<? super T,V> function)
      Description copied from class: Optional
      If the instance is present, it is transformed with the given Function; otherwise, Optional.absent() is returned.

      Comparison to java.util.Optional: this method is similar to Java 8's Optional.map, except when function returns null. In this case this method throws an exception, whereas the Java 8+ method returns Optional.absent().

      Specified by:
      transform in class Optional<T>
    • equals

      public boolean equals(@CheckForNull Object object)
      Description copied from class: Optional
      Returns true if object is an Optional instance, and either the contained references are equal to each other or both are absent. Note that Optional instances of differing parameterized types can be equal.

      Comparison to java.util.Optional: no differences.

      Specified by:
      equals in class Optional<T>
    • hashCode

      public int hashCode()
      Description copied from class: Optional
      Returns a hash code for this instance.

      Comparison to java.util.Optional: this class leaves the specific choice of hash code unspecified, unlike the Java 8+ equivalent.

      Specified by:
      hashCode in class Optional<T>
    • toString

      public String toString()
      Description copied from class: Optional
      Returns a string representation for this instance.

      Comparison to java.util.Optional: this class leaves the specific string representation unspecified, unlike the Java 8+ equivalent.

      Specified by:
      toString in class Optional<T>
    • readResolve

      private Object readResolve()