MapX (cyclops-reactor 9.0.0-FINAL API)

Type Parameters:

K - Key type

V - Value type

All Superinterfaces:

BiTransformable<K,V>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, Filters<org.jooq.lambda.tuple.Tuple2<K,V>>, FluentMapX<K,V>, Folds<org.jooq.lambda.tuple.Tuple2<K,V>>, java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, java.util.Map<K,V>, OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>, OnEmptySwitch<org.jooq.lambda.tuple.Tuple2<K,V>,java.util.Map<K,V>>, org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>, ReactiveStreamsTerminalOperations<org.jooq.lambda.tuple.Tuple2<K,V>>, To<MapX<K,V>>, Transformable<V>, Unwrapable

All Known Implementing Classes:

MapXImpl
```
public interface MapX<K,V>
extends To<MapX<K,V>>, java.util.Map<K,V>, Unwrapable, FluentMapX<K,V>, BiTransformable<K,V>, Transformable<V>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>, OnEmptySwitch<org.jooq.lambda.tuple.Tuple2<K,V>,java.util.Map<K,V>>, org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>, Folds<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
```
An eXtended Map type, that offers additional eagerly executed functional style operators such as bimap, filter and more

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  java.util.Map.Entry<K,V>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default boolean`	`allMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)` True if predicate matches all elements when Monad converted to a Stream
`default boolean`	`anyMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)` True if a singleUnsafe element matches when Monad converted to a Stream
`default <U1,U2> MapX<U1,U2>`	`bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)` Cast two data types simulatanously.
`default <R1,R2> MapX<R1,R2>`	`bimap(java.util.function.Function<? super K,? extends R1> fn1, java.util.function.Function<? super V,? extends R2> fn2)` Transform this BiTransformable, changing two value types at once.
`default MapX<K,V>`	`bipeek(java.util.function.Consumer<? super K> c1, java.util.function.Consumer<? super V> c2)` Peek at two data types simulatanously (typically to perform a side-effect with each data point)
`default <R1,R2> MapX<R1,R2>`	`bitrampoline(java.util.function.Function<? super K,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super V,? extends Trampoline<? extends R2>> mapper2)` Perform a tail-call optimized recursive transformation operation across two data points simultaneously
`default <U> MapX<K,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`defaultCollector()`
`static <K,V> MapX<K,V>`	`empty()`
`default MapX<K,V>`	`filter(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)` Keep only elements for which the supplied predicates hold e.g.
`default MapX<K,V>`	`filterNot(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`default <KR,VR> MapX<KR,VR>`	`flatMap(java.util.function.BiFunction<? super K,? super V,? extends MapX<KR,VR>> fn)`
`static <K,V> MapX<K,V>`	`fromMap(java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> collector, java.util.Map<? extends K,? extends V> map)` Wrap a map in a MapX, also supplying a Collector for use in operations
`static <K,V> MapX<K,V>`	`fromMap(java.util.Map<? extends K,? extends V> map)` Wrap a Map in a MapX
`default MapX<K,V>`	`fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream)` Construct a new MapX with the same collector from the supplied Stream
`<K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`getCollector()`
`static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`immutableCollector()`
`boolean`	`isEmpty()`
`default java.util.Iterator<org.jooq.lambda.tuple.Tuple2<K,V>>`	`iterator()`
`default <R> MapX<K,R>`	`map(java.util.function.Function<? super V,? extends R> fn)` Transform this functor using the supplied transformation function
`default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>>`	`max(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)` Get the maximum value by a function.
`default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>>`	`min(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)` Get the minimum value by a function.
`default MapX<K,V>`	`minus(java.lang.Object key)`
`default MapX<K,V>`	`minusAll(java.util.Collection<?> keys)`
`default boolean`	`noneMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)`
`default MapX<K,V>`	`notNull()` Filter elements retaining only values which are not null
`default MapX<K,V>`	`onEmpty(org.jooq.lambda.tuple.Tuple2<K,V> value)` If this Container instance is zero, create a new instance containing the provided value
`default MapX<K,V>`	`onEmptyGet(java.util.function.Supplier<? extends org.jooq.lambda.tuple.Tuple2<K,V>> supplier)` If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
`default MapX<K,V>`	`onEmptySwitch(java.util.function.Supplier<? extends java.util.Map<K,V>> supplier)` Switch to container created by provided Supplier, if current Container zero
`default <X extends java.lang.Throwable> MapX<K,V>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is zero, throw the exception returned by the provided Supplier
`default MapX<K,V>`	`peek(java.util.function.Consumer<? super V> c)` Peek at the current value of this Transformable, without transforming it
`default MapX<K,V>`	`plus(K key, V value)`
`default MapX<K,V>`	`plusAll(java.util.Map<? extends K,? extends V> map)`
`default MapX<K,V>`	`removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Remove all supplied elements from this filterable
`default MapX<K,V>`	`removeAllI(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Remove all elements in the supplied Iterable from this filterable
`default MapX<K,V>`	`removeAllS(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)` Remove all elements in the supplied Stream from this filterable
`default MapX<K,V>`	`retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Retain only the supplied elements in the returned Filters
`default MapX<K,V>`	`retainAllI(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Retain only the supplied elements in the returned Filters
`default MapX<K,V>`	`retainAllS(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)` Retain only the supplied elements in the returned Filters
`int`	`size()`
`default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>>`	`stream()`
`default void`	`subscribe(org.reactivestreams.Subscriber<? super org.jooq.lambda.tuple.Tuple2<K,V>> s)`
`default <T> DequeX<T>`	`toDequeX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a DequeX via the provided transformation function
`default <T> ListX<T>`	`toListX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a ListX via the provided transformation function
`static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`toMapX()`
`default <T> QueueX<T>`	`toQueueX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a QueueX via the provided transformation function
`default <T> SetX<T>`	`toSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a SetX via the provided transformation function
`default <T> SortedSetX<T>`	`toSortedSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a SortedSetX via the provided transformation function
`default <R> MapX<K,R>`	`trampoline(java.util.function.Function<? super V,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space

Methods inherited from interface com.aol.cyclops2.types.foldable.To
to

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

Methods inherited from interface java.util.Map
clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, keySet, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, values

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable
retry, retry

Methods inherited from interface com.aol.cyclops2.types.Filters
ofType

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, maxBy, minBy, mode, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, toSet, toString, toString

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

Methods inherited from interface com.aol.cyclops2.types.reactive.ReactiveStreamsTerminalOperations
forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe

- Method Detail
  - defaultCollector
```
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> defaultCollector()
```
    Returns:
    
    A Collector that generates a mutable Map from a Collection of Tuple2
  - immutableCollector
```
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> immutableCollector()
```
    Returns:
    
    A Collector that generates an Immutable Map from a Collection of Tuple2
  - toMapX
```
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> toMapX()
```
    Returns:
    
    A Collector that generates a mutable MapX from a Collection of Tuple2
  - getCollector
```
<K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> getCollector()
```
    Returns:
    
    The currently configured Map Collector for this MapX
  - stream
```
default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream()
```
    Specified by:
    
    stream in interface Folds<org.jooq.lambda.tuple.Tuple2<K,V>>
  - empty
```
static <K,V> MapX<K,V> empty()
```
    Returns:
    
    An zero MapX
  - fromMap
```
static <K,V> MapX<K,V> fromMap(java.util.Map<? extends K,? extends V> map)
```
    Wrap a Map in a MapX
    
    Parameters:
    
    map - to wrap
    
    Returns:
    
    MapX wrapping the supplied Map
  - fromMap
```
static <K,V> MapX<K,V> fromMap(java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> collector,
                               java.util.Map<? extends K,? extends V> map)
```
    Wrap a map in a MapX, also supplying a Collector for use in operations
    
    Parameters:
    
    collector - To generate new MapX's from
    
    map - to wrap
    
    Returns:
    
    MapX wrapping the supplied Map
  - fromStream
```
default MapX<K,V> fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream)
```
    Construct a new MapX with the same collector from the supplied Stream
    
    Parameters:
    
    stream - ot Tuples to convert into a MapX
    
    Returns:
    
    MapX
  - iterator
```
default java.util.Iterator<org.jooq.lambda.tuple.Tuple2<K,V>> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - flatMap
```
default <KR,VR> MapX<KR,VR> flatMap(java.util.function.BiFunction<? super K,? super V,? extends MapX<KR,VR>> fn)
```
  - map
```
default <R> MapX<K,R> map(java.util.function.Function<? super V,? extends R> fn)
```
    Description copied from interface: Transformable
    Transform this functor using the supplied transformation function
```
 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 
```
    Specified by:
    
    map in interface Transformable<V>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - bimap
```
default <R1,R2> MapX<R1,R2> bimap(java.util.function.Function<? super K,? extends R1> fn1,
                                  java.util.function.Function<? super V,? extends R2> fn2)
```
    Description copied from interface: BiTransformable
    Transform this BiTransformable, changing two value types at once.
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     MapX<String,Integer> transformedMap = map.bimap(s->s+" world",i->i*4);
     //["hello world",8]
 
 
```
    Specified by:
    
    bimap in interface BiTransformable<K,V>
    
    Parameters:
    
    fn1 - transformation function for the first type
    
    fn2 - transformation function for the second type
    
    Returns:
    
    New BiTransformable containing transformed data
  - size
```
int size()
```
    Specified by:
    
    size in interface java.util.Map<K,V>
  - isEmpty
```
boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<K,V>
  - allMatch
```
default boolean allMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
```
    Description copied from interface: CyclopsCollectable
    True if predicate matches all elements when Monad converted to a Stream
```
  
 assertThat(ReactiveSeq.of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
 
 
```
    Specified by:
    
    allMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    c - Predicate to check if all match
  - anyMatch
```
default boolean anyMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
```
    Description copied from interface: CyclopsCollectable
    True if a singleUnsafe element matches when Monad converted to a Stream
```
  
     ReactiveSeq.of(1,2,3,4,5).anyMatch(it-> it.equals(3))
     //true
 
 
```
    Specified by:
    
    anyMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    c - Predicate to check if any match
  - noneMatch
```
default boolean noneMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
```
    Specified by:
    
    noneMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - max
```
default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>> max(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)
```
    Description copied from interface: CyclopsCollectable
    
    Get the maximum value by a function.
    
    Specified by:
    
    max in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - min
```
default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>> min(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)
```
    Description copied from interface: CyclopsCollectable
    
    Get the minimum value by a function.
    
    Specified by:
    
    min in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - plus
```
default MapX<K,V> plus(K key,
                       V value)
```
    Specified by:
    
    plus in interface FluentMapX<K,V>
  - plusAll
```
default MapX<K,V> plusAll(java.util.Map<? extends K,? extends V> map)
```
    Specified by:
    
    plusAll in interface FluentMapX<K,V>
  - minus
```
default MapX<K,V> minus(java.lang.Object key)
```
    Specified by:
    
    minus in interface FluentMapX<K,V>
  - minusAll
```
default MapX<K,V> minusAll(java.util.Collection<?> keys)
```
    Specified by:
    
    minusAll in interface FluentMapX<K,V>
  - cast
```
default <U> MapX<K,U> cast(java.lang.Class<? extends U> type)
```
    Description copied from interface: Transformable
    
    Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
    
    Specified by:
    
    cast in interface Transformable<V>
  - peek
```
default MapX<K,V> peek(java.util.function.Consumer<? super V> c)
```
    Description copied from interface: Transformable
    Peek at the current value of this Transformable, without transforming it
```
 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 
```
    Specified by:
    
    peek in interface Transformable<V>
    
    Parameters:
    
    c - Consumer that recieves each element from this Transformable
    
    Returns:
    
    Transformable that will peek at each value
  - trampoline
```
default <R> MapX<K,R> trampoline(java.util.function.Function<? super V,? extends Trampoline<? extends R>> mapper)
```
    Description copied from interface: Transformable
    Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);

    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}

 55
    	6765
    	832040
    	102334155


 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);


 completes successfully
 
 
```
    Specified by:
    
    trampoline in interface Transformable<V>
    
    Parameters:
    
    mapper - TCO Transformation function
    
    Returns:
    
    Transformable transformed by the supplied transformation function
  - filter
```
default MapX<K,V> filter(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)
```
    Description copied from interface: Filters
    Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
    Specified by:
    
    filter in interface Filters<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - filterNot
```
default MapX<K,V> filterNot(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)
```
    Description copied from interface: Filters
    Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
    Specified by:
    
    filterNot in interface Filters<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - notNull
```
default MapX<K,V> notNull()
```
    Description copied from interface: Filters
    Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 
```
    Specified by:
    
    notNull in interface Filters<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    Filters with nulls removed
  - removeAllS
```
default MapX<K,V> removeAllS(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)
```
    Description copied from interface: IterableFilterable
    
    Remove all elements in the supplied Stream from this filterable
    
    Specified by:
    
    removeAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    stream - of elements to remove
    
    Returns:
    
    Filters with all supplied elements removed
  - removeAllI
```
default MapX<K,V> removeAllI(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)
```
    Description copied from interface: IterableFilterable
    
    Remove all elements in the supplied Iterable from this filterable
    
    Specified by:
    
    removeAllI in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    it - an Iterable of elements to remove
    
    Returns:
    
    Filters with all supplied elements removed
  - removeAll
```
default MapX<K,V> removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Remove all supplied elements from this filterable
    
    Specified by:
    
    removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    values - to remove
    
    Returns:
    
    Filters with all supplied values removed
  - retainAllI
```
default MapX<K,V> retainAllI(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filters
    
    Specified by:
    
    retainAllI in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    it - Iterable of elements to retain
    
    Returns:
    
    Filters with supplied values retained, and others removed
  - retainAllS
```
default MapX<K,V> retainAllS(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filters
    
    Specified by:
    
    retainAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    stream - of elements to retain
    
    Returns:
    
    Filters with supplied values retained, and others removed
  - retainAll
```
default MapX<K,V> retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filters
    
    Specified by:
    
    retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    values - elements to retain
    
    Returns:
    
    Filters with supplied values retained, and others removed
  - bipeek
```
default MapX<K,V> bipeek(java.util.function.Consumer<? super K> c1,
                         java.util.function.Consumer<? super V> c2)
```
    Description copied from interface: BiTransformable
    Peek at two data types simulatanously (typically to perform a side-effect with each data point)
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
 
 
```
    Specified by:
    
    bipeek in interface BiTransformable<K,V>
    
    Parameters:
    
    c1 - consumer for the first type
    
    c2 - consumer for the second type
    
    Returns:
    
    New BiTransformable with the same data
  - bicast
```
default <U1,U2> MapX<U1,U2> bicast(java.lang.Class<U1> type1,
                                   java.lang.Class<U2> type2)
```
    Description copied from interface: BiTransformable
    Cast two data types simulatanously.
```
 
     MapX<Animal,Food> map = MapXs.of(cow,grass);
     MapX<Mamaml,Vegitation> herbervoreMammals = map.bicast(Mammal.class,Vegitation.class);
 
 
```
    Specified by:
    
    bicast in interface BiTransformable<K,V>
    
    Returns:
  - bitrampoline
```
default <R1,R2> MapX<R1,R2> bitrampoline(java.util.function.Function<? super K,? extends Trampoline<? extends R1>> mapper1,
                                         java.util.function.Function<? super V,? extends Trampoline<? extends R2>> mapper2)
```
    Description copied from interface: BiTransformable
    
    Perform a tail-call optimized recursive transformation operation across two data points simultaneously
    
    Specified by:
    
    bitrampoline in interface BiTransformable<K,V>
    
    Parameters:
    
    mapper1 - transformation function for the first type
    
    mapper2 - transformation function for the second type
    
    Returns:
    
    New BiTransformable containing transformed data
  - subscribe
```
default void subscribe(org.reactivestreams.Subscriber<? super org.jooq.lambda.tuple.Tuple2<K,V>> s)
```
    Specified by:
    
    subscribe in interface org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>
  - onEmpty
```
default MapX<K,V> onEmpty(org.jooq.lambda.tuple.Tuple2<K,V> value)
```
    Description copied from interface: OnEmpty
    
    If this Container instance is zero, create a new instance containing the provided value
    
    Specified by:
    
    onEmpty in interface OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    New instance containing value if container is zero, otherwise returns this container
  - onEmptyGet
```
default MapX<K,V> onEmptyGet(java.util.function.Supplier<? extends org.jooq.lambda.tuple.Tuple2<K,V>> supplier)
```
    Description copied from interface: OnEmpty
    
    If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
    
    Specified by:
    
    onEmptyGet in interface OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    supplier - to determine new value for container
    
    Returns:
    
    New Container with value if this is zero, otherwise this container
  - onEmptyThrow
```
default <X extends java.lang.Throwable> MapX<K,V> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
    Description copied from interface: OnEmpty
    
    If this container instance is zero, throw the exception returned by the provided Supplier
    
    Specified by:
    
    onEmptyThrow in interface OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    supplier - to create exception from
    
    Returns:
    
    Throw exception if zero, otherwise this container
  - onEmptySwitch
```
default MapX<K,V> onEmptySwitch(java.util.function.Supplier<? extends java.util.Map<K,V>> supplier)
```
    Description copied from interface: OnEmptySwitch
    Switch to container created by provided Supplier, if current Container zero
```
  
     ListX.zero().onEmptySwitch(()->ListX.of(1));
  
 
```
    Specified by:
    
    onEmptySwitch in interface OnEmptySwitch<org.jooq.lambda.tuple.Tuple2<K,V>,java.util.Map<K,V>>
    
    Parameters:
    
    supplier - to create replacement container
    
    Returns:
    
    Either this container or if zero, an alternative returned by the provided supplier
  - toListX
```
default <T> ListX<T> toListX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a ListX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    ListX of transformed values
  - toSetX
```
default <T> SetX<T> toSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a SetX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    SetX of transformed values
  - toSortedSetX
```
default <T> SortedSetX<T> toSortedSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a SortedSetX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    SortedSetX of transformed values
  - toQueueX
```
default <T> QueueX<T> toQueueX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a QueueX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    QueueX of transformed values
  - toDequeX
```
default <T> DequeX<T> toDequeX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a DequeX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    DequeX of transformed values

Interface MapX<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Method Summary

Methods inherited from interface com.aol.cyclops2.types.foldable.To

Methods inherited from interface com.aol.cyclops2.types.Unwrapable

Methods inherited from interface java.util.Map

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable

Methods inherited from interface com.aol.cyclops2.types.Filters

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds

Methods inherited from interface com.aol.cyclops2.types.reactive.ReactiveStreamsTerminalOperations

Method Detail

defaultCollector

immutableCollector

toMapX

getCollector

stream

empty

fromMap

fromMap

fromStream

iterator

flatMap

map

bimap

size

isEmpty

allMatch

anyMatch

noneMatch

max

min

plus

plusAll

minus

minusAll

cast

peek

trampoline

filter

filterNot

notNull

removeAllS

removeAllI

removeAll

retainAllI

retainAllS

retainAll

bipeek

bicast

bitrampoline

subscribe

onEmpty

onEmptyGet

onEmptyThrow

onEmptySwitch

toListX

toSetX

toSortedSetX

toQueueX

toDequeX