com.aol.cyclops.data.collections.extensions.standard

Interface MapX<K,V>

All Superinterfaces:

BiFunctor<K,V>, org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>, ConvertableSequence<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, ExtendedTraversable<org.jooq.lambda.tuple.Tuple2<K,V>>, Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>, FluentMapX<K,V>, Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>, Functor<V>, java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>>, IterableCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, java.util.Map<K,V>, Traversable<org.jooq.lambda.tuple.Tuple2<K,V>>

All Known Implementing Classes:

MapXImpl

public interface MapX<K,V>
extends java.util.Map<K,V>, FluentMapX<K,V>, BiFunctor<K,V>, Functor<V>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, ExtendedTraversable<org.jooq.lambda.tuple.Tuple2<K,V>>, Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, IterableCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>

Nested Class Summary

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

java.util.Map.Entry<K,V>

Method Summary

Modifier and Type	Method and Description
default boolean	allMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
default boolean	anyMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c) True if a single element matches when Monad converted to a Stream
default <R1,R2> BiFunctor<R1,R2>	bimap(java.util.function.Function<? super K,? extends R1> fn1, java.util.function.Function<? super V,? extends R2> fn2)
default <U> MapX<K,U>	cast(java.lang.Class<U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
default org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>	collectable() Narrow this class to a Collectable
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>	defaultCollector()
default MapX<K,V>	filter(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)
default MapX<K,V>	filterNot(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)
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> it)
static <K,V> MapX<K,V>	fromMap(java.util.Map<? extends K,? extends V> it)
default MapX<K,V>	fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> 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()
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)
default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>>	max(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)
default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>>	min(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)
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()
default MapX<K,V>	peek(java.util.function.Consumer<? super V> c)
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(java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>> it)
default MapX<K,V>	removeAll(java.util.stream.Stream<org.jooq.lambda.tuple.Tuple2<K,V>> stream)
default MapX<K,V>	removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
default MapX<K,V>	removeMatches(<any> m)
default MapX<K,V>	retainAll(java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>> it)
default MapX<K,V>	retainAll(java.util.stream.Stream<org.jooq.lambda.tuple.Tuple2<K,V>> stream)
default MapX<K,V>	retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
default MapX<K,V>	retainMatches(<any> m)
int	size()
default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>>	stream()
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>	toMapX()
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 java.util.Map

clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, values

Methods inherited from interface com.aol.cyclops.types.BiFunctor

bicast, bipeek, bitrampoline

Methods inherited from interface com.aol.cyclops.types.Functor

patternMatch

Methods inherited from interface com.aol.cyclops.types.Filterable

ofType

Methods inherited from interface com.aol.cyclops.types.ExtendedTraversable

combinations, combinations, permutations

Methods inherited from interface com.aol.cyclops.types.Traversable

cycle, cycle, cycleUntil, cycleWhile, distinct, dropRight, dropUntil, dropWhile, endsWith, endsWithIterable, findAny, findFirst, firstValue, futureOperations, get, groupBy, grouped, grouped, grouped, grouped, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, headAndTail, intersperse, join, join, join, lazyOperations, limit, limitLast, limitUntil, limitWhile, onEmpty, onEmptyGet, onEmptyThrow, reverse, scanLeft, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, shuffle, shuffle, single, single, singleOptional, skip, skipLast, skipUntil, skipWhile, slice, sliding, sliding, sorted, sorted, sorted, startsWith, startsWithIterable, takeRight, takeUntil, takeWhile, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, visit, visit, zip, zip, zip3, zip4, zipStream, zipWithIndex

Methods inherited from interface com.aol.cyclops.types.Foldable

foldRight, foldRight, foldRightMapToType, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence

seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable

avg, avg, avgDouble, avgInt, avgLong, collect, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, minBy, minBy, mode, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable

collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

Methods inherited from interface com.aol.cyclops.types.IterableCollectable

xMatch

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()

immutableCollector

static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> immutableCollector()

toMapX

static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> toMapX()

getCollector

<K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> getCollector()

stream

default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream()

Specified by:

stream in interface ConvertableSequence<org.jooq.lambda.tuple.Tuple2<K,V>>

Specified by:

stream in interface Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>

Specified by:

stream in interface IterableCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>

Specified by:

stream in interface Traversable<org.jooq.lambda.tuple.Tuple2<K,V>>

fromMap

static <K,V> MapX<K,V> fromMap(java.util.Map<? extends K,? extends V> it)

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> it)

fromStream

default MapX<K,V> fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream)

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

collectable

default org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>> collectable()

Description copied from interface: CyclopsCollectable

Narrow this class to a Collectable

Specified by:

collectable in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>

Returns:

Collectable

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)

Specified by:

map in interface Functor<V>

bimap

default <R1,R2> BiFunctor<R1,R2> bimap(java.util.function.Function<? super K,? extends R1> fn1,
                                       java.util.function.Function<? super V,? extends R2> fn2)

Specified by:

bimap in interface BiFunctor<K,V>

size

int size()

Specified by:

size in interface java.util.Map<K,V>

allMatch

default boolean allMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)

Specified by:

allMatch in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>

Specified by:

allMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>

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 single element matches when Monad converted to a Stream

  
 assertThat(ReactiveSeq.of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
 
 

Specified by:

anyMatch in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>

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 org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>

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)

Specified by:

max in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>

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)

Specified by:

min in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>

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<U> type)

Description copied from interface: Functor

Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Functor<V>

peek

default MapX<K,V> peek(java.util.function.Consumer<? super V> c)

Specified by:

peek in interface Functor<V>

trampoline

default <R> MapX<K,R> trampoline(java.util.function.Function<? super V,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Functor

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 Functor<V>

Returns:

filter

default MapX<K,V> filter(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)

Specified by:

filter in interface Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>

filterNot

default MapX<K,V> filterNot(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)

Specified by:

filterNot in interface Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>

notNull

default MapX<K,V> notNull()

Specified by:

notNull in interface Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>

removeAll

default MapX<K,V> removeAll(java.util.stream.Stream<org.jooq.lambda.tuple.Tuple2<K,V>> stream)

Specified by:

removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

removeAll

default MapX<K,V> removeAll(java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>> it)

Specified by:

removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

removeAll

default MapX<K,V> removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)

Specified by:

removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

retainAll

default MapX<K,V> retainAll(java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>> it)

Specified by:

retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

retainAll

default MapX<K,V> retainAll(java.util.stream.Stream<org.jooq.lambda.tuple.Tuple2<K,V>> stream)

Specified by:

retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

retainAll

default MapX<K,V> retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)

Specified by:

retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

retainMatches

default MapX<K,V> retainMatches(<any> m)

Specified by:

retainMatches in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>

removeMatches

default MapX<K,V> removeMatches(<any> m)

Specified by:

removeMatches in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>