Package com.google.common.base

Class Absent<T>

  • All Implemented Interfaces:
    java.io.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 Absent<java.lang.Object> INSTANCE  
      private static long serialVersionUID  

    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private Absent()  

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      java.util.Set<T> asSet()
      Returns an immutable singleton Set whose only element is the contained instance if it is present; an empty immutable Set otherwise.
      boolean equals​(java.lang.Object object)
      Returns true if object is an Optional instance, and either the contained references are equal to each other or both are absent.
      T get()
      Returns the contained instance, which must be present.
      int hashCode()
      Returns a hash code for this instance.
      boolean isPresent()
      Returns true if this holder contains a (non-null) instance.
      Optional<T> or​(Optional<? extends T> secondChoice)
      Returns this Optional if it has a value present; secondChoice otherwise.
      T or​(Supplier<? extends T> supplier)
      Returns the contained instance if it is present; supplier.get() otherwise.
      T or​(T defaultValue)
      Returns the contained instance if it is present; defaultValue otherwise.
      T orNull()
      Returns the contained instance if it is present; null otherwise.
      private java.lang.Object readResolve()  
      java.lang.String toString()
      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> withType()  

      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, wait, wait, wait

    • Field Detail

      • INSTANCE

        static final Absent<java.lang.Object> INSTANCE

    • Constructor Detail

      • Absent

        private Absent()

    • Method Detail

      • 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 8 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

        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 java.util.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​(java.lang.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 java.lang.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 java.lang.Object readResolve()