Optionals (Root POM 0.9.18-SNAPSHOT API)

java.lang.Object
- de.larssh.utils.Optionals

```
public final class Optionals
extends Object
```
This class contains helper methods for Optional.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T extends Comparable<T>> Comparator<? super Optional<? extends T>>`	`comparator()` Creates a `Comparator` to compare `Optional`s based on the inner types `Comparable` implementation.
`static <T> Comparator<? super Optional<? extends T>>`	`comparator(Comparator<? super T> comparator)` Wraps a `Comparator` to allow compare `Optional`s.
`static <T,U extends Comparable<U>> Comparator<T>`	`comparator(Function<T,Optional<U>> keyExtractor)` Wraps a `Comparator` to allow compare `Optional`s.
`static <T> OptionalDouble`	`flatMapToDouble(Optional<T> optional, Function<? super T,OptionalDouble> mapper)` If a value is present, apply the provided `OptionalDouble`-bearing mapping function to it, return that result, otherwise return an empty `OptionalDouble`.
`static <T> OptionalInt`	`flatMapToInt(Optional<T> optional, Function<? super T,OptionalInt> mapper)` If a value is present, apply the provided `OptionalInt`-bearing mapping function to it, return that result, otherwise return an empty `OptionalInt`.
`static <T> OptionalLong`	`flatMapToLong(Optional<T> optional, Function<? super T,OptionalLong> mapper)` If a value is present, apply the provided `OptionalLong`-bearing mapping function to it, return that result, otherwise return an empty `OptionalLong`.
`static <T> Optional<T>`	`getFirst(Optional<T>... values)` Returns the first present value.
`static <T> Optional<T>`	`getFirst(Predicate<? super T> isPresent, Supplier<? extends T>... suppliers)` Returns an `Optional` describing the first value matching the predicate `isPresent`.
`static <T> Optional<T>`	`getFirst(Supplier<? extends Optional<T>>... suppliers)` Returns the first present value.
`static <T> Optional<T>`	`getFirstValue(Predicate<? super T> isPresent, T... values)` Returns an `Optional` describing the first value matching the predicate `isPresent`.
`static OptionalDouble`	`mapToDouble(Optional<Double> optional)` If a value is present, returns an `OptionalDouble` describing the result.
`static <T> OptionalDouble`	`mapToDouble(Optional<T> optional, ToDoubleFunction<? super T> mapper)` If a value is present, applies `mapper` to `optional` and returns an `OptionalDouble` describing the result.
`static OptionalInt`	`mapToInt(Optional<Integer> optional)` If a value is present, returns an `OptionalInt` describing the result.
`static <T> OptionalInt`	`mapToInt(Optional<T> optional, ToIntFunction<? super T> mapper)` If a value is present, applies `mapper` to `optional` and returns an `OptionalInt` describing the result.
`static OptionalLong`	`mapToLong(Optional<Long> optional)` If a value is present, returns an `OptionalLong` describing the result.
`static <T> OptionalLong`	`mapToLong(Optional<T> optional, ToLongFunction<? super T> mapper)` If a value is present, applies `mapper` to `optional` and returns an `OptionalLong` describing the result.
`static <T> Optional<T>`	`ofNon(Predicate<? super T> isEmpty, T value)` Returns an `Optional` describing the specified value, if non-null and non-empty, otherwise returns an empty `Optional`.
`static Optional<String>`	`ofNonBlank(String string)` Returns an `Optional` describing the specified string, if non-null and non-blank, otherwise returns an empty `Optional`.
`static Optional<String>`	`ofNonEmpty(String string)` Returns an `Optional` describing the specified string, if non-null and non-empty, otherwise returns an empty `Optional`.
`static <T extends Collection<?>> Optional<T>`	`ofNonEmpty(T collection)` Returns an `Optional` describing the specified collection, if non-null and non-empty, otherwise returns an empty `Optional`.
`static <T> Optional<T[]>`	`ofNonEmpty(T[] array)` Returns an `Optional` describing the specified array, if non-null and non-empty, otherwise returns an empty `Optional`.
`static OptionalInt`	`ofSingle(CharSequence string)` Returns an `OptionalInt` describing the specified strings first character, if present, otherwise returns an empty `OptionalInt`.
`static <T> Optional<T>`	`ofSingle(Iterable<T> iterable)` Returns an `Optional` describing the specified iterables first element, if present, otherwise returns an empty `Optional`.
`static <T> Optional<T>`	`ofSingle(Iterator<T> iterator)` Returns an `Optional` describing the specified iterators first element, if present, otherwise returns an empty `Optional`.
`static <T> Optional<T>`	`ofSingle(Stream<T> stream)` Returns an `Optional` describing the specified streams first element, if present, otherwise returns an empty `Optional`.
`static <T> Optional<T>`	`ofSingle(T[] array)` Returns an `Optional` describing the specified arrays first element, if present, otherwise returns an empty `Optional`.
`static <T> Stream<T>`	`stream(Optional<T>... optionals)` Returns a stream consisting of present elements.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - comparator
```
public static <T extends Comparable<T>> Comparator<? super Optional<? extends T>> comparator()
```
    Creates a Comparator to compare Optionals based on the inner types Comparable implementation.
    
    Type Parameters:
    
    T - optional value type
    
    Returns:
    
    comparator for optional
  - comparator
```
public static <T> Comparator<? super Optional<? extends T>> comparator(Comparator<? super T> comparator)
```
    Wraps a Comparator to allow compare Optionals.
    When comparing comparator is called with the optionals object if present or null. Therefore it needs to handle null values appropriately. Use Comparator.nullsFirst(Comparator) and Comparator.nullsLast(Comparator) if your comparator does not.
    
    Type Parameters:
    
    T - optional value type
    
    Parameters:
    
    comparator - optional value comparator
    
    Returns:
    
    comparator for optional
  - comparator
```
public static <T,U extends Comparable<U>> Comparator<T> comparator(Function<T,Optional<U>> keyExtractor)
```
    Wraps a Comparator to allow compare Optionals.
    
    Type Parameters:
    
    T - the type of element to be compared
    
    U - the type of the sort key
    
    Parameters:
    
    keyExtractor - method to extract the optional sort key
    
    Returns:
    
    comparator for optional
  - flatMapToDouble
```
public static <T> OptionalDouble flatMapToDouble(Optional<T> optional,
                                                 Function<? super T,OptionalDouble> mapper)
```
    If a value is present, apply the provided OptionalDouble-bearing mapping function to it, return that result, otherwise return an empty OptionalDouble. This method is similar to mapToDouble(Optional, ToDoubleFunction), but the provided mapper is one whose result is already an OptionalDouble, and if invoked, flatMapToDouble does not wrap it with an additional OptionalDouble.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optional - optional value
    
    mapper - a mapping function to apply to the value, if present the mapping function
    
    Returns:
    
    the result of applying an OptionalDouble-bearing mapping function to the value of this OptionalDouble, if a value is present, otherwise an empty OptionalDouble
  - flatMapToInt
```
public static <T> OptionalInt flatMapToInt(Optional<T> optional,
                                           Function<? super T,OptionalInt> mapper)
```
    If a value is present, apply the provided OptionalInt-bearing mapping function to it, return that result, otherwise return an empty OptionalInt. This method is similar to mapToInt(Optional, ToIntFunction), but the provided mapper is one whose result is already an OptionalInt, and if invoked, flatMap does not wrap it with an additional OptionalInt.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optional - optional value
    
    mapper - a mapping function to apply to the value, if present the mapping function
    
    Returns:
    
    the result of applying an OptionalInt-bearing mapping function to the value of this OptionalInt, if a value is present, otherwise an empty OptionalInt
  - flatMapToLong
```
public static <T> OptionalLong flatMapToLong(Optional<T> optional,
                                             Function<? super T,OptionalLong> mapper)
```
    If a value is present, apply the provided OptionalLong-bearing mapping function to it, return that result, otherwise return an empty OptionalLong. This method is similar to mapToLong(Optional, ToLongFunction), but the provided mapper is one whose result is already an OptionalLong, and if invoked, flatMapToDouble does not wrap it with an additional OptionalLong.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optional - optional value
    
    mapper - a mapping function to apply to the value, if present the mapping function
    
    Returns:
    
    the result of applying an OptionalLong-bearing mapping function to the value of this OptionalLong, if a value is present, otherwise an empty OptionalLong
  - getFirst
```
@SafeVarargs
public static <T> Optional<T> getFirst(Optional<T>... values)
```
    Returns the first present value. Returns empty if no value is present.
    
    Type Parameters:
    
    T - value type
    
    Parameters:
    
    values - any number of optional values to test
    
    Returns:
    
    the first present value, empty if no value is present
  - getFirst
```
@SafeVarargs
public static <T> Optional<T> getFirst(Supplier<? extends Optional<T>>... suppliers)
```
    Returns the first present value. Values are created on-demand by calling suppliers one after the other. Returns empty if no value is present.
    
    Type Parameters:
    
    T - value type
    
    Parameters:
    
    suppliers - any number of value suppliers, which values to test, evaluated in a lazy manner
    
    Returns:
    
    the first present value, empty if no value is present
  - getFirst
```
@SafeVarargs
public static <T> Optional<T> getFirst(Predicate<? super T> isPresent,
                                                    Supplier<? extends T>... suppliers)
```
    Returns an Optional describing the first value matching the predicate isPresent. Values are created on-demand by calling suppliers one after the other. Returns an empty Optional if no element matches.
    
    Type Parameters:
    
    T - type of the return value
    
    Parameters:
    
    isPresent - predicate to match
    
    suppliers - any number of value suppliers, which values to test, evaluated in a lazy manner
    
    Returns:
    
    an Optional describing the first value matching the predicate isPresent, an empty Optional if no element matches
  - getFirstValue
```
@SafeVarargs
public static <T> Optional<T> getFirstValue(Predicate<? super T> isPresent,
                                                         T... values)
```
    Returns an Optional describing the first value matching the predicate isPresent. Returns an empty Optional if no element matches.
    
    Type Parameters:
    
    T - type of the return value
    
    Parameters:
    
    isPresent - predicate to match
    
    values - any number of values to test
    
    Returns:
    
    an Optional describing the first value matching the predicate isPresent, an empty Optional if no element matches
  - mapToDouble
```
public static OptionalDouble mapToDouble(Optional<Double> optional)
```
    If a value is present, returns an OptionalDouble describing the result. Otherwise returns an empty OptionalDouble.
    
    Parameters:
    
    optional - optional value
    
    Returns:
    
    an OptionalDouble describing the value of optional, if a value is present, otherwise an empty OptionalDouble
  - mapToDouble
```
public static <T> OptionalDouble mapToDouble(Optional<T> optional,
                                             ToDoubleFunction<? super T> mapper)
```
    If a value is present, applies mapper to optional and returns an OptionalDouble describing the result. Otherwise returns an empty OptionalDouble.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optional - optional value
    
    mapper - a mapping function to apply to the value, if present
    
    Returns:
    
    an OptionalDouble describing the result of applying mapper function to the value of optional, if a value is present, otherwise an empty OptionalDouble
  - mapToInt
```
public static OptionalInt mapToInt(Optional<Integer> optional)
```
    If a value is present, returns an OptionalInt describing the result. Otherwise returns an empty OptionalInt.
    
    Parameters:
    
    optional - optional value
    
    Returns:
    
    an OptionalInt describing the value of optional, if a value is present, otherwise an empty OptionalInt
  - mapToInt
```
public static <T> OptionalInt mapToInt(Optional<T> optional,
                                       ToIntFunction<? super T> mapper)
```
    If a value is present, applies mapper to optional and returns an OptionalInt describing the result. Otherwise returns an empty OptionalInt.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optional - optional value
    
    mapper - a mapping function to apply to the value, if present
    
    Returns:
    
    an OptionalInt describing the result of applying mapper function to the value of optional, if a value is present, otherwise an empty OptionalInt
  - mapToLong
```
public static OptionalLong mapToLong(Optional<Long> optional)
```
    If a value is present, returns an OptionalLong describing the result. Otherwise returns an empty OptionalLong.
    
    Parameters:
    
    optional - optional value
    
    Returns:
    
    an OptionalLong describing the value of optional, if a value is present, otherwise an empty OptionalLong
  - mapToLong
```
public static <T> OptionalLong mapToLong(Optional<T> optional,
                                         ToLongFunction<? super T> mapper)
```
    If a value is present, applies mapper to optional and returns an OptionalLong describing the result. Otherwise returns an empty OptionalLong.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optional - optional value
    
    mapper - a mapping function to apply to the value, if present
    
    Returns:
    
    an OptionalLong describing the result of applying mapper function to the value of optional, if a value is present, otherwise an empty OptionalLong
  - ofNon
```
public static <T> Optional<T> ofNon(Predicate<? super T> isEmpty,
                                    @Nullable
                                    T value)
```
    Returns an Optional describing the specified value, if non-null and non-empty, otherwise returns an empty Optional. The term empty is described by isEmpty.
    
    Type Parameters:
    
    T - value type
    
    Parameters:
    
    isEmpty - predicate describing the term empty
    
    value - the possibly-null-or-empty value to describe
    
    Returns:
    
    an Optional with a present value if the specified value is non-null and non-empty, otherwise an empty Optional
  - ofNonBlank
```
public static Optional<String> ofNonBlank(@Nullable
                                          String string)
```
    Returns an Optional describing the specified string, if non-null and non-blank, otherwise returns an empty Optional.
    
    Parameters:
    
    string - the possibly-null-or-blank string to describe
    
    Returns:
    
    an Optional with a present value if the specified string is non-null and non-empty after being trimmed, otherwise an empty Optional
  - ofNonEmpty
```
public static <T> Optional<T[]> ofNonEmpty(@Nullable
                                           T[] array)
```
    Returns an Optional describing the specified array, if non-null and non-empty, otherwise returns an empty Optional.
    
    Type Parameters:
    
    T - array element type
    
    Parameters:
    
    array - the possibly-null-or-empty array to describe
    
    Returns:
    
    an Optional with a present value if the specified array is non-null and non-empty, otherwise an empty Optional
  - ofNonEmpty
```
public static <T extends Collection<?>> Optional<T> ofNonEmpty(@Nullable
                                                               T collection)
```
    Returns an Optional describing the specified collection, if non-null and non-empty, otherwise returns an empty Optional.
    
    Type Parameters:
    
    T - collection and collection element type
    
    Parameters:
    
    collection - the possibly-null-or-empty collection to describe
    
    Returns:
    
    an Optional with a present value if the specified collection is non-null and non-empty, otherwise an empty Optional
  - ofNonEmpty
```
public static Optional<String> ofNonEmpty(@Nullable
                                          String string)
```
    Returns an Optional describing the specified string, if non-null and non-empty, otherwise returns an empty Optional.
    
    Parameters:
    
    string - the possibly-null-or-empty string to describe
    
    Returns:
    
    an Optional with a present value if the specified string is non-null and non-empty, otherwise an empty Optional
  - ofSingle
```
public static <T> Optional<T> ofSingle(T[] array)
```
    Returns an Optional describing the specified arrays first element, if present, otherwise returns an empty Optional. Throws a TooManyElementsException if array contains more than one element.
    
    Type Parameters:
    
    T - array element type
    
    Parameters:
    
    array - the array describing the element
    
    Returns:
    
    an Optional describing the specified arrays first element, if present, otherwise returns an empty Optional
    
    Throws:
    
    TooManyElementsException - if array contains more than one element
  - ofSingle
```
public static <T> Optional<T> ofSingle(Iterable<T> iterable)
```
    Returns an Optional describing the specified iterables first element, if present, otherwise returns an empty Optional. Throws a TooManyElementsException if iterable contains more than one element.
    
    Type Parameters:
    
    T - iterable element type
    
    Parameters:
    
    iterable - the iterable describing the element
    
    Returns:
    
    an Optional describing the specified iterables first element, if present, otherwise returns an empty Optional
    
    Throws:
    
    TooManyElementsException - if iterable contains more than one element
  - ofSingle
```
public static <T> Optional<T> ofSingle(Iterator<T> iterator)
```
    Returns an Optional describing the specified iterators first element, if present, otherwise returns an empty Optional. Throws a TooManyElementsException if iterator contains more than one element.
    
    Type Parameters:
    
    T - iterator element type
    
    Parameters:
    
    iterator - the iterator describing the element
    
    Returns:
    
    an Optional describing the specified iterators first element, if present, otherwise returns an empty Optional
    
    Throws:
    
    TooManyElementsException - if iterator contains more than one element
  - ofSingle
```
public static <T> Optional<T> ofSingle(Stream<T> stream)
```
    Returns an Optional describing the specified streams first element, if present, otherwise returns an empty Optional. Throws a TooManyElementsException if stream contains more than one element.
    This is a terminal operation.
    
    Type Parameters:
    
    T - stream element type
    
    Parameters:
    
    stream - the stream describing the element
    
    Returns:
    
    an Optional describing the specified streams first element, if present, otherwise returns an empty Optional
    
    Throws:
    
    TooManyElementsException - if stream contains more than one element
  - ofSingle
```
public static OptionalInt ofSingle(CharSequence string)
```
    Returns an OptionalInt describing the specified strings first character, if present, otherwise returns an empty OptionalInt. Throws a TooManyElementsException if string contains more than one character, ignoring trailing whitespaces.
    Whitespace characters are recognized using Characters.isAsciiWhitespace(char).
    
    Parameters:
    
    string - the string describing the character
    
    Returns:
    
    an OptionalInt describing the specified strings first character, if present, otherwise returns an empty OptionalInt
    
    Throws:
    
    TooManyElementsException - if string contains more than one character, ignoring trailing whitespaces
  - stream
```
@SafeVarargs
public static <T> Stream<T> stream(Optional<T>... optionals)
```
    Returns a stream consisting of present elements.
    
    Type Parameters:
    
    T - element type
    
    Parameters:
    
    optionals - array of optional elements
    
    Returns:
    
    the new stream

Class Optionals

Method Summary

Methods inherited from class java.lang.Object

Method Detail

comparator

comparator

comparator

flatMapToDouble

flatMapToInt

flatMapToLong

getFirst

getFirst

getFirst

getFirstValue

mapToDouble

mapToDouble

mapToInt

mapToInt

mapToLong

mapToLong

ofNon

ofNonBlank

ofNonEmpty

ofNonEmpty

ofNonEmpty

ofSingle

ofSingle

ofSingle

ofSingle

ofSingle

stream