de.caff.generics

Class Types

java.lang.Object

de.caff.generics.Types

public final class Types
extends java.lang.Object

Tool with helpful methods for type conversion.

Have a look at package generics to get an overview.

Author:

Rammi

Field Summary

Fields

Modifier and Type	Field and Description
static java.util.Comparator<? extends java.lang.Comparable>	COMPARABLE_COMPARATOR Comparator which compares Comparables in their natural order.
static PrimitiveBooleanIterator	EMPTY_BOOLEAN_ITERATOR Empty primitive boolean iterator.
static PrimitiveByteIterator	EMPTY_BYTE_ITERATOR Empty primitive byte iterator.
static PrimitiveCharIterator	EMPTY_CHAR_ITERATOR Empty primitive char iterator.
static java.util.PrimitiveIterator.OfDouble	EMPTY_DOUBLE_ITERATOR Empty primitve double iterator.
static PrimitiveFloatIterator	EMPTY_FLOAT_ITERATOR Empty primitive float iterator.
static int	EMPTY_HASH Hash value for empty collections.
static java.util.PrimitiveIterator.OfInt	EMPTY_INT_ITERATOR Empty primitive int iterator.
static java.util.PrimitiveIterator.OfLong	EMPTY_LONG_ITERATOR Empty primitive long iterator.
static PrimitiveShortIterator	EMPTY_SHORT_ITERATOR Empty primitive short iterator.
static Predicate1<java.lang.Object>	NOT_NULL Predicate for filtering out null objects.
static Function1<java.lang.Byte,java.lang.Number>	NUMBER_TO_BYTE A type converter allowing any number based type to be converted to a byte value.
static Function1<java.lang.Double,java.lang.Number>	NUMBER_TO_DOUBLE A type converter allowing any number based type to be converted to double.
static Function1<java.lang.Float,java.lang.Number>	NUMBER_TO_FLOAT A type converter allowing any number based type to be converted to float.
static Function1<java.lang.Integer,java.lang.Number>	NUMBER_TO_INT A type converter allowing any number based type to be converted to integer.
static Function1<java.lang.Long,java.lang.Number>	NUMBER_TO_LONG A type converter allowing any number based type to be converted to long.
static Function1<java.lang.Short,java.lang.Number>	NUMBER_TO_SHORT A type converter allowing any number based type to be converted to short integer.
static java.lang.String	RELEASE_DATE Deprecated. Use ModuleVersion.VERSION instead, or ModuleVersionService.iterator()/ModuleVersionService.collectServices() for all modules
static Function1<java.lang.Boolean,java.lang.String>	STR_TO_BOOLEAN A converter which converts strings to boolean values.
static FragileTypeConverter<java.lang.Byte,java.lang.String>	STR_TO_BYTE A converter which converts strings to byte values, using base 10.
static FragileTypeConverter<java.lang.Byte,java.lang.String>	STR_TO_BYTE_BASE_16 A converter which converts strings to byte values, using base 16.
static FragileTypeConverter<java.lang.Byte,java.lang.String>	STR_TO_BYTE_BASE_2 A converter which converts strings to byte values, using base 2.
static FragileTypeConverter<java.lang.Byte,java.lang.String>	STR_TO_BYTE_BASE_8 A converter which converts strings to byte values, using base 8.
static FragileTypeConverter<java.lang.Double,java.lang.String>	STR_TO_DOUBLE A converter which converts strings (in Java number format) to double values.
static FragileTypeConverter<java.lang.Float,java.lang.String>	STR_TO_FLOAT A converter which converts strings (in Java number format) to float values.
static FragileTypeConverter<java.lang.Integer,java.lang.String>	STR_TO_INT A converter which converts strings to integer, using base 10.
static FragileTypeConverter<java.lang.Integer,java.lang.String>	STR_TO_INT_BASE_16 A converter which converts strings to integer, using base 16.
static FragileTypeConverter<java.lang.Integer,java.lang.String>	STR_TO_INT_BASE_2 A converter which converts strings to integer, using base 2.
static FragileTypeConverter<java.lang.Integer,java.lang.String>	STR_TO_INT_BASE_8 A converter which converts strings to integer, using base 8.
static FragileTypeConverter<java.lang.Long,java.lang.String>	STR_TO_LONG A converter which converts strings to long integer, using base 10.
static FragileTypeConverter<java.lang.Long,java.lang.String>	STR_TO_LONG_BASE_16 A converter which converts strings to long integer, using base 16.
static FragileTypeConverter<java.lang.Long,java.lang.String>	STR_TO_LONG_BASE_2 A converter which converts strings to long integer, using base 2.
static FragileTypeConverter<java.lang.Long,java.lang.String>	STR_TO_LONG_BASE_8 A converter which converts strings to long integer, using base 8.
static Function1<java.lang.String,java.lang.String>	STR_TO_LOWER A converter which changes strings to lowercase.
static FragileTypeConverter<java.lang.Short,java.lang.String>	STR_TO_SHORT A converter which converts strings to short integer, using base 10.
static FragileTypeConverter<java.lang.Short,java.lang.String>	STR_TO_SHORT_BASE_16 A converter which converts strings to short integer, using base 16.
static FragileTypeConverter<java.lang.Short,java.lang.String>	STR_TO_SHORT_BASE_2 A converter which converts strings to short integer, using base 2.
static FragileTypeConverter<java.lang.Short,java.lang.String>	STR_TO_SHORT_BASE_8 A converter which converts strings to short integer, using base 8.
static Function1<java.lang.String,java.lang.String>	STR_TO_UPPER A converter which changes strings to uppercase.
static Function1<java.lang.String,java.lang.Object>	TO_STRING A type converter which converts any object into its toString() representation.
static java.util.Comparator<?>	TO_STRING_COMPARATOR Comparator which compares the toString() representation.
static java.util.Comparator<?>	TO_STRING_IGNORE_CASE_COMPARATOR Comparator which compares the toString() representation in case-insensitive order.
static java.lang.String	VERSION Deprecated. use ModuleVersion.VERSION instead
static Function1<java.util.List<java.lang.String>,java.lang.String>	WORD_SPLIT A converter which splits strings into words.

Method Summary

Modifier and Type	Method and Description
static <C extends java.util.Collection<T>,T> C	addAll(C collection, java.util.Enumeration<? extends T> enumeration) Add all elements of an enumeration to a collection.
static <C extends java.util.Collection<T>,T> C	addAll(C collection, java.lang.Iterable<? extends T> iterable) Add all elements of an iterable to a collection.
static <C extends java.util.Collection<T>,T> C	addAll(C collection, java.util.Iterator<? extends T> iterator) Add all elements of an iterator to a collection.
static <C extends java.util.Collection<? super T>,T> C	addAll(C collection, T... elements) Add all elements to a collection.
static <C extends java.util.Collection<T>,T> C	addEnumeration(C collection, java.util.Enumeration<? extends T> enumeration) Deprecated. Use addAll(Collection, Enumeration) instead
static <C extends java.util.Collection<T>,T> C	addIterable(C collection, java.lang.Iterable<? extends T> iterable) Deprecated. Use addAll(Collection, Iterable) instead
static <C extends java.util.Collection<T>,T> C	addIterator(C collection, java.util.Iterator<? extends T> iterator) Deprecated. Use addAll(Collection, Iterator) instead
static <T> boolean	all(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker) Does every element of the enumeration fulfill the predicate?
static <T> boolean	all(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker) Does every element in the iterable fulfill the predicate?
static <T> boolean	all(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker) Does every element of the iterator fulfill the predicate?
static <T> boolean	all(T[] array, java.util.function.Predicate<? super T> checker) Does every element in the array fulfill the predicate?
static <T> boolean	any(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker) Does any element of the enumeration fulfill the predicate?
static <T> boolean	any(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker) Does any element in the iterable fulfill the predicate?
static <T> boolean	any(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker) Does any element of the iterator fulfill the predicate?
static <T> boolean	any(T[] array, java.util.function.Predicate<? super T> checker) Does any element in the array fulfill the predicate?
static <T1,T2> boolean	areEqual(java.util.Collection<T1> c1, java.util.Collection<T2> c2) Are two collections equal?
static <T1,T2> boolean	areEqual(java.util.Collection<T1> c1, java.util.Collection<T2> c2, java.util.function.BiPredicate<? super T1,? super T2> matcher) Are two collections equal?
static <T1,T2> boolean	areEqual(Countable<T1> c1, Countable<T2> c2) Are two countables equal?
static <T1,T2> boolean	areEqual(Countable<T1> c1, Countable<T2> c2, java.util.function.BiPredicate<? super T1,? super T2> matcher) Are two countables equal?
static <T1,T2> boolean	areEqual(java.util.Enumeration<T1> en1, java.util.Enumeration<T2> en2) Are two enumerators equal?
static <T1,T2> boolean	areEqual(java.util.Enumeration<T1> en1, java.util.Enumeration<T2> en2, java.util.function.BiPredicate<? super T1,? super T2> matcher) Are two enumerators equal?
static <T1,T2> boolean	areEqual(java.lang.Iterable<T1> it1, java.lang.Iterable<T2> it2) Are two iterables equal?
static <T1,T2> boolean	areEqual(java.lang.Iterable<T1> it1, java.lang.Iterable<T2> it2, java.util.function.BiPredicate<? super T1,? super T2> matcher) Are two iterables equal?
static <T1,T2> boolean	areEqual(java.util.Iterator<T1> it1, java.util.Iterator<T2> it2) Are two iterations equal?
static <T1,T2> boolean	areEqual(java.util.Iterator<T1> it1, java.util.Iterator<T2> it2, java.util.function.BiPredicate<? super T1,? super T2> matcher) Are two iterations equal?
static <T1,T2> boolean	areEqual(T1[] arr1, T2[] arr2) Are two arrays equal?
static <T1,T2> boolean	areEqual(T1[] arr1, T2[] arr2, java.util.function.BiPredicate<? super T1,? super T2> matcher) Are two arrays equal?
static <T> T	as(java.lang.Class<T> type, java.lang.Object obj) Cast an item to a given type if possible.
static <T> java.util.List<T>	asList(T... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static <T> java.util.List<T>	asList(T[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static <T> java.util.List<T>	asList(T[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static <T,S> FragileTypeConverter<T,S>	asTypeConverter(FragileFunction1<T,? extends java.lang.Exception,S> function) Use a fragile function with 1 argument as a type converter.
static <S> PrimitiveBooleanIterable	booleanView(java.lang.Iterable<S> sourceIterable, java.util.function.Predicate<? super S> booleanMapper) View a generic iterable as if it is an iterable of primitive boolean values.
static <S> PrimitiveBooleanIterator	booleanView(java.util.Iterator<S> sourceIterator, java.util.function.Predicate<? super S> booleanMapper) View a generic iterator as if it is an iterator for primitive boolean values.
static <S> PrimitiveByteIterable	byteView(java.lang.Iterable<S> sourceIterable, ToByteFunction<? super S> byteMapper) View a generic iterable as if it is an iterable of primitive byte values.
static <S> PrimitiveByteIterator	byteView(java.util.Iterator<S> sourceIterator, ToByteFunction<? super S> byteMapper) View a generic iterator as if it is an iterator for primitive byte values.
static <T> java.util.Enumeration<T>	cast(java.util.Enumeration<? extends T> enumeration) Get a casted enumeration.
static <T> java.lang.Iterable<T>	cast(java.lang.Iterable<?> iterable) Get a casted iterable.
static <T> java.util.Iterator<T>	cast(java.util.Iterator<?> iterator) Get a casted iterator.
static <T,S> Function1<T,S>	castConverter() A converter which converts a type to a any other type by applying a cast.
static <S> PrimitiveCharIterable	charView(java.lang.Iterable<S> sourceIterable, ToCharFunction<? super S> charMapper) View a generic iterable as if it is an iterable of primitive char values.
static <S> PrimitiveCharIterator	charView(java.util.Iterator<S> sourceIterator, ToCharFunction<? super S> charMapper) View a generic iterator as if it is an iterator for primitive char values.
static <T> java.util.ArrayList<T>	clone(java.util.Collection<T> sourceCollection, java.util.function.Function<T,T> cloner) Clone a collection.
static <T> java.util.ArrayList<T>	clone(Countable<T> sourceCountable, java.util.function.Function<T,T> cloner) Clone a countable.
static <T,I,S> Function1<T,S>	combine(java.util.function.Function<I,T> secondStep, java.util.function.Function<S,? extends I> firstStep) Get a combined type converter using an intermediate value.
static <T,I,S> FragileTypeConverter<T,S>	combineEE(FragileTypeConverter<T,I> secondStep, FragileTypeConverter<? extends I,S> firstStep) Get a combined type converter using an intermediate value.
static <T,I,S> FragileTypeConverter<T,S>	combineEF(FragileTypeConverter<T,I> secondStep, java.util.function.Function<S,? extends I> firstStep) Get a combined type converter using an intermediate value.
static <T,I,S> FragileTypeConverter<T,S>	combineFE(java.util.function.Function<I,T> secondStep, FragileTypeConverter<? extends I,S> firstStep) Get a combined type converter using an intermediate value.
static <T> java.lang.Iterable<T>	concat(java.lang.Iterable<? extends T>... iterables) Concatenate some iterables to a combined iterable.
static <T> java.util.Iterator<T>	concat(java.util.Iterator<? extends T>... iterators) Concatenate some iterators.
static <T> java.lang.Iterable<T>	concatIterables(java.lang.Iterable<? extends java.lang.Iterable<? extends T>> iterables) Concatenate some iterables to a combined iterable.
static <T> java.util.Iterator<T>	concatIterators(java.lang.Iterable<? extends java.util.Iterator<? extends T>> iterators) Concatenate some iterators.
static <T,E> boolean	contains(java.util.Enumeration<T> enumeration, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Is an element contained in an enumeration?
static <T,E> boolean	contains(java.lang.Iterable<T> iterable, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Is an element contained in an iterable?
static <T,E> boolean	contains(java.util.Iterator<T> iterator, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Is an element contained in an iterator?
static <T,E> boolean	contains(T[] array, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Is an element contained in an array?
static <T> boolean	containsAny(java.util.Collection<T> set, java.lang.Iterable<? extends T> possibleElements) Check whether any of a bunch of elements is contained in a collection.
static <T> boolean	containsEquals(java.lang.Iterable<T> collection, T element) Test whether a collection contains an element which is equal to another element.
static <T extends Copyable<T>,C extends java.util.Collection<T>> C	copy(C target, java.util.Enumeration<T> enumeration) Get a copy of an enumeration while copying the content.
static <T extends Copyable<T>,C extends java.util.Collection<T>> C	copy(C target, java.lang.Iterable<T> iterable) Get a copy of an iterable, while copying the content.
static <T extends Copyable<T>,C extends java.util.Collection<T>> C	copy(C target, java.util.Iterator<T> iterator) Get a copy of an iterator while copying the content.
static <T extends Copyable<T>> java.util.ArrayList<T>	copy(java.util.Collection<T> collection) Get a copy of a collection, while copying the content.
static <T extends Copyable<T>> java.util.ArrayList<T>	copy(Countable<T> countable) Get a copy of a countable, while copying the content.
static <T extends Copyable<T>,C extends java.util.Collection<T>> C	copy(C target, T[] array) Get a copy of an array, while copying the content.
static <T extends Copyable<T>> java.util.LinkedList<T>	copy(java.util.Enumeration<T> enumeration) Get a copy of an enumeration, while copying the content.
static <T extends Copyable<T>> java.util.ArrayList<T>	copy(Indexable<T> indexable) Get a copy of a indexable, while copying the content.
static <T extends Copyable<T>> java.util.LinkedList<T>	copy(java.lang.Iterable<T> iterable) Get a copy of an iterable, while copying the content.
static <T extends Copyable<T>> java.util.LinkedList<T>	copy(java.util.Iterator<T> iterator) Get a copy of an iterator, while copying the content.
static <T extends Copyable<T>> java.util.ArrayList<T>	copy(T[] array) Get a copy of an array, while copying the content.
static <T,S> TwoWayTypeConverter<T,S>	createTwoWay(java.util.function.Function<S,T> toConverter, java.util.function.Function<T,S> backConverter) Create a two way type converter from two one way type converters.
static <S> PrimitiveDoubleIterable	doubleView(java.lang.Iterable<S> sourceIterable, java.util.function.ToDoubleFunction<? super S> doubleMapper) View a generic iterable as if it is an iterable of primitive double values.
static <S> java.util.PrimitiveIterator.OfDouble	doubleView(java.util.Iterator<S> sourceIterator, java.util.function.ToDoubleFunction<? super S> doubleMapper) View a generic iterator as if it is an iterator for primitive double values.
static <T> java.util.Enumeration<T>	downCast(java.util.Enumeration<? extends T> enumeration) Get a down-casted enumeration.
static <T,S> java.util.function.Function<S,T>	downCast(java.util.function.Function<? super S,? extends T> typeConverter) Downcast a type converter.
static <T> java.lang.Iterable<T>	downCast(java.lang.Iterable<? extends T> iterable) Get a down-casted iterable.
static <T> java.util.Iterator<T>	downCast(java.util.Iterator<? extends T> iterator) Get a down-casted iterator.
static <T,S> FragileTypeConverter<T,S>	downCastT(FragileTypeConverter<? extends T,? super S> typeConverter) Downcast a type converter.
static <T,S extends T> Function1<T,S>	downConverter() A converter which converts a type to a more basic type.
static <T> java.util.Enumeration<T>	emptyEnumeration() Return an empty enumeration which does not iterate.
static <T> java.lang.Iterable<T>	emptyIterable() Return an empty iterable which does not iterate.
static <T> java.util.Iterator<T>	emptyIterator() Return an empty iterator which does not iterate.
static <T> java.util.ListIterator<T>	emptyListIterator() Return an empty list iterator which does not iterate.
static <T,C extends java.util.Collection<? super T>> C	extract(C target, java.util.Enumeration<?> enumeration, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T,C extends java.util.Collection<? super T>> C	extract(C target, java.lang.Iterable<?> iterable, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T,C extends java.util.Collection<? super T>> C	extract(C target, java.util.Iterator<?> iterator, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T,C extends java.util.Collection<? super T>> C	extract(C target, java.lang.Object[] array, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T> java.util.LinkedList<T>	extract(java.util.Enumeration<?> enumeration, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T> java.util.LinkedList<T>	extract(java.lang.Iterable<?> iterable, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T> java.util.LinkedList<T>	extract(java.util.Iterator<?> iterator, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T> java.util.LinkedList<T>	extract(java.lang.Object[] array, java.lang.Class<T> targetType) Extract all elements of a given type.
static <T1,T2> java.util.function.BiPredicate<T1,T2>	falseBiPredicate() Return a bi-predicate which returns always false.
static <T> java.util.function.Predicate<T>	falsePredicate() Return a predicate which returns always false.
static <T> void	fillArray(T[] array, int start, int length, java.util.function.Supplier<? extends T> supplier) Fill part of an array with elements provided by a supplier.
static <T> void	fillArray(T[] array, java.util.function.Supplier<? extends T> supplier) Fill an array with elements provided by a supplier.
static <T> void	fillTight(java.util.ArrayList<T> list, java.util.Collection<? extends T> elements) Fill an array list with a number of alements.
static <T,S> void	fillTight(java.util.ArrayList<T> list, java.util.Collection<S> elements, java.util.function.Function<? super S,? extends T> mapper) Fill an array list with a number of elements.
static <T> void	fillTight(java.util.ArrayList<T> list, Countable<? extends T> elements) Fill an array list with a number of alements.
static <T,S> void	fillTight(java.util.ArrayList<T> list, Countable<S> elements, java.util.function.Function<? super S,? extends T> mapper) Fill an array list with a number of elements.
static <T> void	fillTight(java.util.ArrayList<T> list, java.lang.Iterable<? extends T> elements) Fill an array list with a number of alements.
static <T,S> void	fillTight(java.util.ArrayList<T> list, java.lang.Iterable<S> elements, java.util.function.Function<? super S,? extends T> mapper) Fill an array list with a number of elements.
static <C extends java.util.Collection<? super T>,T> C	filter(C target, java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker) Filter the elements of an enumeration into a collection.
static <C extends java.util.Collection<? super T>,T> C	filter(C target, java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker) Filter the elements of an iterable into a collection.
static <C extends java.util.Collection<? super T>,T> C	filter(C target, java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker) Filter the elements of an iterator into a collection.
static <C extends java.util.Collection<? super T>,T> C	filter(C target, T[] array, java.util.function.Predicate<? super T> filter) Filter the elements of an array into a collection.
static <T> java.util.LinkedList<T>	filter(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> checker) Filter the elements of an enumeration into a result list.
static <T> java.util.LinkedList<T>	filter(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker) Filter the elements of an iterable into a collection.
static <T> java.util.LinkedList<T>	filter(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> checker) Filter the elements of an iterator into a collection.
static <T> java.util.LinkedList<T>	filter(T[] array, java.util.function.Predicate<? super T> checker) Filter the elements of an array into a collection.
static <T> boolean	filterOut(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> outCheck) Filter a modifiable iterable inline.
static <K,V> java.util.Set<java.util.Map.Entry<K,V>>	findAllEntries(java.util.Map<K,V> map, Predicate2<? super K,? super V> entryChecker) Return all entries which which the given checker accepts.
static <K,V> java.util.Map.Entry<K,V>	findAnyEntry(java.util.Map<K,V> map, Predicate2<? super K,? super V> entryChecker) Find the first entry in a map which the given entry checker accepts.
static <K,V> K	findAnyKey(java.util.Map<K,V> map, java.util.function.Predicate<? super V> valueChecker) Find the first key in a map which the given value checker accepts.
static <T> T	findFirst(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> check) Find the first element which fulfills the given check.
static <T> int	findFirstEqual(java.lang.Iterable<T> collection, T element) Find the first element in an collection which is equal to another element.
static <T,E> int	findFirstMatch(java.lang.Iterable<T> collection, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Find the first element in a collection which is matching another element.
static <T> T	findNext(java.util.Enumeration<T> enumeration, java.util.function.Predicate<? super T> check) Find the nect element which fulfils the given check.
static <T> T	findNext(java.util.Iterator<T> iterator, java.util.function.Predicate<? super T> check) Find the nect element which fulfils the given check.
static <T> T	first(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker) Get the first element which fulfills a check.
static <T> java.util.LinkedList<T>	flatten(java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections) Flatten a collection of collections.
static <T,R extends java.util.Collection<? super T>> R	flatten(R target, java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections) Flatten a collection of collections.
static <S> PrimitiveFloatIterable	floatView(java.lang.Iterable<S> sourceIterable, ToFloatFunction<? super S> floatMapper) View a generic iterable as if it is an iterable of primitive float values.
static <S> PrimitiveFloatIterator	floatView(java.util.Iterator<S> sourceIterator, ToFloatFunction<? super S> floatMapper) View a generic iterator as if it is an iterator for primitive float values.
static <V,T> V	foldLeft(java.util.Enumeration<T> enumeration, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do left-associative folding of an enumeration.
static <V,T> V	foldLeft(java.lang.Iterable<T> iterable, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do left-associative folding of an iterable.
static <V,T> V	foldLeft(java.util.Iterator<T> iterator, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do left-associative folding of an iterator.
static <V,T> V	foldLeft(T[] array, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do left-associative folding of an array.
static <V,T> V	foldRight(java.util.Enumeration<T> enumeration, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do right-associative folding of an enumeration.
static <V,T> V	foldRight(java.lang.Iterable<T> iterable, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do right-associative folding of an iterable.
static <V,T> V	foldRight(java.util.Iterator<T> iterator, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do right-associative folding of an iteration.
static <V,T> V	foldRight(java.util.List<T> list, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do right-associative folding of a list.
static <V,T> V	foldRight(java.util.ListIterator<T> reverseIterator, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do right-associative folding of a list iterator using it in reverse direction.
static <V,T> V	foldRight(T[] array, V initialValue, java.util.function.BiFunction<? super V,? super T,? extends V> folder) Do right-associative folding of an array.
static <T,E extends java.lang.Exception> void	forEach(java.util.Enumeration<T> enumeration, FragileLoopItemHandler<? super T,E> handler) Call a handler for each item in an enumeration
static <T> void	forEach(java.util.Enumeration<T> enumeration, LoopItemHandler<? super T> handler) Call a handler for each item in an enumeration.
static <T,E extends java.lang.Exception> void	forEach(java.lang.Iterable<T> iterable, FragileLoopItemHandler<? super T,E> handler) Call a handler for each item in an iterable.
static <T> void	forEach(java.lang.Iterable<T> iterable, LoopItemHandler<? super T> handler) Call a handler for each item in an iterable.
static <T,E extends java.lang.Exception> void	forEach(java.util.Iterator<T> iterator, FragileLoopItemHandler<? super T,E> handler) Call a handler for each item in an iterator
static <T> void	forEach(java.util.Iterator<T> iterator, LoopItemHandler<? super T> handler) Call a handler for each item in an iterator.
static <T,E extends java.lang.Exception> void	forEach(T[] array, FragileLoopItemHandler<? super T,E> handler) Call a handler for each item in an array.
static <T> void	forEach(T[] array, LoopItemHandler<? super T> handler) Call a handler for each item in an array.
static <T,E extends java.lang.Exception> void	forEachFragile(java.lang.Iterable<T> iterable, FragileProcedure1<E,? super T> consumer) Foreach implementation which can be used with consumers which might throw a checked exception.
static <T,E extends java.lang.Exception> void	forEachRemainingFragile(java.util.Iterator<T> iterator, FragileProcedure1<E,? super T> consumer) Foreach remaining implementation which can be used with consumers which might throw a checked exception.
static <T> T	get(java.lang.Iterable<T> iterable, int index) Get the nth element of an iterable.
static <T extends Copyable<T>> java.util.function.Function<T,T>	getCopier(java.lang.Class<T> elemClass) Get a copier function which creates an copy of its argument.
static int	hash(java.lang.Iterable<?> iterable) Calculate a hash code for a generic iterable.
static Indexable<java.lang.Byte>	indexable(byte... array) Return an indexable from a primitive byte integer array.
static Indexable<java.lang.Double>	indexable(double... array) Return an indexable from a primitive double array.
static Indexable<java.lang.Float>	indexable(float... array) Return an indexable from a primitive float array.
static Indexable<java.lang.Integer>	indexable(int... array) Return an indexable from a primitive integer array.
static Indexable<java.lang.Long>	indexable(long... array) Return an indexable from a primitive long integer array.
static Indexable<java.lang.Short>	indexable(short... array) Return an indexable from a primitive short integer array.
static <T,E> int	indexOf(java.util.Enumeration<T> enumeration, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Get the first index where a given element appears.
static <T,E> int	indexOf(java.util.Enumeration<T> enumeration, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the first index where a given element appears.
static <T,E> int	indexOf(java.lang.Iterable<T> iterable, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Get the first index where a given element appears.
static <T,E> int	indexOf(java.lang.Iterable<T> iterable, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the first index where a given element appears.
static <T,E> int	indexOf(java.util.Iterator<T> iterator, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Get the first index where a given element appears.
static <T,E> int	indexOf(java.util.Iterator<T> iterator, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the first index where a given element appears.
static <T,E> int	indexOf(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the first index where a given element appears.
static <T,E> int	indexOf(T[] array, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Get the first index where a given element appears.
static <T,E> int	indexOf(T[] array, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the first index where a given element appears.
static <S> PrimitiveIntIterable	intView(java.lang.Iterable<S> sourceIterable, java.util.function.ToIntFunction<? super S> intMapper) View a generic iterable as if it is an iterable of primitive int values.
static <S> java.util.PrimitiveIterator.OfInt	intView(java.util.Iterator<S> sourceIterator, java.util.function.ToIntFunction<? super S> intMapper) View a generic iterator as if it is an iterator for primitive int values.
static <T,S> TwoWayTypeConverter<T,S>	invert(TwoWayTypeConverter<S,T> typeConverter) Get an inverted two way type converter from a given one.
static java.lang.String	join(char glue, java.lang.Iterable<java.lang.String> strings) Join a bunch of strings into one.
static java.lang.String	join(char glue, java.util.Iterator<java.lang.String> strings) Join a bunch of strings into one.
static java.lang.String	join(char glue, java.lang.String... strings) Join an array of strings into one.
static java.lang.String	join(java.lang.String glue, java.util.Enumeration<java.lang.String> strings) Join a bunch of strings into one.
static java.lang.String	join(java.lang.String glue, java.lang.Iterable<java.lang.String> strings) Join a bunch of strings into one.
static java.lang.String	join(java.lang.String glue, java.util.Iterator<java.lang.String> strings) Join a bunch of strings into one.
static java.lang.String	join(java.lang.String glue, java.lang.String... strings) Join an array of strings into one.
static <T> T	last(java.lang.Iterable<T> iterable, java.util.function.Predicate<? super T> checker) Get the last element which fulfills a check.
static <T> T	last(java.util.List<T> list, java.util.function.Predicate<? super T> checker, int startIndex) Get the last element which fulfills a check.
static <T,E> int	lastIndexOf(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Get the last index where a given element appears.
static <T,E> int	lastIndexOf(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the last index where a given element appears.
static <T,E> T	lastMatch(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher) Get the last matching element where a given element appears.
static <T,E> T	lastMatch(java.util.List<T> list, E element, java.util.function.BiPredicate<? super T,? super E> matcher, int start) Get the last matching element from a list.
static <T extends java.lang.Comparable<T>> int	lexicalCompare(java.lang.Iterable<? extends T> it1, java.lang.Iterable<? extends T> it2) Compare two iterables in lexical natural order.
static <T> int	lexicalCompare(java.lang.Iterable<? extends T> it1, java.lang.Iterable<? extends T> it2, java.util.Comparator<T> comparator) Compare two iterables in lexical order.
static <T extends java.lang.Comparable<T>> int	lexicalCompare(java.util.Iterator<? extends T> it1, java.util.Iterator<? extends T> it2) Compare two iterators in lexical natural order.
static <T> int	lexicalCompare(java.util.Iterator<? extends T> it1, java.util.Iterator<? extends T> it2, java.util.Comparator<T> comparator) Compare two iterators in lexical order.
static <S> PrimitiveLongIterable	longView(java.lang.Iterable<S> sourceIterable, java.util.function.ToLongFunction<? super S> longMapper) View a generic iterable as if it is an iterable of primitive long values.
static <S> java.util.PrimitiveIterator.OfLong	longView(java.util.Iterator<S> sourceIterator, java.util.function.ToLongFunction<? super S> longMapper) View a generic iterator as if it is an iterator for primitive long values.
static <T> ArrayFactory<T>	makeArrayFactory(java.lang.Class<T> type) Create an array factory from a type.
static <T> Factory<T>	makeFactory(java.lang.Class<T> type) Create a factory from a type.
static <T> java.util.LinkedList<T>	makeList(java.util.Enumeration<T> enumeration) Create a list from an enumeration.
static <T> java.util.LinkedList<T>	makeList(java.lang.Iterable<T> iterable) Create a list from an iterable.
static <T> java.util.LinkedList<T>	makeList(java.util.Iterator<T> iterator) Create a list from an iterator.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iteration into a collection.
static <C extends java.util.function.Consumer<? super T>,T,S> C	map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iteration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iteration into a collection.
static <C extends java.util.function.Consumer<? super T>,T,S> C	map(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iteration to a consumer.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a collection.
static <C extends java.util.function.Consumer<? super T>,T,S> C	map(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator to a consumer.
static <T,S> java.util.ArrayList<T>	map(java.util.Collection<S> collection, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of a collection.
static <T,S> java.util.ArrayList<T>	map(Countable<S> countable, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of a countable.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, S[] array, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an array into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	map(C target, S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an array into a collection.
static <T,S> java.util.LinkedList<T>	map(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
static <T,S> java.util.LinkedList<T>	map(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a collection.
static <T,S> java.util.LinkedList<T>	map(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an iterable.
static <T,S> java.util.LinkedList<T>	map(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Get the mapped elements of an iterable.
static <T,S> java.util.LinkedList<T>	map(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an iterator.
static <T,S> java.util.LinkedList<T>	map(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a collection.
static <KT,VT,KS,VS> java.util.HashMap<KT,VT>	map(java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<KS,VS>,java.util.Map.Entry<KT,VT>> typeConverter) Map one map into another, while allowing to discard elements on the way.
static <MT extends java.util.Map<KT,VT>,KT,VT,KS,VS> MT	map(MT target, java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<KS,VS>,? extends java.util.Map.Entry<KT,VT>> typeConverter) Map one map into another, while allowing to discard elements on the way.
static <T,S> java.util.ArrayList<T>	map(S[] array, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an array.
static <T,S> java.util.LinkedList<T>	map(S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Get the mapped elements of an array.
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Collection, Enumeration, FragileFunction1) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Collection, Enumeration, FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Collection, Iterable, FragileFunction1) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Collection, Iterable, FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Collection, Iterator, FragileFunction1) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Collection, Iterator, FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, S[] array, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Collection, Object[], FragileFunction1) instead which does not require handling a TypeConverterException
static <C extends java.util.Collection<? super T>,T,S> C	mapE(C target, S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Collection, Object[], FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Enumeration, FragileFunction1) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Enumeration, FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Iterable, FragileFunction1) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Iterable, FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Iterator, FragileFunction1) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Iterator, FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(S[] array, FragileTypeConverter<T,? super S> typeConverter) Deprecated. use mapFragile(Object[], FragileFunction1) instead which does not require handling a TypeConverterException
static <T,S> java.util.LinkedList<T>	mapE(S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Deprecated. use mapFragile(Object[], FragileFunction1, Object) instead which does not require handling a TypeConverterException
static <KT,VT,KS,VS> Function1<java.util.Map.Entry<KT,VT>,java.util.Map.Entry<KS,VS>>	mapEntryConverter(java.util.function.Function<KS,KT> keyConverter, java.util.function.Function<VS,VT> valueConverter) Type converter which converts a map entry by simultaneously applying a converter to the key and to the value.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper) Add the mapped elements of an enumeration into a collection by using a mapper function which might throw a checked exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Add the mapped elements of an enumeration into a collection while using a mapper which might throw an exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper) Add the mapped elements of an iterable into a collection by using a mapper function which might throw a checked exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Add the mapped elements of an iterable into a collection while using a mapper which might throw an exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper) Add the mapped elements of an iterator into a collection by using a mapper function which might throw a checked exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Add the mapped elements of an iterator into a collection while using a mapper which might throw an exception.
static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>	mapFragile(java.util.Collection<S> collection, FragileFunction1<? extends T,E,? super S> mapper) Get the mapped elements of a collection while using a mapper which might throw a checked exception.
static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>	mapFragile(Countable<S> countable, FragileFunction1<? extends T,E,? super S> mapper) Get the mapped elements of an array while using a mapper which might throw a checked exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, S[] array, FragileFunction1<? extends T,E,? super S> mapper) Add the mapped elements of an array into a collection by using a mapper function which might throw a checked exception.
static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C	mapFragile(C target, S[] array, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Add the mapped elements of an array into a collection while using a mapper which might throw an exception.
static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>	mapFragile(java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper) Get the mapped elements of an enumeration while using a mapper which might throw a checked exception.
static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>	mapFragile(java.util.Enumeration<S> enumeration, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Get the mapped elements of an enumeration while using a mapper which might throw an exception.
static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>	mapFragile(java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper) Get the mapped elements of an iterable while using a mapper which might throw a checked exception.
static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>	mapFragile(java.lang.Iterable<S> iterable, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Get the mapped elements of an iterable while using a mapper which might throw an exception.
static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>	mapFragile(java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper) Get the mapped elements of an iterator while using a mapper which might throw a checked exception.
static <T,S,E extends java.lang.Exception> java.util.LinkedList<T>	mapFragile(java.util.Iterator<S> iterator, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Get the mapped elements of an iterator while using a mapper which might throw an exception.
static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>	mapFragile(S[] array, FragileFunction1<? extends T,E,? super S> mapper) Get the mapped elements of an array while using a mapper which might throw a checked exception.
static <T,S,E extends java.lang.Exception> java.util.ArrayList<T>	mapFragile(S[] array, FragileFunction1<? extends T,E,? super S> mapper, T deleteMark) Get the mapped elements of an array while using a mapper which might throw an exception.
static <T,S> java.util.HashMap<T,S>	mapM(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a map.
static <T,S> java.util.HashMap<T,S>	mapM(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a map.
static <T,S> java.util.HashMap<T,S>	mapM(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an iterable as a hash map..
static <T,S> java.util.HashMap<T,S>	mapM(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Get the mapped elements of an iterable to a map.
static <T,S> java.util.HashMap<T,S>	mapM(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an iterator as a map.
static <T,S> java.util.HashMap<T,S>	mapM(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, S[] array, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an array into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapM(M target, S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an array into a map.
static <T,S> java.util.HashMap<T,S>	mapM(S[] array, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<T,S>	mapM(S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<T,S>	mapME(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration into a map.
static <T,S> java.util.HashMap<T,S>	mapME(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration to a map.
static <T,S> java.util.HashMap<T,S>	mapME(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter) Get the mapped elements of an iterable as a map.
static <T,S> java.util.HashMap<T,S>	mapME(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Get the mapped elements of an iterable as a map.
static <T,S> java.util.HashMap<T,S>	mapME(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Get the mapped elements of an iterator as a map.
static <T,S> java.util.HashMap<T,S>	mapME(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration to a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration to a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iterator to a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an array into a map.
static <M extends java.util.Map<? super T,? super S>,T,S> M	mapME(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an array into a map.
static <T,S> java.util.HashMap<T,S>	mapME(S[] array, FragileTypeConverter<T,? super S> typeConverter) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<T,S>	mapME(S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<S,T>	mapR(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a map.
static <T,S> java.util.HashMap<S,T>	mapR(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a map.
static <T,S> java.util.HashMap<S,T>	mapR(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an iterable as a hash map..
static <T,S> java.util.HashMap<S,T>	mapR(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Get the mapped elements of an iterable to a map.
static <T,S> java.util.HashMap<S,T>	mapR(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an iterator as a map.
static <T,S> java.util.HashMap<S,T>	mapR(java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, S[] array, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an array into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapR(M target, S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an array into a map.
static <T,S> java.util.HashMap<S,T>	mapR(S[] array, java.util.function.Function<? super S,T> typeConverter) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<S,T>	mapR(S[] array, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<S,T>	mapRE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration into a map.
static <T,S> java.util.HashMap<S,T>	mapRE(java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration to a map.
static <T,S> java.util.HashMap<S,T>	mapRE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter) Get the mapped elements of an iterable as a map.
static <T,S> java.util.HashMap<S,T>	mapRE(java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Get the mapped elements of an iterable as a map.
static <T,S> java.util.HashMap<S,T>	mapRE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Get the mapped elements of an iterator as a map.
static <T,S> java.util.HashMap<S,T>	mapRE(java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration to a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration to a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, java.lang.Iterable<S> iterable, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iteration into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iterator to a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an array into a map.
static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRE(M target, S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an array into a map.
static <T,S> java.util.HashMap<S,T>	mapRE(S[] array, FragileTypeConverter<T,? super S> typeConverter) Get the mapped elements of an array as a map.
static <T,S> java.util.HashMap<S,T>	mapRE(S[] array, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Get the mapped elements of an array as a map.
static <C extends java.util.Collection<? super T>,T,S> C	mapX(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an enumeration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	mapX(C target, java.lang.Iterable<S> iterable, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an iteration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	mapX(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an iterator into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	mapX(C target, S[] array, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an array into a collection.
static <T,S> java.util.LinkedList<T>	mapX(java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an enumeration into a collection.
static <T,S> java.util.LinkedList<T>	mapX(java.lang.Iterable<S> iterable, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Get the mapped elements of an iterable.
static <T,S> java.util.LinkedList<T>	mapX(java.util.Iterator<S> iterator, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Get the mapped elements of an iterator.
static <KT,VT,KS,VS> java.util.HashMap<KT,VT>	mapX(java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,java.lang.Iterable<java.util.Map.Entry<KT,VT>>> typeConverter) Map one map into another, while allowing to discard elements on the way.
static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT	mapX(MT target, java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,? extends java.lang.Iterable<? extends java.util.Map.Entry<? extends KT,? extends VT>>> typeConverter) Map one map into another, allowing to discard or add elements on the way.
static <T,S> java.util.LinkedList<T>	mapX(S[] array, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Get the mapped elements of an array.
static <C extends java.util.Collection<? super T>,T,S> C	mapXE(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an enumeration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	mapXE(C target, java.lang.Iterable<S> iterable, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an iteration into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	mapXE(C target, java.util.Iterator<S> iterator, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an iterator into a collection.
static <C extends java.util.Collection<? super T>,T,S> C	mapXE(C target, S[] array, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an array into a collection.
static <T,S> java.util.LinkedList<T>	mapXE(java.util.Enumeration<S> enumeration, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an enumeration into a collection.
static <T,S> java.util.LinkedList<T>	mapXE(java.lang.Iterable<S> iterable, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Get the mapped elements of an iterable.
static <T,S> java.util.LinkedList<T>	mapXE(java.util.Iterator<S> iterator, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Get the mapped elements of an iterator.
static <T,S> java.util.LinkedList<T>	mapXE(S[] array, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Get the mapped elements of an array.
static <T> T	max(java.util.Comparator<? super T> comparator, java.lang.Iterable<T> values) Get the maximal value from some values.
static <T> T	max(java.util.Comparator<? super T> comparator, T... values) Get the maximal value from an array of values.
static <T extends java.lang.Comparable<? super T>> T	max(java.lang.Iterable<T> values) Get the maximal value from some comparable values.
static <T extends java.lang.Comparable<? super T>> T	max(T... values) Get the maximal value from an array of comparable values.
static byte	maxByte(byte... values) Get the maximal value.
static char	maxChar(char... values) Get the maximal value.
static double	maxDouble(double... values) Get the maximal value.
static double	maxDouble(java.lang.Iterable<? extends java.lang.Number> iterable) Get the maximal double value for an iterable of numbers.
static <T> double	maxDouble(java.lang.Iterable<T> iterable, java.util.function.ToDoubleFunction<? super T> toDouble) Get the maximal double value from a double view of an iterable.
static float	maxFloat(float... values) Get the maximal value.
static int	maxInt(int... values) Get the maximal value.
static long	maxLong(long... values) Get the maximal value.
static short	maxShort(short... values) Get the maximal value.
static <T> T	min(java.util.Comparator<? super T> comparator, java.lang.Iterable<T> values) Get the minimal value from some values.
static <T> T	min(java.util.Comparator<? super T> comparator, T... values) Get the minimal value from an array of values.
static <T extends java.lang.Comparable<? super T>> T	min(java.lang.Iterable<T> values) Get the minimal value from some comparable values.
static <T extends java.lang.Comparable<? super T>> T	min(T... values) Get the minimal value from an array of comparable values.
static byte	minByte(byte... values) Get the minimal value.
static char	minChar(char... values) Get the minimal value.
static double	minDouble(double... values) Get the minimal value.
static double	minDouble(java.lang.Iterable<? extends java.lang.Number> iterable) Get the minimal double value for an iterable of numbers.
static <T> double	minDouble(java.lang.Iterable<T> iterable, java.util.function.ToDoubleFunction<? super T> toDouble) Get the minimal double value from a double view of an iterable.
static float	minFloat(float... values) Get the minimal value.
static int	minInt(int... values) Get the minimal value.
static long	minLong(long... values) Get the minimal value.
static short	minShort(short... values) Get the minimal value.
static java.lang.String	multiple(java.lang.String str, int count) Create a string from a base string repeated multiple times.
static <T extends java.lang.Comparable<T>> java.util.Comparator<T>	naturalOrder() Get a comparator which sorts comparables in their natural order.
static <T extends java.lang.Comparable<T>> java.util.Comparator<T>	naturalOrder(java.lang.Class<T> type) Deprecated. use naturalOrder() instead
static <T extends java.lang.Comparable<T>> java.util.Comparator<T>	naturalOrder(java.util.Collection<T> list) Deprecated. use naturalOrder() instead
static java.lang.String	notEmpty(java.lang.String str, java.lang.String fallback) Make sure a string is neither null nor empty.
static java.lang.String	notNull(java.lang.String str) Make sure a string is not null.
static <T,D extends T> T	notNull(T item, D defaultValue) Make sure that something is not null.
static <T> T	notNullOr(T item, java.util.function.Supplier<? extends T> provider) Make sure that something is not null, but postpone the fallback creation.
static <T> T	notNullOrN(T item, java.util.function.Supplier<? extends T> provider) Try to determine a fallback when a value is null.
static <T> Function1<T,T>	nullConverter() Type converter which does no conversion.
static <T> T	requireNonNull(T item, Procedure0 thrower) Require an item to be not null.
static <T> void	separate(java.lang.Iterable<T> elements, java.util.Collection<? super T> trueCollect, java.util.Collection<? super T> falseCollect, java.util.function.Predicate<? super T> condition) Go over an iterable and sepparate its elements depending a condition.
static <T> void	separate(java.lang.Iterable<T> elements, java.util.function.Consumer<? super T> trueCollect, java.util.function.Consumer<? super T> falseCollect, java.util.function.Predicate<? super T> condition) Go over an iterable and sepparate its elements depending a condition.
static <T> Pair<java.util.LinkedList<T>>	separate(java.lang.Iterable<T> elements, java.util.function.Predicate<? super T> condition) Go over an iterable and separate its elements into two lists depending on a condition.
static <T,C extends java.util.Collection<? super T>> Pair<C>	separate(java.lang.Iterable<T> elements, java.util.function.Supplier<C> slotCreator, java.util.function.Predicate<? super T> condition) Fo over an iterable and separate its elements depending on a condition.
static <S> PrimitiveShortIterable	shortView(java.lang.Iterable<S> sourceIterable, ToShortFunction<? super S> shortMapper) View a generic iterable as if it is an iterable of primitive short values.
static <S> PrimitiveShortIterator	shortView(java.util.Iterator<S> sourceIterator, ToShortFunction<? super S> shortMapper) View a generic iterator as if it is an iterator for primitive short values.
static java.lang.String	spaces(int count) This creates a string consisting only of spaces which is sometimes useful.
static <T> java.util.Collection<T>	synchronizedCollection(java.util.Collection<T> collection) Get a synchronized collection from a basic collection which is optimized for being often iterated, but rarely changed.
static <T> java.util.List<T>	synchronizedList(java.util.List<T> list) Get a synchronized list from a basic collection which is optimized for being often iterated, but rarely changed.
static boolean[]	toBooleanArray(java.util.Collection<java.lang.Boolean> c) Convert a collection of Booleans to a raw array of booleans.
static boolean[]	toBooleanArray(Countable<java.lang.Boolean> c) Convert a countable of Booleans to a raw array of booleans.
static byte[]	toByteArray(java.util.Collection<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of bytes.
static byte[]	toByteArray(Countable<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of bytes.
static byte[]	toByteArray(int... bytes) Convert a number of bytes into a byte array.
static double[]	toDoubleArray(java.util.Collection<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of doubles.
static double[]	toDoubleArray(Countable<? extends java.lang.Number> c) Convert a countable of Numbers to a raw array of doubles.
static <T> java.util.Enumeration<T>	toEnumeration(java.lang.Iterable<T> iterable) Convert an iterable into an enumeration.
static <T> java.util.Enumeration<T>	toEnumeration(java.util.Iterator<T> iterator) Convert an iterator into an enumeration.
static <T> java.util.Enumeration<T>	toEnumeration(T... item) Convert some items into an enumeration.
static float[]	toFloatArray(java.util.Collection<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of floats.
static float[]	toFloatArray(Countable<? extends java.lang.Number> c) Convert a countable of Numbers to a raw array of floats.
static <T,S> OverCaringTypeConverter<T,S>	toFragile(java.util.function.Function<S,T> typeConverter) Make a non-fragile type converter appear as fragile.
static int[]	toIntArray(java.util.Collection<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of ints.
static int[]	toIntArray(Countable<? extends java.lang.Number> c) Convert a countable of Numbers to a raw array of ints.
static <T> java.lang.Iterable<T>	toIterable(java.util.Enumeration<T> enumeration) Get a one shot iterable from an enumeration.
static <T> java.util.Iterator<T>	toIterator(java.util.Enumeration<T> enumeration) Convert an enumeration into an iterator.
static <T> java.util.Iterator<T>	toIterator(T... item) Convert some items into an iterator.
static java.util.List<java.lang.Boolean>	toList(boolean... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Boolean>	toList(boolean[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Boolean>	toList(boolean[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Byte>	toList(byte... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Byte>	toList(byte[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Byte>	toList(byte[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Double>	toList(double... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Double>	toList(double[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Double>	toList(double[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static <T> java.util.LinkedList<T>	toList(java.util.Enumeration<T> enumeration) Collect an enumeration into a linked list.
static java.util.List<java.lang.Float>	toList(float... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Float>	toList(float[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Float>	toList(float[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Integer>	toList(int... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Integer>	toList(int[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Integer>	toList(int[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static <T> java.util.LinkedList<T>	toList(java.lang.Iterable<T> iterable) Collect the elements of an iterable into a linked list.
static <T> java.util.LinkedList<T>	toList(java.util.Iterator<T> iterator) Collect an iterator into a linked list.
static java.util.List<java.lang.Long>	toList(long... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Long>	toList(long[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Long>	toList(long[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Short>	toList(short... array) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Short>	toList(short[] array, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static java.util.List<java.lang.Short>	toList(short[] array, int start, int length) A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.
static long[]	toLongArray(java.util.Collection<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of long ints.
static long[]	toLongArray(Countable<? extends java.lang.Number> c) Convert a countable of Numbers to a raw array of long ints.
static <T,E extends java.lang.Exception,L extends FragileLoopItemHandler<T,E>> CarelessLoopItemHandler<T,E,L>	toLoopItemHandler(L handler) Wrap a careful loop item handler as a simple loop item handler.
static <T,S> CarelessTypeConverter<T,S>	toNonFragile(FragileTypeConverter<T,S> fragileTypeConverter) Make a fragile type converter appear as a standard type converter.
static <T,S> CarelessTypeConverter<T,S>	toNonFragile(FragileTypeConverter<T,S> fragileTypeConverter, T defaultValue) Make a fragile type converter appear as a standard type converter.
static <K,V,C extends java.util.Collection<OrderedPair<K,V>>> C	toPairs(C target, java.util.Map<K,V> map) Get all entries of a map as a collection of ordered pairs.
static <K,V> java.util.ArrayList<OrderedPair<K,V>>	toPairs(java.util.Map<K,V> map) Get all entries of a map as a list of ordered pairs.
static <R> Function0<R>	toRobustF0(FragileFunction0<? extends R,?> fragileFunction) Convert a fragile zero-argument function which could throw an exception into non-fragile one.
static <R,P> Function1<R,P>	toRobustF1(FragileFunction1<? extends R,?,? super P> fragileFunction) Convert a fragile one-argument function which could throw an exception into non-fragile one.
static <R,P1,P2> Function2<R,P1,P2>	toRobustF2(FragileFunction2<? extends R,?,? super P1,? super P2> fragileFunction) Convert a fragile two-argument function which could throw an exception into non-fragile one.
static <R,P1,P2,P3> Function3<R,P1,P2,P3>	toRobustF3(FragileFunction3<? extends R,?,? super P1,? super P2,? super P3> fragileFunction) Convert a fragile 3-argument function which could throw an exception into non-fragile one.
static Procedure0	toRobustP0(FragileProcedure0<?> fragileProc) Convert a fragile zero-argument procedure which could throw an exception into non-fragile one.
static <P> Procedure1<P>	toRobustP1(FragileProcedure1<?,? super P> fragileProc) Convert a fragile one-argument procedure which could throw an exception into non-fragile one.
static <P1,P2> Procedure2<P1,P2>	toRobustP2(FragileProcedure2<?,? super P1,? super P2> fragileProc) Convert a fragile two-argument procedure which could throw an exception into non-fragile one.
static <P1,P2,P3> Procedure3<P1,P2,P3>	toRobustP3(FragileProcedure3<?,? super P1,? super P2,? super P3> fragileProc) Convert a fragile 3-argument procedure which could throw an exception into non-fragile one.
static short[]	toShortArray(java.util.Collection<? extends java.lang.Number> c) Convert a collection of Numbers to a raw array of shorts.
static short[]	toShortArray(Countable<? extends java.lang.Number> c) Convert a countable of Numbers to a raw array of shorts.
static java.util.LinkedList<java.lang.String>	toStringList(java.util.Enumeration<?> enumeration) Collect an enumeration into a linked list of strings.
static java.util.LinkedList<java.lang.String>	toStringList(java.lang.Iterable<?> iterable) Collect the elements of an iterable into a linked list.
static java.util.LinkedList<java.lang.String>	toStringList(java.util.Iterator<?> iterator) Collect an iterator into a linked list of strings.
static <T1,T2> java.util.function.BiPredicate<T1,T2>	trueBiPredicate() Return a bi-predicate which returns always true.
static <T> java.util.function.Predicate<T>	truePredicate() Return a predicate which returns always true.
static <T> java.util.Iterator<T>	unmodifiable(java.util.Iterator<T> iterator) Wrap an iterator to keep it from modifying the underlying collection.
static <T> java.util.ListIterator<T>	unmodifiable(java.util.ListIterator<T> iterator) Wrap a list iterator to keep it from modifying the underlying collection.
static <T,S> java.lang.Iterable<T>	view(java.util.function.Function<? super S,T> mapper, S... array) View an array as if it belongs to another iterable type.
static <T,S> Indexable<T>	view(Indexable<S> sourceIndexable, java.util.function.Function<? super S,T> mapper) View an indexable.
static <T,S> java.lang.Iterable<T>	view(java.lang.Iterable<S> sourceIterable, java.util.function.Function<? super S,? extends T> mapper) View an iterable Instead of map(java.lang.Iterable, Function) this will work transparently on the fly.
static <T,S> java.util.Iterator<T>	view(java.util.Iterator<S> sourceIterator, java.util.function.Function<? super S,? extends T> mapper) View an iterator as if it belongs to another type.
static <T,S> java.util.ListIterator<T>	view(java.util.ListIterator<S> sourceIterator, java.util.function.Function<? super S,T> mapper) View a list iterator as if it belongs to another type.
static <T,S> java.util.Collection<T>	viewCollection(java.util.Collection<S> collection, java.util.function.Function<? super S,T> mapper) View a collection as if it has of another element type.
static <T,S> java.util.List<T>	viewList(java.util.List<S> list, java.util.function.Function<? super S,T> mapper) View a list as if it has another element type.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

RELEASE_DATE

@Deprecated
public static final java.lang.String RELEASE_DATE

Deprecated. Use ModuleVersion.VERSION instead, or ModuleVersionService.iterator()/ModuleVersionService.collectServices() for all modules

Release of this file.

VERSION

@Deprecated
public static final java.lang.String VERSION

Deprecated. use ModuleVersion.VERSION instead

Version number of this file.

COMPARABLE_COMPARATOR

@NotNull
public static final java.util.Comparator<? extends java.lang.Comparable> COMPARABLE_COMPARATOR

Comparator which compares Comparables in their natural order. Will throw NullPointerException on null values.

TO_STRING_COMPARATOR

public static final java.util.Comparator<?> TO_STRING_COMPARATOR

Comparator which compares the toString() representation. Will throw NullPointerException on null values.

TO_STRING_IGNORE_CASE_COMPARATOR

public static final java.util.Comparator<?> TO_STRING_IGNORE_CASE_COMPARATOR

Comparator which compares the toString() representation in case-insensitive order. Will throw NullPointerException on null values.

EMPTY_DOUBLE_ITERATOR

public static final java.util.PrimitiveIterator.OfDouble EMPTY_DOUBLE_ITERATOR

Empty primitve double iterator.

EMPTY_INT_ITERATOR

public static final java.util.PrimitiveIterator.OfInt EMPTY_INT_ITERATOR

Empty primitive int iterator.

EMPTY_LONG_ITERATOR

public static final java.util.PrimitiveIterator.OfLong EMPTY_LONG_ITERATOR

Empty primitive long iterator.

EMPTY_BOOLEAN_ITERATOR

public static final PrimitiveBooleanIterator EMPTY_BOOLEAN_ITERATOR

Empty primitive boolean iterator.

EMPTY_BYTE_ITERATOR

public static final PrimitiveByteIterator EMPTY_BYTE_ITERATOR

Empty primitive byte iterator.

EMPTY_SHORT_ITERATOR

public static final PrimitiveShortIterator EMPTY_SHORT_ITERATOR

Empty primitive short iterator.

EMPTY_CHAR_ITERATOR

public static final PrimitiveCharIterator EMPTY_CHAR_ITERATOR

Empty primitive char iterator.

EMPTY_FLOAT_ITERATOR

public static final PrimitiveFloatIterator EMPTY_FLOAT_ITERATOR

Empty primitive float iterator.

EMPTY_HASH

public static final int EMPTY_HASH

Hash value for empty collections.

See Also:

Constant Field Values

TO_STRING

@NotNull
public static final Function1<java.lang.String,java.lang.Object> TO_STRING

A type converter which converts any object into its toString() representation. It is safe for null values.

NUMBER_TO_DOUBLE

@NotNull
public static final Function1<java.lang.Double,java.lang.Number> NUMBER_TO_DOUBLE

A type converter allowing any number based type to be converted to double.

NUMBER_TO_FLOAT

@NotNull
public static final Function1<java.lang.Float,java.lang.Number> NUMBER_TO_FLOAT

A type converter allowing any number based type to be converted to float.

NUMBER_TO_LONG

@NotNull
public static final Function1<java.lang.Long,java.lang.Number> NUMBER_TO_LONG

A type converter allowing any number based type to be converted to long.

NUMBER_TO_INT

@NotNull
public static final Function1<java.lang.Integer,java.lang.Number> NUMBER_TO_INT

A type converter allowing any number based type to be converted to integer.

NUMBER_TO_SHORT

@NotNull
public static final Function1<java.lang.Short,java.lang.Number> NUMBER_TO_SHORT

A type converter allowing any number based type to be converted to short integer.

NUMBER_TO_BYTE

@NotNull
public static final Function1<java.lang.Byte,java.lang.Number> NUMBER_TO_BYTE

A type converter allowing any number based type to be converted to a byte value.

STR_TO_INT

@NotNull
public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT

A converter which converts strings to integer, using base 10.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_INT_BASE_16

@NotNull
public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT_BASE_16

A converter which converts strings to integer, using base 16.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_INT_BASE_8

@NotNull
public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT_BASE_8

A converter which converts strings to integer, using base 8.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_INT_BASE_2

@NotNull
public static final FragileTypeConverter<java.lang.Integer,java.lang.String> STR_TO_INT_BASE_2

A converter which converts strings to integer, using base 2.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_LONG

@NotNull
public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG

A converter which converts strings to long integer, using base 10.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_LONG_BASE_16

@NotNull
public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG_BASE_16

A converter which converts strings to long integer, using base 16.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_LONG_BASE_8

@NotNull
public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG_BASE_8

A converter which converts strings to long integer, using base 8.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_LONG_BASE_2

@NotNull
public static final FragileTypeConverter<java.lang.Long,java.lang.String> STR_TO_LONG_BASE_2

A converter which converts strings to long integer, using base 2.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_SHORT

@NotNull
public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT

A converter which converts strings to short integer, using base 10.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_SHORT_BASE_16

@NotNull
public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT_BASE_16

A converter which converts strings to short integer, using base 16.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_SHORT_BASE_8

@NotNull
public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT_BASE_8

A converter which converts strings to short integer, using base 8.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_SHORT_BASE_2

@NotNull
public static final FragileTypeConverter<java.lang.Short,java.lang.String> STR_TO_SHORT_BASE_2

A converter which converts strings to short integer, using base 2.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_BYTE

@NotNull
public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE

A converter which converts strings to byte values, using base 10.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_BYTE_BASE_16

@NotNull
public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE_BASE_16

A converter which converts strings to byte values, using base 16.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_BYTE_BASE_8

@NotNull
public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE_BASE_8

A converter which converts strings to byte values, using base 8.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_BYTE_BASE_2

@NotNull
public static final FragileTypeConverter<java.lang.Byte,java.lang.String> STR_TO_BYTE_BASE_2

A converter which converts strings to byte values, using base 2.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_DOUBLE

@NotNull
public static final FragileTypeConverter<java.lang.Double,java.lang.String> STR_TO_DOUBLE

A converter which converts strings (in Java number format) to double values.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_FLOAT

@NotNull
public static final FragileTypeConverter<java.lang.Float,java.lang.String> STR_TO_FLOAT

A converter which converts strings (in Java number format) to float values.

It may throw a TypeConverterException wrapping a NumberFormatException

STR_TO_BOOLEAN

@NotNull
public static final Function1<java.lang.Boolean,java.lang.String> STR_TO_BOOLEAN

A converter which converts strings to boolean values.

It follows the semantics of Boolean.valueOf(String), but will pass through null values. .

WORD_SPLIT

public static final Function1<java.util.List<java.lang.String>,java.lang.String> WORD_SPLIT

A converter which splits strings into words.

STR_TO_LOWER

public static final Function1<java.lang.String,java.lang.String> STR_TO_LOWER

A converter which changes strings to lowercase.

STR_TO_UPPER

public static final Function1<java.lang.String,java.lang.String> STR_TO_UPPER

A converter which changes strings to uppercase.

NOT_NULL

public static final Predicate1<java.lang.Object> NOT_NULL

Predicate for filtering out null objects.

Method Detail

naturalOrder

@NotNull
 @Deprecated
public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> naturalOrder(@NotNull
                                                                                                             java.lang.Class<T> type)

Deprecated. use naturalOrder() instead

Get a comparator which sorts comparables in their natural order.

Type Parameters:

T - comparable type

Parameters:

type - comparable type class

Returns:

natural order comparator

naturalOrder

@NotNull
 @Deprecated
public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> naturalOrder(@NotNull
                                                                                                             java.util.Collection<T> list)

Deprecated. use naturalOrder() instead

Get a comparator which sorts comparables in their natural order.

Type Parameters:

T - comparable type

Parameters:

list - collection with comparable type

Returns:

natural order comparator

naturalOrder

@NotNull
public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> naturalOrder()

Get a comparator which sorts comparables in their natural order.

Type Parameters:

T - comparable tyoe

Returns:

natural order comparator

downConverter

@NotNull
public static <T,S extends T> Function1<T,S> downConverter()

A converter which converts a type to a more basic type. Java can do this alone in most circumstances, so this should rarely be necessary.

Type Parameters:

S - source type which extends the target type

T - target type (base type of source type)

Returns:

type converter converting S to T

castConverter

@NotNull
public static <T,S> Function1<T,S> castConverter()

A converter which converts a type to a any other type by applying a cast. Use this converter only if you are perfectly sure that all objects passed to this converter fulfill the promise that they are of type T, If not usage of this converter will result in a ClassCastException.

Type Parameters:

S - source type

T - target type

Returns:

type converter converting S to T

nullConverter

@NotNull
public static <T> Function1<T,T> nullConverter()

Type converter which does no conversion. Use this converter when there is a type converter expected, but not necessary.

Type Parameters:

T - any type

Returns:

type converter not doing any conversion

as

@Nullable
public static <T> T as(@NotNull
                                 java.lang.Class<T> type,
                                 @Nullable
                                 java.lang.Object obj)

Cast an item to a given type if possible.

Type Parameters:

T - target type

Parameters:

type - target type

obj - object

Returns:

obj cast to target type, or null

mapEntryConverter

@NotNull
public static <KT,VT,KS,VS> Function1<java.util.Map.Entry<KT,VT>,java.util.Map.Entry<KS,VS>> mapEntryConverter(java.util.function.Function<KS,KT> keyConverter,
                                                                                                                        java.util.function.Function<VS,VT> valueConverter)

Type converter which converts a map entry by simultaneously applying a converter to the key and to the value.

Type Parameters:

KT - target key type

VT - target value type

KS - source key type

VS - source value type

Parameters:

keyConverter - key converter

valueConverter - value converter

Returns:

the converter

combine

public static <T,I,S> Function1<T,S> combine(@NotNull
                                             java.util.function.Function<I,T> secondStep,
                                             @NotNull
                                             java.util.function.Function<S,? extends I> firstStep)

Get a combined type converter using an intermediate value.

Type Parameters:

T - target type

I - intermediate type

S - source type

Parameters:

secondStep - second step, converting the intermediate vale to the target value

firstStep - first step, converting the source value to the intermediate value

Returns:

combined converter

combineEF

public static <T,I,S> FragileTypeConverter<T,S> combineEF(@NotNull
                                                          FragileTypeConverter<T,I> secondStep,
                                                          @NotNull
                                                          java.util.function.Function<S,? extends I> firstStep)

Get a combined type converter using an intermediate value.

Type Parameters:

T - target type

I - intermediate type

S - source type

Parameters:

secondStep - second step, converting the intermediate vale to the target value

firstStep - first step, converting the source value to the intermediate value

Returns:

combined converter

combineFE

public static <T,I,S> FragileTypeConverter<T,S> combineFE(@NotNull
                                                          java.util.function.Function<I,T> secondStep,
                                                          @NotNull
                                                          FragileTypeConverter<? extends I,S> firstStep)

Get a combined type converter using an intermediate value.

Type Parameters:

T - target type

I - intermediate type

S - source type

Parameters:

secondStep - second step, converting the intermediate vale to the target value

firstStep - first step, converting the source value to the intermediate value

Returns:

combined converter

combineEE

public static <T,I,S> FragileTypeConverter<T,S> combineEE(@NotNull
                                                          FragileTypeConverter<T,I> secondStep,
                                                          @NotNull
                                                          FragileTypeConverter<? extends I,S> firstStep)

Get a combined type converter using an intermediate value.

Type Parameters:

T - target type

I - intermediate type

S - source type

Parameters:

secondStep - second step, converting the intermediate vale to the target value

firstStep - first step, converting the source value to the intermediate value

Returns:

combined converter

invert

@NotNull
public static <T,S> TwoWayTypeConverter<T,S> invert(@NotNull
                                                             TwoWayTypeConverter<S,T> typeConverter)

Get an inverted two way type converter from a given one.

Type Parameters:

T - target type

S - source tyoe

Parameters:

typeConverter - given type converter

Returns:

inverse type converter

createTwoWay

@NotNull
public static <T,S> TwoWayTypeConverter<T,S> createTwoWay(@NotNull
                                                                   java.util.function.Function<S,T> toConverter,
                                                                   @NotNull
                                                                   java.util.function.Function<T,S> backConverter)

Create a two way type converter from two one way type converters.

Type Parameters:

T - target type

S - source type

Parameters:

toConverter - converter for normal direction (S to T)

backConverter - converter for back direction (T to S)

Returns:

two way type converter

toRobustF0

@NotNull
public static <R> Function0<R> toRobustF0(@NotNull
                                                   FragileFunction0<? extends R,?> fragileFunction)

Convert a fragile zero-argument function which could throw an exception into non-fragile one.

Type Parameters:

R - result type of incoming and outgoing function

Parameters:

fragileFunction - fragile function

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileFunction throws its declared exception

toRobustF1

@NotNull
public static <R,P> Function1<R,P> toRobustF1(@NotNull
                                                       FragileFunction1<? extends R,?,? super P> fragileFunction)

Convert a fragile one-argument function which could throw an exception into non-fragile one.

Type Parameters:

R - result type of incoming and outgoing function

P - parameter type of incoming and outgoing function

Parameters:

fragileFunction - fragile function

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileFunction throws its declared exception

toRobustF2

@NotNull
public static <R,P1,P2> Function2<R,P1,P2> toRobustF2(@NotNull
                                                               FragileFunction2<? extends R,?,? super P1,? super P2> fragileFunction)

Convert a fragile two-argument function which could throw an exception into non-fragile one.

Type Parameters:

R - result type of incoming and outgoing function

P1 - first parameter type of incoming and outgoing function

P2 - second parameter type of incoming and outgoing function

Parameters:

fragileFunction - fragile function

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileFunction throws its declared exception

toRobustF3

@NotNull
public static <R,P1,P2,P3> Function3<R,P1,P2,P3> toRobustF3(@NotNull
                                                                     FragileFunction3<? extends R,?,? super P1,? super P2,? super P3> fragileFunction)

Convert a fragile 3-argument function which could throw an exception into non-fragile one.

Type Parameters:

R - result type of incoming and outgoing function

P1 - first parameter type of incoming and outgoing function

P2 - second parameter type of incoming and outgoing function

P3 - third parameter type of incoming and outgoing function

Parameters:

fragileFunction - fragile function

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileFunction throws its declared exception

toRobustP0

@NotNull
public static Procedure0 toRobustP0(@NotNull
                                             FragileProcedure0<?> fragileProc)

Convert a fragile zero-argument procedure which could throw an exception into non-fragile one.

Parameters:

fragileProc - fragile procedure

Returns:

non-fragile procedure which will throw a RuntimeException with the wrapped original exception if fragileProc throws its declared exception

toRobustP1

@NotNull
public static <P> Procedure1<P> toRobustP1(@NotNull
                                                    FragileProcedure1<?,? super P> fragileProc)

Convert a fragile one-argument procedure which could throw an exception into non-fragile one.

Type Parameters:

P - parameter type of incoming and outgoing procedure

Parameters:

fragileProc - fragile procedure

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileProc throws its declared exception

toRobustP2

@NotNull
public static <P1,P2> Procedure2<P1,P2> toRobustP2(@NotNull
                                                            FragileProcedure2<?,? super P1,? super P2> fragileProc)

Convert a fragile two-argument procedure which could throw an exception into non-fragile one.

Type Parameters:

P1 - first parameter type of incoming and outgoing procedure

P2 - second parameter type of incoming and outgoing procedure

Parameters:

fragileProc - fragile procedure

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileProc throws its declared exception

toRobustP3

@NotNull
public static <P1,P2,P3> Procedure3<P1,P2,P3> toRobustP3(@NotNull
                                                                  FragileProcedure3<?,? super P1,? super P2,? super P3> fragileProc)

Convert a fragile 3-argument procedure which could throw an exception into non-fragile one.

Type Parameters:

P1 - first parameter type of incoming and outgoing procedure

P2 - second parameter type of incoming and outgoing procedure

P3 - third parameter type of incoming and outgoing procedure

Parameters:

fragileProc - fragile procedure

Returns:

non-fragile function which will throw a RuntimeException with the wrapped original exception if fragileProc throws its declared exception

toNonFragile

@NotNull
public static <T,S> CarelessTypeConverter<T,S> toNonFragile(@NotNull
                                                                     FragileTypeConverter<T,S> fragileTypeConverter)

Make a fragile type converter appear as a standard type converter.

Type Parameters:

T - target type

S - source type

Parameters:

fragileTypeConverter - fragile type converter

Returns:

fragile type converter wrapper, returning null on exceptions

toNonFragile

@NotNull
public static <T,S> CarelessTypeConverter<T,S> toNonFragile(@NotNull
                                                                     FragileTypeConverter<T,S> fragileTypeConverter,
                                                                     @Nullable
                                                                     T defaultValue)

Make a fragile type converter appear as a standard type converter.

Type Parameters:

T - target type

S - source type

Parameters:

fragileTypeConverter - fragile type converter

defaultValue - default value returned when the fragile type converter throws an exception

Returns:

fragile type converter wrapper, returning the default value on exceptions

toFragile

@NotNull
public static <T,S> OverCaringTypeConverter<T,S> toFragile(@NotNull
                                                                    java.util.function.Function<S,T> typeConverter)

Make a non-fragile type converter appear as fragile.

Type Parameters:

T - target type

S - source type

Parameters:

typeConverter - standard non-fragile type converter

Returns:

overcaring type converter

downCast

@NotNull
public static <T> java.lang.Iterable<T> downCast(@NotNull
                                                          java.lang.Iterable<? extends T> iterable)

Get a down-casted iterable.

This allows to view any iterable as being an iterable of a base class of its generic type.

Although casting generic types is frowned upon in general, in this special case using this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw ClassCastExceptions as the result of using this method.

Example:

   public void drawShapes(Iterable<Shape> shapes) {
     // ...
   }

   // ...
   Collection<Rectangle2D> rectangles = // ...
   drawShapes(Types.<Shape>downCast(rectangles));

 

Type Parameters:

T - base type

Parameters:

iterable - iterable with extended type

Returns:

iterator with base type

downCast

@NotNull
public static <T> java.util.Iterator<T> downCast(@NotNull
                                                          java.util.Iterator<? extends T> iterator)

Get a down-casted iterator.

This allows to view any iterator as being an iterator of a base class of its generic type.

Although casting generic types is frowned upon in general, in this special case using of this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw ClassCastExceptions as the result of using this method.

Example:

   public void drawShapes(Iterator<Shape> shapes) {
     // ...
   }

   // ...
   Collection<Rectangle2D> rectangles = // ...
   drawShapes(Types.<Shape>downCast(rectangles.iterator());

 

Type Parameters:

T - base type

Parameters:

iterator - iterator with extended type

Returns:

iterable with base type

downCast

@NotNull
public static <T> java.util.Enumeration<T> downCast(@NotNull
                                                             java.util.Enumeration<? extends T> enumeration)

Get a down-casted enumeration.

This allows to view any enumeration as being an enumeration of a base class of its generic type.

Although casting generic types is frowned upon in general, in this special case usage of this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw ClassCastExceptions as the result of using this method.

Example:

   public void drawShapes(Enumeration<Shape> shapes) {
     // ...
   }

   // ...
   GVector<Rectangle2D> rectangles = // ...
   drawShapes(Types.<Shape>downCast(rectangles.enumeration());
 

Type Parameters:

T - base type

Parameters:

enumeration - enumeration with extended type

Returns:

enumerator with base type

downCast

@NotNull
public static <T,S> java.util.function.Function<S,T> downCast(@NotNull
                                                                       java.util.function.Function<? super S,? extends T> typeConverter)

Downcast a type converter.

Using this method is typesafe.

Although casting generic types is frowned upon in general, in this special case usage of this method does not harm static type safety. I.e. if your program compiles the code without warnings, your program will not throw ClassCastExceptions as the result of using this method.

Type Parameters:

T - base type of original target type

S - extending type of original source type

Parameters:

typeConverter - type converter to downcast

Returns:

casted type converter

downCastT

@NotNull
public static <T,S> FragileTypeConverter<T,S> downCastT(@NotNull
                                                                 FragileTypeConverter<? extends T,? super S> typeConverter)

Downcast a type converter.

Using this method is typesafe.

Type Parameters:

T - base type of original target type

S - extending type of original source type

Parameters:

typeConverter - type converter to downcast

Returns:

casted type converter

cast

@NotNull
public static <T> java.lang.Iterable<T> cast(@NotNull
                                                      java.lang.Iterable<?> iterable)

Get a casted iterable.

Be careful using this method, as it can easily harm static type safety. I.e. only use when it is guaranteed that all elements returned by the iteration fulfill the promise that they are of type T. Otherwise a ClassCastException will be thrown when using the iterator if the iterable.

In other words: you can use this method to compile a program which will fail at runtime! And that is usually a stupid idea. So you should rethink your design before using this method.

The reason for this method is that life isn't perfect, and especially when you have to use libraries (even standard Java ones) this method may prove helpful.

Example:

   // we have this naked collection, but we know all its elements are Strings
   Collection foo = otherLibObject.getCollection();
   for (String str : Types.<String>cast(foo)) {
     // ...
   }
 

Type Parameters:

T - target type

Parameters:

iterable - iterable with any tye

Returns:

iterator with target type

cast

@NotNull
public static <T> java.util.Iterator<T> cast(@NotNull
                                                      java.util.Iterator<?> iterator)

Get a casted iterator.

Be careful using this method, as it can easily harm static type safety. I.e. only use when it is guaranteed that all elements returned by the iterator fulfill the promise that they are of type T. Otherwise a ClassCastException will be thrown when using the iterator.

In other words: you can use this method to compile a program which will fail at runtime! And that is usually a stupid idea. So you should rethink your design before using this method.

The reason for this method is that life isn't perfect, and especially when you have to use libraries (even standard Java ones) this method may prove helpful.

See cast(java.lang.Iterable) for an easy to adapt example.

Type Parameters:

T - target type

Parameters:

iterator - iterator with any type

Returns:

iterator with target type

cast

@NotNull
public static <T> java.util.Enumeration<T> cast(@NotNull
                                                         java.util.Enumeration<? extends T> enumeration)

Get a casted enumeration.

Be careful using this method, as it can easily harm static type safety. I.e. only use when it is guaranteed that all elements returned by the enumeration fulfill the promise that they are of type T. Otherwise a ClassCastException will be thrown when using the enumeration.

In other words: you can use this method to compile a program which will fail at runtime! And that is a stupid idea. So you should rethink your design before using this method.

The reason for this method is that life isn't perfect, and especially when you have to use libraries (even standard Java ones) this method may prove helpful.

See cast(java.lang.Iterable) for an easy to adapt example.

Type Parameters:

T - target type

Parameters:

enumeration - enumeration with any type

Returns:

enumerator with target type

flatten

@NotNull
public static <T> java.util.LinkedList<T> flatten(@NotNull
                                                           java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections)

Flatten a collection of collections. This will create a single linked list which contains all elements contained in the incoming collections.

Type Parameters:

T - basic type

Parameters:

collectionOfCollections - collection to flatten

Returns:

flattened linked list with all elements

flatten

@NotNull
public static <T,R extends java.util.Collection<? super T>> R flatten(@NotNull
                                                                               R target,
                                                                               @NotNull
                                                                               java.lang.Iterable<? extends java.lang.Iterable<T>> collectionOfCollections)

Flatten a collection of collections. This will create a single collection which contains all elements contained in the incoming collections.

Type Parameters:

T - basic type

R - result type

Parameters:

target - target collection, where the elements are stored

collectionOfCollections - collection to flatten

Returns:

flattened linked list with all elements

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             S[] array,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an array into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(new ArrayList<Double>(values.length),
                                    values,
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 S[] array,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an array into a map.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 S[] array,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an array into a map.

This will add all mapped elements to the target collection, using the incoming values as keys pointing to the converted values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             java.lang.Iterable<S> iterable,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iteration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(new ArrayList<Double>(values.length),
                                    Types.asList(values),
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.function.Consumer<? super T>,T,S> C map(@NotNull
                                                                                    C target,
                                                                                    @NotNull
                                                                                    java.lang.Iterable<S> iterable,
                                                                                    @NotNull
                                                                                    java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iteration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(new ArrayList<Double>(values.length),
                                    Types.asList(values),
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.lang.Iterable<S> iterable,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iteration into a map.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.lang.Iterable<S> iterable,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iteration into a map.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             java.util.Iterator<S> iterator,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator into a map.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator into a map.

This will add all mapped elements to the target collection, using the incoming values as keys pointing to the converted values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             java.util.Enumeration<S> enumeration,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Enumeration<S> enumeration,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Enumeration<S> enumeration,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <KT,VT,KS,VS> java.util.HashMap<KT,VT> map(@NotNull
                                                                  java.util.Map<KS,VS> source,
                                                                  @NotNull
                                                                  java.util.function.Function<java.util.Map.Entry<KS,VS>,java.util.Map.Entry<KT,VT>> typeConverter)

Map one map into another, while allowing to discard elements on the way.

An element is discarded if the type converter returns null.

Type Parameters:

KT - target map key type

VT - target map value type

KS - source map key type

VS - source map value type

Parameters:

source - source map

typeConverter - type converter converting map entries

Returns:

target map

map

@NotNull
public static <MT extends java.util.Map<KT,VT>,KT,VT,KS,VS> MT map(@NotNull
                                                                            MT target,
                                                                            @NotNull
                                                                            java.util.Map<KS,VS> source,
                                                                            @NotNull
                                                                            java.util.function.Function<java.util.Map.Entry<KS,VS>,? extends java.util.Map.Entry<KT,VT>> typeConverter)

Map one map into another, while allowing to discard elements on the way.

An element is discarded if the type converter returns null.

Type Parameters:

MT - target map type

KT - target map key type

VT - target map value type

KS - source map key type

VS - source map value type

Parameters:

target - target map

source - source map

typeConverter - type converter converting map entries

Returns:

target map

mapX

@NotNull
public static <KT,VT,KS,VS> java.util.HashMap<KT,VT> mapX(@NotNull
                                                                   java.util.Map<KS,VS> source,
                                                                   @NotNull
                                                                   java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,java.lang.Iterable<java.util.Map.Entry<KT,VT>>> typeConverter)

Map one map into another, while allowing to discard elements on the way.

An element is discarded if the type converter returns null.

Type Parameters:

KT - target map key type

VT - target map value type

KS - source map key type

VS - source map value type

Parameters:

source - source map

typeConverter - type converter converting map entries

Returns:

target map

mapX

@NotNull
public static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT mapX(@NotNull
                                                                                             MT target,
                                                                                             @NotNull
                                                                                             java.util.Map<KS,VS> source,
                                                                                             @NotNull
                                                                                             java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,? extends java.lang.Iterable<? extends java.util.Map.Entry<? extends KT,? extends VT>>> typeConverter)

Map one map into another, allowing to discard or add elements on the way.

Type Parameters:

MT - target map type

KT - target map key type

VT - target map value type

KS - source map key type

VS - source map value type

Parameters:

target - target map

source - source map

typeConverter - type converter converting map entries

Returns:

target map

filter

@NotNull
public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              T[] array,
                                                                              @NotNull
                                                                              java.util.function.Predicate<? super T> filter)

Filter the elements of an array into a collection.

This will add all filtered elements to the target collection.

Type Parameters:

C - collection type

T - filtered type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

filter - filter to decide which elements are kept, when returning true the element is kept, otherwise it is discarded

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              java.lang.Iterable<T> iterable,
                                                                              @NotNull
                                                                              java.util.function.Predicate<? super T> checker)

Filter the elements of an iterable into a collection.

This will add all filtered elements to the target collection.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - filtered type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              java.util.Iterator<T> iterator,
                                                                              @NotNull
                                                                              java.util.function.Predicate<? super T> checker)

Filter the elements of an iterator into a collection.

This will add all filtered elements to the target collection.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - filtered type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <C extends java.util.Collection<? super T>,T> C filter(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              java.util.Enumeration<T> enumeration,
                                                                              @NotNull
                                                                              java.util.function.Predicate<? super T> checker)

Filter the elements of an enumeration into a collection.

This will add all filtered elements to the target collection.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - filtered type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <T> java.util.LinkedList<T> filter(@NotNull
                                                          T[] array,
                                                          @NotNull
                                                          java.util.function.Predicate<? super T> checker)

Filter the elements of an array into a collection.

This will add all filtered elements to the target collection.

Type Parameters:

T - filtered type

Parameters:

array - array providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <T> java.util.LinkedList<T> filter(@NotNull
                                                          java.lang.Iterable<T> iterable,
                                                          @NotNull
                                                          java.util.function.Predicate<? super T> checker)

Filter the elements of an iterable into a collection.

This will add all filtered elements to the target collection.

Type Parameters:

T - filtered type

Parameters:

iterable - iterable providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <T> java.util.LinkedList<T> filter(@NotNull
                                                          java.util.Iterator<T> iterator,
                                                          @NotNull
                                                          java.util.function.Predicate<? super T> checker)

Filter the elements of an iterator into a collection.

This will add all filtered elements to the target collection.

Type Parameters:

T - filtered type

Parameters:

iterator - iterator providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filter

@NotNull
public static <T> java.util.LinkedList<T> filter(@NotNull
                                                          java.util.Enumeration<T> enumeration,
                                                          @NotNull
                                                          java.util.function.Predicate<? super T> checker)

Filter the elements of an enumeration into a result list.

Type Parameters:

T - filtered type

Parameters:

enumeration - enumeration providing the source elements

checker - value checker to decide which elements are kept

Returns:

reference to target, allowing to create it directly in the call

filterOut

public static <T> boolean filterOut(@NotNull
                                    java.lang.Iterable<T> iterable,
                                    @NotNull
                                    java.util.function.Predicate<? super T> outCheck)

Filter a modifiable iterable inline. This removes elements with certain properties from the iterable.

Type Parameters:

T - collection element type

Parameters:

iterable - modifiable iterable expected to provide an iterator which implements the Iterator.remove() method

outCheck - predicate which returns true for elements which are expected to be removed

Returns:

true if the collection was mdified
false if nothing was changed

Throws:

java.lang.RuntimeException - whatever the iterator of the iterable throws when calling its remove() method

any

public static <T> boolean any(@NotNull
                              T[] array,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does any element in the array fulfill the predicate?

This will check all array elements against the predicate, and return true on the first positive check.

Type Parameters:

T - checked type

Parameters:

array - array providing the source elements

checker - value checker

Returns:

true: if any of the elements of the array matches the predicate
false: if none of the elements matches or the array is empty

any

public static <T> boolean any(@NotNull
                              java.lang.Iterable<T> iterable,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does any element in the iterable fulfill the predicate?

This will check all elements against the predicate, and return true on the first positive check.

Type Parameters:

T - filtered type

Parameters:

iterable - iterable providing the source elements

checker - value checker

Returns:

true: if any of the elements of the array matches the predicate
false: if none of the elements matches or the iterable is empty

any

public static <T> boolean any(@NotNull
                              java.util.Iterator<T> iterator,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does any element of the iterator fulfill the predicate?

This will check all elements against the predicate, and return true on the first positive check.

Type Parameters:

T - filtered type

Parameters:

iterator - iterator providing the source elements

checker - value checker to decide which elements are kept

Returns:

true: if any of the elements of the array matches the predicate
false: if none of the elements matches or the iterator is empty

any

public static <T> boolean any(@NotNull
                              java.util.Enumeration<T> enumeration,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does any element of the enumeration fulfill the predicate?

This will check all elements against the predicate, and return true on the first positive check.

Type Parameters:

T - filtered type

Parameters:

enumeration - enumeration providing the source elements

checker - value checker to decide which elements are kept

Returns:

true: if any of the elements of the array matches the predicate
false: if none of the elements matches or the enumeration is empty

all

public static <T> boolean all(@NotNull
                              T[] array,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does every element in the array fulfill the predicate?

This will check all array elements against the predicate, and return false on the first negative check.

Type Parameters:

T - checked type

Parameters:

array - array providing the source elements

checker - value checker

Returns:

true: if all of the elements of the array match the predicate or the array is empty
false: if any of the elements does not match

all

public static <T> boolean all(@NotNull
                              java.lang.Iterable<T> iterable,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does every element in the iterable fulfill the predicate?

This will check all elements against the predicate, and return false on the first negative check.

Type Parameters:

T - filtered type

Parameters:

iterable - iterable providing the source elements

checker - value checker

Returns:

true: if all of the elements of the iterable match the predicate or the iterable is empty
false: if any of the elements does not match

all

public static <T> boolean all(@NotNull
                              java.util.Iterator<T> iterator,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does every element of the iterator fulfill the predicate?

This will check all elements against the predicate, and return false on the first negative check.

Type Parameters:

T - filtered type

Parameters:

iterator - iterator providing the source elements

checker - value checker to decide which elements are kept

Returns:

true: if all of the elements of the iterator match the predicate or the iterator is empty
false: if any of the elements does not match

all

public static <T> boolean all(@NotNull
                              java.util.Enumeration<T> enumeration,
                              @NotNull
                              java.util.function.Predicate<? super T> checker)

Does every element of the enumeration fulfill the predicate?

This will check all elements against the predicate, and return false on the first negative check.

Type Parameters:

T - filtered type

Parameters:

enumeration - enumeration providing the source elements

checker - value checker to decide which elements are kept

Returns:

true: if all of the elements of the enumeration match the predicate or the enumeration is empty
false: if any of the elements does not match

first

@Nullable
public static <T> T first(@NotNull
                                    java.lang.Iterable<T> iterable,
                                    @NotNull
                                    java.util.function.Predicate<? super T> checker)

Get the first element which fulfills a check.

Type Parameters:

T - element type

Parameters:

iterable - iterable

checker - value checker to decide which elements fit

Returns:

first matching element of null

last

@Nullable
public static <T> T last(@NotNull
                                   java.lang.Iterable<T> iterable,
                                   @NotNull
                                   java.util.function.Predicate<? super T> checker)

Get the last element which fulfills a check.

Type Parameters:

T - element type

Parameters:

iterable - iterable

checker - value checker to decide which elements fit

Returns:

last matching element of null

last

@Nullable
public static <T> T last(@NotNull
                                   java.util.List<T> list,
                                   @NotNull
                                   java.util.function.Predicate<? super T> checker,
                                   int startIndex)

Get the last element which fulfills a check.

Type Parameters:

T - element type

Parameters:

list - list to check

checker - value checker to decide which elements fit

startIndex - start index of search

Returns:

last matching element of null

foldLeft

public static <V,T> V foldLeft(@NotNull
                               T[] array,
                               V initialValue,
                               @NotNull
                               java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do left-associative folding of an array.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Eg to calculate the integer sum of an array of Numbers, you can use the following code

  Number[] array = { 1, Math.PI, 9L };
  double result = Types.foldLeft(array, 0.0,
                                new Function2<Double, Double, Number>() {
                                   public Double apply(Double arg1, Number arg2) {
                                     return arg1 + arg2.doubleValue();
                                   }
                                });
 

result will have a value of 13.14... after the call.

Type Parameters:

V - accumulated value type

T - array type

Parameters:

array - array which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldLeft

public static <V,T> V foldLeft(@NotNull
                               java.lang.Iterable<T> iterable,
                               V initialValue,
                               @NotNull
                               java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do left-associative folding of an iterable.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Eg to calculate the integer sum of an array of Numbers, you can use the following code

  Collection<Number> numbers = Types.<Number>asList(1, Math.PI, 9L);
  double result = Types.foldLeft(numbers, 0.0,
                                new Function2<Double, Double, Number>() {
                                   public Double apply(Double arg1, Number arg2) {
                                     return arg1 + arg2.doubleValue();
                                   }
                                });
 

result will have a value of 13.14... after the call.

Type Parameters:

V - accumulated value type

T - iterable type

Parameters:

iterable - iterable which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldLeft

public static <V,T> V foldLeft(@NotNull
                               java.util.Iterator<T> iterator,
                               V initialValue,
                               @NotNull
                               java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do left-associative folding of an iterator.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

See foldLeft(Iterable, Object, BiFunction) for a code example.

Type Parameters:

V - accumulated value type

T - iterable type

Parameters:

iterator - iterator which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldLeft

public static <V,T> V foldLeft(@NotNull
                               java.util.Enumeration<T> enumeration,
                               V initialValue,
                               @NotNull
                               java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do left-associative folding of an enumeration.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

See foldLeft(Iterable, Object, BiFunction) for a code example.

Type Parameters:

V - accumulated value type

T - iterable type

Parameters:

enumeration - enumeration which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldRight

public static <V,T> V foldRight(@NotNull
                                T[] array,
                                V initialValue,
                                @NotNull
                                java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do right-associative folding of an array.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Currently I have no useful example where right-folding in Java is making sense, so you should prefer foldLeft(Object[], Object, BiFunction).

Type Parameters:

V - accumulated value type

T - array type

Parameters:

array - array which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldRight

public static <V,T> V foldRight(@NotNull
                                java.lang.Iterable<T> iterable,
                                V initialValue,
                                @NotNull
                                java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do right-associative folding of an iterable.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Currently I have no useful example where right-folding in Java is making sense, so you should prefer foldLeft(Object[], Object, BiFunction), especially as the implementation for iterables is requiring an intermediate copy. If you really find a use for right-folding try to use the foldRight method working on a list, as it avoids the copy mentioned above.

Type Parameters:

V - accumulated value type

T - iterable type

Parameters:

iterable - iterable which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldRight

public static <V,T> V foldRight(@NotNull
                                java.util.Iterator<T> iterator,
                                V initialValue,
                                @NotNull
                                java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do right-associative folding of an iteration.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Currently I have no useful example where right-folding in Java is making sense, so you should prefer foldLeft(Iterable, Object, BiFunction), especially as the implementation for iteration is requiring an intermediate copy. If you really find a use for right-folding you should try to use the foldRight method working on a list, as it avoids the copy mentioned above.

Type Parameters:

V - accumulated value type

T - iterator type

Parameters:

iterator - iterator which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldRight

public static <V,T> V foldRight(@NotNull
                                java.util.Enumeration<T> enumeration,
                                V initialValue,
                                @NotNull
                                java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do right-associative folding of an enumeration.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Currently I have no useful example where right-folding in Java is making sense, so you should prefer foldLeft(java.util.Iterator, Object, BiFunction), especially as the implementation for iteration is requiring an intermediate copy. If you really find a use for right-folding you should try to use the foldRight method working on a list, as it avoids the copy mentioned above.

Type Parameters:

V - accumulated value type

T - enumeration type

Parameters:

enumeration - enumeration which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldRight

public static <V,T> V foldRight(@NotNull
                                java.util.List<T> list,
                                V initialValue,
                                @NotNull
                                java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do right-associative folding of a list.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Currently I have no useful example where right-folding in Java is making sense, so you should prefer foldLeft(java.util.Enumeration, Object, BiFunction), especially as the implementation for iteration is requiring an intermediate copy.

Type Parameters:

V - accumulated value type

T - list type

Parameters:

list - list which elements are folded together

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

foldRight

public static <V,T> V foldRight(@NotNull
                                java.util.ListIterator<T> reverseIterator,
                                V initialValue,
                                @NotNull
                                java.util.function.BiFunction<? super V,? super T,? extends V> folder)

Do right-associative folding of a list iterator using it in reverse direction.

Folding is the reduction of the elements of a collection into one value, by applying the same function on each element with the result of the last call.

Currently I have no useful example where right-folding in Java is making sense, so you should prefer foldLeft(Iterable, Object, BiFunction), especially as the implementation for iteration is requiring an intermediate copy.

Type Parameters:

V - accumulated value type

T - list type

Parameters:

reverseIterator - iterator which is traverse in reverse direction

initialValue - start value

folder - folding function, the apply method gets the accumulated value as its first and the element as its second argument, and returns the result of their combination

Returns:

accumulated value

mapX

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              S[] array,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an array into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(new ArrayList<Double>(values.length),
                                    values,
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapX

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              java.lang.Iterable<S> iterable,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an iteration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(new ArrayList<Double>(values.length),
                                    Types.asList(values),
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapX

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              java.util.Iterator<S> iterator,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapX

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapX(@NotNull
                                                                              C target,
                                                                              @NotNull
                                                                              java.util.Enumeration<S> enumeration,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         java.lang.Iterable<S> iterable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an iterable.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(Types.asList(values),
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

map

@NotNull
public static <T,S> java.util.ArrayList<T> map(@NotNull
                                                        java.util.Collection<S> collection,
                                                        @NotNull
                                                        java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of a collection.

This method has the advantage that the size of the collection is known, so an ArrayList is used for the resulting collection.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source target

Parameters:

collection - collection to be mapped

typeConverter - type converter doing the mapping

Returns:

linked list with mapping results

map

@NotNull
public static <T,S> java.util.ArrayList<T> map(@NotNull
                                                        Countable<S> countable,
                                                        @NotNull
                                                        java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of a countable.

This method has the advantage that the size of the countable is known, so an ArrayList is used for the resulting collection.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source target

Parameters:

countable - collection to be mapped

typeConverter - type converter doing the mapping

Returns:

linked list with mapping results

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         java.lang.Iterable<S> iterable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an iterable as a hash map..

The converted values will become keys, pointing to the associated incoming values.

See mapM(java.util.Map, Iterable, Function) for a method which allows to define the result map.

See mapM(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         java.lang.Iterable<S> iterable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an iterable as a hash map..

The incoming values will become keys, pointing to the associated converted values.

See mapR(java.util.Map, Iterable, Function) for a method which allows to define the result map.

See mapR(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

map

@NotNull
public static <T,S> java.util.ArrayList<T> map(@NotNull
                                                        S[] array,
                                                        @NotNull
                                                        java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an array.

See map(java.util.Collection, Object[], Function) for a method which allows to define the result collection.

See map(Object[], Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(values,
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         S[] array,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an array as a map.

The converted values will become keys, pointing to the associated incoming values.

See mapM(java.util.Map, Object[], Function) for a method which allows to define the result collection.

See mapM(Object[], Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         S[] array,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an array as a map.

The incoming values will become keys, pointing to the associated converted values.

See mapR(java.util.Map, Object[], Function) for a method which allows to define the result collection.

See mapR(Object[], Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         java.util.Iterator<S> iterator,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an iterator.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

See map(Iterable, Function) for an easy to adapt example.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

See Also:

view(java.util.Iterator, Function)

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         java.util.Iterator<S> iterator,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an iterator as a map.

The converted values will become keys, pointing to the associated incoming values.

See mapM(java.util.Map, Iterable, Function) for a method which allows to define the result collection.

See mapM(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         java.util.Iterator<S> iterator,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Get the mapped elements of an iterator as a map.

The incoming values will become keys, pointing to the associated converted values.

See mapR(java.util.Map, Iterable, Function) for a method which allows to define the result collection.

See mapR(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         java.util.Enumeration<S> enumeration,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         java.util.Enumeration<S> enumeration,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a map.

The converted values will become keys, pointing to the associated incoming values.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         java.util.Enumeration<S> enumeration,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a map.

The incoming values will become keys, pointing to the associated converted values.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapX

@NotNull
public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                          java.lang.Iterable<S> iterable,
                                                          @NotNull
                                                          java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Get the mapped elements of an iterable.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(Types.asList(values),
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapX

@NotNull
public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                          S[] array,
                                                          @NotNull
                                                          java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Get the mapped elements of an array.

See map(java.util.Collection, Object[], Function) for a method which allows to define the result collection.

See map(Object[], Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(values,
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapX

@NotNull
public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                          java.util.Iterator<S> iterator,
                                                          @NotNull
                                                          java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Get the mapped elements of an iterator.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

See map(Iterable, Function) for an easy to adapt example.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

mapX

@NotNull
public static <T,S> java.util.LinkedList<T> mapX(@NotNull
                                                          java.util.Enumeration<S> enumeration,
                                                          @NotNull
                                                          java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an enumeration into a collection.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             S[] array,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter,
                                                                             @Nullable
                                                                             T deleteMark)

Add the mapped elements of an array into a collection.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 S[] array,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an array into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 S[] array,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an array into a map.

The incoming values will become keys, pointing to the associated mapped values.

This method allows to discard elements during the mapping.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             java.lang.Iterable<S> iterable,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter,
                                                                             @Nullable
                                                                             T deleteMark)

Add the mapped elements of an iteration into a collection.

This method allows to discard elements during the mapping.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.function.Consumer<? super T>,T,S> C map(@NotNull
                                                                                    C target,
                                                                                    @NotNull
                                                                                    java.lang.Iterable<S> iterable,
                                                                                    @NotNull
                                                                                    java.util.function.Function<? super S,T> typeConverter,
                                                                                    @Nullable
                                                                                    T deleteMark)

Add the mapped elements of an iteration to a consumer.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - consumer applied to each mapped element

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.lang.Iterable<S> iterable,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an iteration into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.lang.Iterable<S> iterable,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an iteration into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             java.util.Iterator<S> iterator,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter,
                                                                             @Nullable
                                                                             T deleteMark)

Add the mapped elements of an iterator into a collection.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.function.Consumer<? super T>,T,S> C map(@NotNull
                                                                                    C target,
                                                                                    @NotNull
                                                                                    java.util.Iterator<S> iterator,
                                                                                    @NotNull
                                                                                    java.util.function.Function<? super S,T> typeConverter,
                                                                                    @Nullable
                                                                                    T deleteMark)

Add the mapped elements of an iterator to a consumer.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - consumer to which all mapped elements are forwarded

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an iterator into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an iterator into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C map(@NotNull
                                                                             C target,
                                                                             @NotNull
                                                                             java.util.Enumeration<S> enumeration,
                                                                             @NotNull
                                                                             java.util.function.Function<? super S,T> typeConverter,
                                                                             @Nullable
                                                                             T deleteMark)

Add the mapped elements of an enumeration into a collection.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapM(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Enumeration<S> enumeration,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an enumeration into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapR

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapR(@NotNull
                                                                                 M target,
                                                                                 @NotNull
                                                                                 java.util.Enumeration<S> enumeration,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Add the mapped elements of an enumeration into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         S[] array,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Get the mapped elements of an array.

This method allows to discard elements during the mapping.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(values,
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapping results

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         S[] array,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Get the mapped elements of an array as a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         S[] array,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Get the mapped elements of an array as a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         java.lang.Iterable<S> iterable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Get the mapped elements of an iterable.

This method allows to discard elements during the mapping.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979", "foobar" };
    List<Double> result = Types.map(Types.asList(values),
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        try {
                                          return Double.parseDouble(object);
                                        } catch (NumberFormatException x) {
                                          return null; // delete mark, compare last parameter
                                        }
                                      }
                                    },
                                    null);
 

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapping results

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         java.lang.Iterable<S> iterable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Get the mapped elements of an iterable to a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         java.lang.Iterable<S> iterable,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Get the mapped elements of an iterable to a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         java.util.Iterator<S> iterator,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Add the mapped elements of an iterator into a collection.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapping results

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         java.util.Iterator<S> iterator,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Add the mapped elements of an iterator into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         java.util.Iterator<S> iterator,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Add the mapped elements of an iterator into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

map

@NotNull
public static <T,S> java.util.LinkedList<T> map(@NotNull
                                                         java.util.Enumeration<S> enumeration,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Add the mapped elements of an enumeration into a collection.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapM

@NotNull
public static <T,S> java.util.HashMap<T,S> mapM(@NotNull
                                                         java.util.Enumeration<S> enumeration,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Add the mapped elements of an enumeration into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

result map

mapR

@NotNull
public static <T,S> java.util.HashMap<S,T> mapR(@NotNull
                                                         java.util.Enumeration<S> enumeration,
                                                         @NotNull
                                                         java.util.function.Function<? super S,T> typeConverter,
                                                         @Nullable
                                                         T deleteMark)

Add the mapped elements of an enumeration into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

result map

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           S[] array,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Object[], FragileFunction1) instead which does not require handling a TypeConverterException

Add the mapped elements of an array into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Example:

    // convert an array of strings containing double values into a collection of doubles
    String[] values = { "1.2", "-7.07", "3.14250255358979" };
    List<Double> result = Types.map(new ArrayList<Double>(values.length),
                                    values,
                                    new Function1<Double, String>() {
                                      public Double convert(String object) {
                                        return Double.parseDouble(object);
                                      }
                                    });
 

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          S[] array,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an array into a collection by using a mapper function which might throw a checked exception.

Type Parameters:

C - type of returned collection

T - target (mapped) element type

S - source element type

E - exception type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

mapper - mapper function converting the source elements into the target elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - mapper exception

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  S[] array,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an array into a map.

The converted values will become keys, pointing to the associated incoming values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  S[] array,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an array into a map.

The incoming values will become keys, pointing to the associated converted values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           java.lang.Iterable<S> iterable,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Iterable, FragileFunction1) instead which does not require handling a TypeConverterException

Add the mapped elements of an iteration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          java.lang.Iterable<S> iterable,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an iterable into a collection by using a mapper function which might throw a checked exception.

Type Parameters:

C - type of returned collection

T - target (mapped) element type

S - source element type

E - exception type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

mapper - mapper function converting the source elements into the target elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - mapper exception

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.lang.Iterable<S> iterable,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an iteration into a map.

The converted values will become keys, pointing to the associated incoming values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.lang.Iterable<S> iterable,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an iteration into a map.

The incoming values will become keys, pointing to the associated converted values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           java.util.Iterator<S> iterator,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Iterator, FragileFunction1) instead which does not require handling a TypeConverterException

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          java.util.Iterator<S> iterator,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an iterator into a collection by using a mapper function which might throw a checked exception.

Type Parameters:

C - type of returned collection

T - target (mapped) element type

S - source element type

E - exception type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

mapper - mapper function converting the source elements into the target elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - mapper exception

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Iterator<S> iterator,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an iterator to a map.

The converted values will become keys, pointing to the associated incoming values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Iterator<S> iterator,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an iterator to a map.

The incoming values will become keys, pointing to the associated converted values.

This will add all mapped elements to the target map. See mapR(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<S> enumeration,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Enumeration, FragileFunction1) instead which does not require handling a TypeConverterException

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          java.util.Enumeration<S> enumeration,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an enumeration into a collection by using a mapper function which might throw a checked exception.

Type Parameters:

C - type of returned collection

T - target (mapped) element type

S - source element type

E - exception type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

mapper - mapper function converting the source elements into the target elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - mapper exception

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Enumeration<S> enumeration,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The converted values will become keys, pointing to the associated incoming values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Enumeration<S> enumeration,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter)
                                                                           throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The incoming values will become keys, pointing to the associated converted values.

This will add all mapped elements to the target map. See mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       java.lang.Iterable<S> iterable,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Iterable, FragileFunction1) instead which does not require handling a TypeConverterException

Get the mapped elements of an iterable.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                              java.lang.Iterable<S> iterable,
                                                                                              @NotNull
                                                                                              FragileFunction1<? extends T,E,? super S> mapper)
                                                                                       throws E extends java.lang.Exception

Get the mapped elements of an iterable while using a mapper which might throw a checked exception.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

iterable - iterable providing the source elements

mapper - mapper converting the source elements into the target elements

Returns:

linked list with mapping results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          java.lang.Iterable<S> iterable,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Get the mapped elements of an iterable as a map.

The converted values will become keys, pointing to the associated incoming values.

See mapM(java.util.Map, Iterable, Function) for a method which allows to define the result map.

See mapM(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          java.lang.Iterable<S> iterable,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Get the mapped elements of an iterable as a map.

The incoming values will become keys, pointing to the associated converted values.

See mapR(java.util.Map, Iterable, Function) for a method which allows to define the result map.

See mapR(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       S[] array,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Object[], FragileFunction1) instead which does not require handling a TypeConverterException

Get the mapped elements of an array.

See map(java.util.Collection, Object[], Function) for a method which allows to define the result collection.

See map(Object[], Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                             S[] array,
                                                                                             @NotNull
                                                                                             FragileFunction1<? extends T,E,? super S> mapper)
                                                                                      throws E extends java.lang.Exception

Get the mapped elements of an array while using a mapper which might throw a checked exception.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

array - array providing the source elements

mapper - mapper converting the source elements into the target elements

Returns:

array list with mapping results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                             java.util.Collection<S> collection,
                                                                                             @NotNull
                                                                                             FragileFunction1<? extends T,E,? super S> mapper)
                                                                                      throws E extends java.lang.Exception

Get the mapped elements of a collection while using a mapper which might throw a checked exception.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

collection - collection providing the source elements

mapper - mapper converting the source elements into the target elements

Returns:

array list with mapping results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                             Countable<S> countable,
                                                                                             @NotNull
                                                                                             FragileFunction1<? extends T,E,? super S> mapper)
                                                                                      throws E extends java.lang.Exception

Get the mapped elements of an array while using a mapper which might throw a checked exception.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

countable - countable providing the source elements

mapper - mapper converting the source elements into the target elements

Returns:

array list with mapping results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                              java.util.Iterator<S> iterator,
                                                                                              @NotNull
                                                                                              FragileFunction1<? extends T,E,? super S> mapper)
                                                                                       throws E extends java.lang.Exception

Get the mapped elements of an iterator while using a mapper which might throw a checked exception.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

iterator - iterator providing the source elements, consumed after the call

mapper - mapper converting the source elements into the target elements

Returns:

linked list with mapping results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                              java.util.Enumeration<S> enumeration,
                                                                                              @NotNull
                                                                                              FragileFunction1<? extends T,E,? super S> mapper)
                                                                                       throws E extends java.lang.Exception

Get the mapped elements of an enumeration while using a mapper which might throw a checked exception.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

enumeration - enumeration providing the source elements, consumed after the call

mapper - mapper converting the source elements into the target elements

Returns:

linked list with mapping results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          S[] array,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Get the mapped elements of an array as a map.

The converted values will become keys, pointing to the associated incoming values.

See mapM(java.util.Map, Object[], Function) for a method which allows to define the result map.

See mapM(Object[], Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          S[] array,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Get the mapped elements of an array as a map.

The incoming values will become keys, pointing to the associated converted values.

See mapR(java.util.Map, Object[], Function) for a method which allows to define the result map.

See mapR(Object[], Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       java.util.Iterator<S> iterator,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Iterator, FragileFunction1) instead which does not require handling a TypeConverterException

Get the mapped elements of an iterator.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

See map(Iterable, Function) for an easy to adapt example.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          java.util.Iterator<S> iterator,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Get the mapped elements of an iterator as a map.

The converted values will become keys, pointing to the associated incoming values.

See mapM(java.util.Map, Iterable, Function) for a method which allows to define the result map.

See mapM(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          java.util.Iterator<S> iterator,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Get the mapped elements of an iterator as a map.

The incoming values will become keys, pointing to the associated converted values.

See mapR(java.util.Map, Iterable, Function) for a method which allows to define the result map.

See mapR(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       java.util.Enumeration<S> enumeration,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Enumeration, FragileFunction1) instead which does not require handling a TypeConverterException

Add the mapped elements of an enumeration into a collection.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with converted elements

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          java.util.Enumeration<S> enumeration,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Add the mapped elements of an enumeration into a map.

The converted values will become keys, pointing to the associated incoming values.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with converted elements

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          java.util.Enumeration<S> enumeration,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter)
                                                   throws TypeConverterException

Add the mapped elements of an enumeration into a map.

The incoming values will become keys, pointing to the associated converted values.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

map with converted elements

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               S[] array,
                                                                               @NotNull
                                                                               FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an array into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.lang.Iterable<S> iterable,
                                                                               @NotNull
                                                                               FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an iteration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.util.Iterator<S> iterator,
                                                                               @NotNull
                                                                               FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <C extends java.util.Collection<? super T>,T,S> C mapXE(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.util.Enumeration<S> enumeration,
                                                                               @NotNull
                                                                               FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                           java.lang.Iterable<S> iterable,
                                                           @NotNull
                                                           FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                    throws TypeConverterException

Get the mapped elements of an iterable.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                           S[] array,
                                                           @NotNull
                                                           FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                    throws TypeConverterException

Get the mapped elements of an array.

See map(java.util.Collection, Object[], Function) for a method which allows to define the result collection.

See map(Object[], Function, Object) for a method which allows to discard elements.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                           java.util.Iterator<S> iterator,
                                                           @NotNull
                                                           FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                    throws TypeConverterException

Get the mapped elements of an iterator.

See map(java.util.Collection, Iterable, Function) for a method which allows to define the result collection.

See map(Iterable, Function, Object) for a method which allows to discard elements.

See map(Iterable, Function) for an easy to adapt example.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXE

@NotNull
public static <T,S> java.util.LinkedList<T> mapXE(@NotNull
                                                           java.util.Enumeration<S> enumeration,
                                                           @NotNull
                                                           FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                    throws TypeConverterException

Add the mapped elements of an enumeration into a collection.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           S[] array,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Object[], FragileFunction1, Object) instead which does not require handling a TypeConverterException

Add the mapped elements of an array into a collection.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          S[] array,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                          @Nullable
                                                                                                          T deleteMark)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an array into a collection while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

E - exception type

Parameters:

target - collection where the mapped elements are added

array - array providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  S[] array,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an array into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  S[] array,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an array into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           java.lang.Iterable<S> iterable,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Iterable, FragileFunction1, Object) instead which does not require handling a TypeConverterException

Add the mapped elements of an iteration into a collection.

This method allows to discard elements during the mapping.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          java.lang.Iterable<S> iterable,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                          @Nullable
                                                                                                          T deleteMark)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an iterable into a collection while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

E - exception type

Parameters:

target - collection where the mapped elements are added

iterable - iterable providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.lang.Iterable<S> iterable,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an iteration into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (converted) type

S - source type

Parameters:

target - map where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.lang.Iterable<S> iterable,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an iteration into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that target and iterable are not allowed to be the same object, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (converted) type

S - source type

Parameters:

target - map where the mapped elements are added

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           java.util.Iterator<S> iterator,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Iterator, FragileFunction1, Object) instead which does not require handling a TypeConverterException

Add the mapped elements of an iterator into a collection.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          java.util.Iterator<S> iterator,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                          @Nullable
                                                                                                          T deleteMark)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an iterator into a collection while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

E - exception type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Iterator<S> iterator,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an iterator into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Iterator<S> iterator,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an iterator into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <C extends java.util.Collection<? super T>,T,S> C mapE(@NotNull
                                                                                           C target,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<S> enumeration,
                                                                                           @NotNull
                                                                                           FragileTypeConverter<T,? super S> typeConverter,
                                                                                           @Nullable
                                                                                           T deleteMark)
                                                                                    throws TypeConverterException

Deprecated. use mapFragile(Collection, Enumeration, FragileFunction1, Object) instead which does not require handling a TypeConverterException

Add the mapped elements of an enumeration into a collection.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <C extends java.util.Collection<T>,T,S,E extends java.lang.Exception> C mapFragile(@NotNull
                                                                                                          C target,
                                                                                                          @NotNull
                                                                                                          java.util.Enumeration<S> enumeration,
                                                                                                          @NotNull
                                                                                                          FragileFunction1<? extends T,E,? super S> mapper,
                                                                                                          @Nullable
                                                                                                          T deleteMark)
                                                                                                   throws E extends java.lang.Exception

Add the mapped elements of an enumeration into a collection while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

E - exception type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <M extends java.util.Map<? super T,? super S>,T,S> M mapME(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Enumeration<S> enumeration,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <M extends java.util.Map<? super S,? super T>,T,S> M mapRE(@NotNull
                                                                                  M target,
                                                                                  @NotNull
                                                                                  java.util.Enumeration<S> enumeration,
                                                                                  @NotNull
                                                                                  FragileTypeConverter<T,? super S> typeConverter,
                                                                                  @Nullable
                                                                                  T deleteMark)
                                                                           throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       S[] array,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter,
                                                                       @Nullable
                                                                       T deleteMark)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Object[], FragileFunction1, Object) instead which does not require handling a TypeConverterException

Get the mapped elements of an array.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.ArrayList<T> mapFragile(@NotNull
                                                                                             S[] array,
                                                                                             @NotNull
                                                                                             FragileFunction1<? extends T,E,? super S> mapper,
                                                                                             @Nullable
                                                                                             T deleteMark)
                                                                                      throws E extends java.lang.Exception

Get the mapped elements of an array while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

array - array providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          S[] array,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Get the mapped elements of an array as a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          S[] array,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Get the mapped elements of an array as a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

array - array providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       java.lang.Iterable<S> iterable,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter,
                                                                       @Nullable
                                                                       T deleteMark)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Iterable, FragileFunction1, Object) instead which does not require handling a TypeConverterException

Get the mapped elements of an iterable.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                              java.lang.Iterable<S> iterable,
                                                                                              @NotNull
                                                                                              FragileFunction1<? extends T,E,? super S> mapper,
                                                                                              @Nullable
                                                                                              T deleteMark)
                                                                                       throws E extends java.lang.Exception

Get the mapped elements of an iterable while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

iterable - iterable providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

mapped and filtered results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          java.lang.Iterable<S> iterable,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Get the mapped elements of an iterable as a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          java.lang.Iterable<S> iterable,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Get the mapped elements of an iterable as a map.

The incoming values will become keys, pointing to the associated convereted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterable - iterable providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       java.util.Iterator<S> iterator,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter,
                                                                       @Nullable
                                                                       T deleteMark)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Iterator, FragileFunction1, Object) instead which does not require handling a TypeConverterException

Add the mapped elements of an iterator into a collection.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                              java.util.Iterator<S> iterator,
                                                                                              @NotNull
                                                                                              FragileFunction1<? extends T,E,? super S> mapper,
                                                                                              @Nullable
                                                                                              T deleteMark)
                                                                                       throws E extends java.lang.Exception

Get the mapped elements of an iterator while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

iterator - iterator providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

mapped and filtered results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          java.util.Iterator<S> iterator,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Add the mapped elements of an iterator into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          java.util.Iterator<S> iterator,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Add the mapped elements of an iterator into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapE

@NotNull
 @Deprecated
public static <T,S> java.util.LinkedList<T> mapE(@NotNull
                                                                       java.util.Enumeration<S> enumeration,
                                                                       @NotNull
                                                                       FragileTypeConverter<T,? super S> typeConverter,
                                                                       @Nullable
                                                                       T deleteMark)
                                                                throws TypeConverterException

Deprecated. use mapFragile(Enumeration, FragileFunction1, Object) instead which does not require handling a TypeConverterException

Add the mapped elements of an enumeration into a collection.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

linked list with mapped elements

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapFragile

@NotNull
public static <T,S,E extends java.lang.Exception> java.util.LinkedList<T> mapFragile(@NotNull
                                                                                              java.util.Enumeration<S> enumeration,
                                                                                              @NotNull
                                                                                              FragileFunction1<? extends T,E,? super S> mapper,
                                                                                              @Nullable
                                                                                              T deleteMark)
                                                                                       throws E extends java.lang.Exception

Get the mapped elements of an enumeration while using a mapper which might throw an exception.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

E - exception type

Parameters:

enumeration - enumeration providing the source elements

mapper - fragile mapper for converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

mapped and filtered results

Throws:

E - if the mapper throws

E extends java.lang.Exception

mapME

@NotNull
public static <T,S> java.util.HashMap<T,S> mapME(@NotNull
                                                          java.util.Enumeration<S> enumeration,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapRE

@NotNull
public static <T,S> java.util.HashMap<S,T> mapRE(@NotNull
                                                          java.util.Enumeration<S> enumeration,
                                                          @NotNull
                                                          FragileTypeConverter<T,? super S> typeConverter,
                                                          @Nullable
                                                          T deleteMark)
                                                   throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Type Parameters:

T - target (mapped) type

S - source type

Parameters:

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

map with mapping results

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

forEach

public static <T> void forEach(@NotNull
                               T[] array,
                               @NotNull
                               LoopItemHandler<? super T> handler)

Call a handler for each item in an array.

Type Parameters:

T - item type

Parameters:

array - array to loop over

handler - item handler which is called for each item

forEach

public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                             T[] array,
                                                             @NotNull
                                                             FragileLoopItemHandler<? super T,E> handler)
                                                      throws E extends java.lang.Exception

Call a handler for each item in an array.

Type Parameters:

T - item type

E - exception type

Parameters:

array - array to loop over

handler - item handler which is called for each item

Throws:

E - exception thrown by handler

E extends java.lang.Exception

forEach

public static <T> void forEach(@NotNull
                               java.lang.Iterable<T> iterable,
                               @NotNull
                               LoopItemHandler<? super T> handler)

Call a handler for each item in an iterable.

Type Parameters:

T - item type

Parameters:

iterable - iterable to loop over

handler - item handler which is called for each item

forEach

public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                             java.lang.Iterable<T> iterable,
                                                             @NotNull
                                                             FragileLoopItemHandler<? super T,E> handler)
                                                      throws E extends java.lang.Exception

Call a handler for each item in an iterable.

Type Parameters:

T - item type

E - exception thrown by handler

Parameters:

iterable - iterable to loop over

handler - item handler which is called for each item

Throws:

E - exception thrown by handler

E extends java.lang.Exception

forEach

public static <T> void forEach(@NotNull
                               java.util.Iterator<T> iterator,
                               @NotNull
                               LoopItemHandler<? super T> handler)

Call a handler for each item in an iterator.

Type Parameters:

T - item type

Parameters:

iterator - iterator to loop over

handler - item handler which is called for each item

forEach

public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                             java.util.Iterator<T> iterator,
                                                             @NotNull
                                                             FragileLoopItemHandler<? super T,E> handler)
                                                      throws E extends java.lang.Exception

Call a handler for each item in an iterator

Type Parameters:

T - item type

E - exception thrown by handler

Parameters:

iterator - iterator to loop over

handler - item handler which is called for each item

Throws:

E - exception thrown by handler

E extends java.lang.Exception

forEach

public static <T> void forEach(@NotNull
                               java.util.Enumeration<T> enumeration,
                               @NotNull
                               LoopItemHandler<? super T> handler)

Call a handler for each item in an enumeration.

Type Parameters:

T - item type

Parameters:

enumeration - enumeration to loop over

handler - item handler which is called for each item

forEach

public static <T,E extends java.lang.Exception> void forEach(@NotNull
                                                             java.util.Enumeration<T> enumeration,
                                                             @NotNull
                                                             FragileLoopItemHandler<? super T,E> handler)
                                                      throws E extends java.lang.Exception

Call a handler for each item in an enumeration

Type Parameters:

T - item type

E - exception thrown by handler

Parameters:

enumeration - enumeration to loop over

handler - item handler which is called for each item

Throws:

E - exception thrown by handler

E extends java.lang.Exception

forEachFragile

public static <T,E extends java.lang.Exception> void forEachFragile(@NotNull
                                                                    java.lang.Iterable<T> iterable,
                                                                    @NotNull
                                                                    FragileProcedure1<E,? super T> consumer)
                                                             throws E extends java.lang.Exception

Foreach implementation which can be used with consumers which might throw a checked exception. Use this instead of Iterable.forEach(Consumer) when the consumer is defined with a checked exception.

Type Parameters:

T - element type

E - exception type

Parameters:

iterable - iterable to iterate over

consumer - consumer called for each iterated element

Throws:

E - forwarded exception of the consumer

E extends java.lang.Exception

forEachRemainingFragile

public static <T,E extends java.lang.Exception> void forEachRemainingFragile(@NotNull
                                                                             java.util.Iterator<T> iterator,
                                                                             @NotNull
                                                                             FragileProcedure1<E,? super T> consumer)
                                                                      throws E extends java.lang.Exception

Foreach remaining implementation which can be used with consumers which might throw a checked exception. Use this instead of Iterator.forEachRemaining(Consumer) when the consumer is defined with a checked exception.

Type Parameters:

T - element type

E - exception type

Parameters:

iterator - iterator for which all remaining elements are consumed

consumer - consumer called for each remaining element

Throws:

E - forwarded exception of the consumer

E extends java.lang.Exception

toLoopItemHandler

@NotNull
public static <T,E extends java.lang.Exception,L extends FragileLoopItemHandler<T,E>> CarelessLoopItemHandler<T,E,L> toLoopItemHandler(L handler)

Wrap a careful loop item handler as a simple loop item handler.

Type Parameters:

T - item type

E - exception type

L - careful loop item handler type

Parameters:

handler - handler to wrap

Returns:

careless loop item handler wrapper

asList

@NotNull
 @SafeVarargs
public static <T> java.util.List<T> asList(@NotNull
                                                                  T... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list returned from this method, so the safest use is as a temporary object.

    public void method(Collection<Double> input) {
      // ...
    }

    // ...
    method(Types.asList(0, 7.1, -42, Math.PI));
 

Type Parameters:

T - element type of array and list

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

asList

@NotNull
public static <T> java.util.List<T> asList(@NotNull
                                                    T[] array,
                                                    int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Type Parameters:

T - element type of array and list

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

asList

@NotNull
public static <T> java.util.List<T> asList(@NotNull
                                                    T[] array,
                                                    int start,
                                                    int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Type Parameters:

T - element type of array and list

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toBooleanArray

@NotNull
public static boolean[] toBooleanArray(@NotNull
                                                java.util.Collection<java.lang.Boolean> c)

Convert a collection of Booleans to a raw array of booleans.

Parameters:

c - collection of Booleans

Returns:

array of boolean

See Also:

BooleanIndexable.viewList(List)

toBooleanArray

public static boolean[] toBooleanArray(@NotNull
                                       Countable<java.lang.Boolean> c)

Convert a countable of Booleans to a raw array of booleans.

Parameters:

c - collection of Booleans

Returns:

array of boolean

toList

@NotNull
public static <T> java.util.LinkedList<T> toList(@NotNull
                                                          java.util.Enumeration<T> enumeration)

Collect an enumeration into a linked list. This will propagate over the complete enumeration, so it can no longer be enumerated after calling this method.

Type Parameters:

T - type of enumeration and result list elements

Parameters:

enumeration - enumeration to convert

Returns:

linked list with all elements of the enumeration

See Also:

addAll(Collection, Enumeration)

toList

@NotNull
public static <T> java.util.LinkedList<T> toList(@NotNull
                                                          java.util.Iterator<T> iterator)

Collect an iterator into a linked list. This will propagate over the complete iterator, so it can no longer be iterated over after calling this method.

Type Parameters:

T - type of iterator and result list elements

Parameters:

iterator - iterator to convert

Returns:

linked list with all elements of the iterator

See Also:

addAll(Collection, Iterator)

toList

@NotNull
public static <T> java.util.LinkedList<T> toList(@NotNull
                                                          java.lang.Iterable<T> iterable)

Collect the elements of an iterable into a linked list.

Type Parameters:

T - type of iterable and result list elements

Parameters:

iterable - iterable to convert

Returns:

list with all elements of the iterable

See Also:

addAll(Collection, Iterable)

toStringList

@NotNull
public static java.util.LinkedList<java.lang.String> toStringList(@NotNull
                                                                           java.util.Enumeration<?> enumeration)

Collect an enumeration into a linked list of strings. This will propagate over the complete enumeration and call @linkObject.toString(), on its elements, so it can no longer be enumerated after calling this method.

Parameters:

enumeration - enumeration to convert

Returns:

linked list with all stringified elements of the enumeration

toStringList

@NotNull
public static java.util.LinkedList<java.lang.String> toStringList(@NotNull
                                                                           java.util.Iterator<?> iterator)

Collect an iterator into a linked list of strings. This will propagate over the complete iterator and call @linkObject.toString(), on its elements, so it can no longer be iterated over after calling this method.

Parameters:

iterator - iterator to convert

Returns:

linked list with all stringified elements of the iterator

toStringList

@NotNull
public static java.util.LinkedList<java.lang.String> toStringList(@NotNull
                                                                           java.lang.Iterable<?> iterable)

Collect the elements of an iterable into a linked list. This will propagate over the complete iterable and call @linkObject.toString() on its elements

Parameters:

iterable - iterable to convert

Returns:

list with all stringified elements of the iterable

toList

@NotNull
public static java.util.List<java.lang.Boolean> toList(@NotNull
                                                                boolean... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

    public void method(Collection<Double> input) {
      // ...
    }

    // ...
    method(Types.toList(0, 7.1, -42, Math.PI));
  

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Boolean> toList(@NotNull
                                                                boolean[] array,
                                                                int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Boolean> toList(@NotNull
                                                                boolean[] array,
                                                                int start,
                                                                int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toByteArray

@NotNull
public static byte[] toByteArray(@NotNull
                                          java.util.Collection<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of bytes.

Parameters:

c - collection of Numbers

Returns:

array of bytes

See Also:

ByteIndexable.viewList(List)

toByteArray

@NotNull
public static byte[] toByteArray(@NotNull
                                          Countable<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of bytes.

Parameters:

c - collection of Numbers

Returns:

array of bytes

toByteArray

public static byte[] toByteArray(int... bytes)

Convert a number of bytes into a byte array. This is a convenience method allowing to use integer values.

Parameters:

bytes - values which will be converted into bytes

Returns:

byte array

toList

@NotNull
public static java.util.List<java.lang.Byte> toList(@NotNull
                                                             byte... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Byte> toList(@NotNull
                                                             byte[] array,
                                                             int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Byte> toList(@NotNull
                                                             byte[] array,
                                                             int start,
                                                             int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toShortArray

@NotNull
public static short[] toShortArray(@NotNull
                                            java.util.Collection<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of shorts.

Parameters:

c - collection of Numbers

Returns:

array of shorts

See Also:

ShortIndexable.viewList(List)

toShortArray

public static short[] toShortArray(@NotNull
                                   Countable<? extends java.lang.Number> c)

Convert a countable of Numbers to a raw array of shorts.

Parameters:

c - countable of Numbers

Returns:

array of shorts

toList

@NotNull
public static java.util.List<java.lang.Short> toList(@NotNull
                                                              short... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

See Also:

ShortIndexable.viewArray(short...)

toList

@NotNull
public static java.util.List<java.lang.Short> toList(@NotNull
                                                              short[] array,
                                                              int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Short> toList(@NotNull
                                                              short[] array,
                                                              int start,
                                                              int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

See Also:

ShortIndexable.viewArray(short[], int, int)

toIntArray

public static int[] toIntArray(@NotNull
                               java.util.Collection<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of ints.

Parameters:

c - collection of Numbers

Returns:

array of ints

See Also:

IntIndexable.viewList(List)

toIntArray

public static int[] toIntArray(@NotNull
                               Countable<? extends java.lang.Number> c)

Convert a countable of Numbers to a raw array of ints.

Parameters:

c - countable Numbers

Returns:

array of ints

toList

@NotNull
public static java.util.List<java.lang.Integer> toList(@NotNull
                                                                int... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

    public void method(Collection<Integer> input) {
      // ...
    }

    // ...
    method(Types.asList(0, 7, -42, 3));
  

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

See Also:

IntIndexable.viewArray(int...)

toList

@NotNull
public static java.util.List<java.lang.Integer> toList(@NotNull
                                                                int[] array,
                                                                int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Integer> toList(@NotNull
                                                                int[] array,
                                                                int start,
                                                                int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

See Also:

IntIndexable.viewArray(int[], int, int)

toLongArray

public static long[] toLongArray(@NotNull
                                 java.util.Collection<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of long ints.

Parameters:

c - collection of Numbers

Returns:

array of long ints

toLongArray

public static long[] toLongArray(@NotNull
                                 Countable<? extends java.lang.Number> c)

Convert a countable of Numbers to a raw array of long ints.

Parameters:

c - countable Numbers

Returns:

array of long ints

toList

@NotNull
public static java.util.List<java.lang.Long> toList(@NotNull
                                                             long... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

    public void method(Collection(<Long> input) {
      // ...
    }

    // ...
    method(Types.toList(0L, 7L, -42L, 3L));
  

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

See Also:

LongIndexable.viewArray(long...)

toList

@NotNull
public static java.util.List<java.lang.Long> toList(@NotNull
                                                             long[] array,
                                                             int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Long> toList(@NotNull
                                                             long[] array,
                                                             int start,
                                                             int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

See Also:

LongIndexable.viewArray(long[], int, int)

toDoubleArray

@NotNull
public static double[] toDoubleArray(@NotNull
                                              java.util.Collection<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of doubles.

Parameters:

c - collection of Numbers

Returns:

array of doubles

toDoubleArray

@NotNull
public static double[] toDoubleArray(@NotNull
                                              Countable<? extends java.lang.Number> c)

Convert a countable of Numbers to a raw array of doubles.

Parameters:

c - countable Numbers

Returns:

array of doubles

toList

@NotNull
public static java.util.List<java.lang.Double> toList(@NotNull
                                                               double... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

    public void method(Collection<Double> input) {
      // ...
    }

    // ...
    method(Types.toList(0.0, 7.1, -42.0, Math.PI));
  

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

See Also:

DoubleIndexable.viewArray(double...)

toList

@NotNull
public static java.util.List<java.lang.Double> toList(@NotNull
                                                               double[] array,
                                                               int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Double> toList(@NotNull
                                                               double[] array,
                                                               int start,
                                                               int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

See Also:

DoubleIndexable.viewArray(double[], int, int)

toFloatArray

@NotNull
public static float[] toFloatArray(@NotNull
                                            java.util.Collection<? extends java.lang.Number> c)

Convert a collection of Numbers to a raw array of floats.

Parameters:

c - collection of Numbers

Returns:

array of floats

toFloatArray

@NotNull
public static float[] toFloatArray(@NotNull
                                            Countable<? extends java.lang.Number> c)

Convert a countable of Numbers to a raw array of floats.

Parameters:

c - countable Numbers

Returns:

array of floats

toList

@NotNull
public static java.util.List<java.lang.Float> toList(@NotNull
                                                              float... array)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

Parameters:

array - the array to wrap into a list view

Returns:

unmodifiable list accessing the array

See Also:

FloatIndexable.viewArray(float...)

toList

@NotNull
public static java.util.List<java.lang.Float> toList(@NotNull
                                                              float[] array,
                                                              int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method, so the safest use is as a temporary object.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

toList

@NotNull
public static java.util.List<java.lang.Float> toList(@NotNull
                                                              float[] array,
                                                              int start,
                                                              int length)

A more effective implementation of Arrays.asList(), useful if only an unmodifiable list is needed.

Changes of the array will be reflected in the list return from this method.

See asList(Object[]) for an easy to adapt example.

Parameters:

array - the array to wrap into a list view

start - index of first used element of the array

length - the number of elements to be used from the array

Returns:

unmodifiable list accessing the array

See Also:

FloatIndexable.viewArray(float[], int, int)

toEnumeration

@NotNull
 @SafeVarargs
public static <T> java.util.Enumeration<T> toEnumeration(@NotNull
                                                                                T... item)

Convert some items into an enumeration.

Type Parameters:

T - enumeration type

Parameters:

item - items

Returns:

enumeration

toEnumeration

@NotNull
public static <T> java.util.Enumeration<T> toEnumeration(@NotNull
                                                                  java.lang.Iterable<T> iterable)

Convert an iterable into an enumeration.

Type Parameters:

T - iterator type

Parameters:

iterable - the iterable

Returns:

enumeration

toEnumeration

@NotNull
public static <T> java.util.Enumeration<T> toEnumeration(@NotNull
                                                                  java.util.Iterator<T> iterator)

Convert an iterator into an enumeration.

Type Parameters:

T - iterator type

Parameters:

iterator - the iterator

Returns:

enumeration

toIterator

@NotNull
public static <T> java.util.Iterator<T> toIterator(@NotNull
                                                            java.util.Enumeration<T> enumeration)

Convert an enumeration into an iterator.

Type Parameters:

T - enumeration type

Parameters:

enumeration - the enumeration

Returns:

iterator

toIterator

@NotNull
 @SafeVarargs
public static <T> java.util.Iterator<T> toIterator(@NotNull
                                                                          T... item)

Convert some items into an iterator.

Type Parameters:

T - item type

Parameters:

item - items

Returns:

iterator

toIterable

@NotNull
public static <T> java.lang.Iterable<T> toIterable(@NotNull
                                                            java.util.Enumeration<T> enumeration)

Get a one shot iterable from an enumeration. The preferred usage of this is to wrap the enumeration so it can be used in a for each loop.

Type Parameters:

T - item type

Parameters:

enumeration - enumeration to wrap

Returns:

iterable which may only be used once, eg in a for each loop

containsEquals

public static <T> boolean containsEquals(@NotNull
                                         java.lang.Iterable<T> collection,
                                         @NotNull
                                         T element)

Test whether a collection contains an element which is equal to another element. The standard Collection contains() method is sometimes erroneously checking for reference equality, while this method uses the equals() method. As this method has to use an iterator its efficiency is determined by the size of the collection and the time for equality checking of the element.

Type Parameters:

T - generic parameter

Parameters:

collection - collection

element - element which is looked up

Returns:

true if an element which is equal to the given one is contained in the collection
false otherwise

findFirst

@Nullable
public static <T> T findFirst(@NotNull
                                        java.lang.Iterable<T> iterable,
                                        @NotNull
                                        java.util.function.Predicate<? super T> check)

Find the first element which fulfills the given check.

Type Parameters:

T - generic parameter

Parameters:

iterable - iterable with possibly matching elements

check - check to perform

Returns:

first matching element or null if no matching element was found

findNext

@Nullable
public static <T> T findNext(@NotNull
                                       java.util.Iterator<T> iterator,
                                       @NotNull
                                       java.util.function.Predicate<? super T> check)

Find the nect element which fulfils the given check.

Type Parameters:

T - generic parameter

Parameters:

iterator - iterator which is advanced until the given element is found

check - check to perform

Returns:

first matching element or null if no matching element was found

findNext

@Nullable
public static <T> T findNext(@NotNull
                                       java.util.Enumeration<T> enumeration,
                                       @NotNull
                                       java.util.function.Predicate<? super T> check)

Find the nect element which fulfils the given check.

Type Parameters:

T - generic parameter

Parameters:

enumeration - enumeration which is advanced until the given element is found

check - check to perform

Returns:

first matching element or null if no matching element was found

findFirstEqual

public static <T> int findFirstEqual(@NotNull
                                     java.lang.Iterable<T> collection,
                                     @NotNull
                                     T element)

Find the first element in an collection which is equal to another element. The standard Collection indexOf() method is sometimes erroneously checking for reference equality, while this method uses the equals() method. As this method has to use an iterator its efficiency is determined by the size of the collection and the time for equality checking of the element.

Type Parameters:

T - generic parameter

Parameters:

collection - collection

element - element which is looked up

Returns:

true if an element which is equal to the given one is contained in the collection
false otherwise

findFirstMatch

public static <T,E> int findFirstMatch(@NotNull
                                       java.lang.Iterable<T> collection,
                                       @NotNull
                                       E element,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T,? super E> matcher)

Find the first element in a collection which is matching another element. As this method has to use an iterator its efficiency is determined by the size of the collection and the time for match checking of the element.

Type Parameters:

T - generic parameter for iterator

E - generic parameter for looked up element

Parameters:

collection - collection

element - element which is looked up

matcher - matcher which matches the elements in the iteration to the given element

Returns:

true if an element which is equal to the given one is contained in the collection
false otherwise

addAll

@NotNull
 @SafeVarargs
public static <C extends java.util.Collection<? super T>,T> C addAll(@NotNull
                                                                                            C collection,
                                                                                            T... elements)

Add all elements to a collection.

Type Parameters:

C - collection type

T - element type

Parameters:

collection - collection to add to, has to be modifiable

elements - elements to add

Returns:

the collection, allowing to create it on the fly when calling this method

See Also:

Collections.addAll(Collection, Object[])

addAll

@NotNull
public static <C extends java.util.Collection<T>,T> C addAll(@NotNull
                                                                      C collection,
                                                                      @NotNull
                                                                      java.lang.Iterable<? extends T> iterable)

Add all elements of an iterable to a collection.

Type Parameters:

C - collection type

T - collection/iterator type

Parameters:

collection - collection to add to, has to be modifiable

iterable - iterable to add

Returns:

the collection, allowing to create it on the fly when calling this method

addIterable

@Deprecated
 @NotNull
public static <C extends java.util.Collection<T>,T> C addIterable(@NotNull
                                                                                        C collection,
                                                                                        @NotNull
                                                                                        java.lang.Iterable<? extends T> iterable)

Deprecated. Use addAll(Collection, Iterable) instead

Add an iterable to a collection.

Type Parameters:

C - collection type

T - collection/iterator type

Parameters:

collection - collection to add to, has to be modifiable

iterable - iterable to add

Returns:

the collection, allowing to create it on the fly when calling this method

addIterator

@NotNull
 @Deprecated
public static <C extends java.util.Collection<T>,T> C addIterator(@NotNull
                                                                                        C collection,
                                                                                        @NotNull
                                                                                        java.util.Iterator<? extends T> iterator)

Deprecated. Use addAll(Collection, Iterator) instead

Add an iterator to a collection. This will propagate over the complete iteration, so it is after it's end after calling this method.

Type Parameters:

C - collection type

T - collection/iterator type

Parameters:

collection - collection to add to, has to be modifiable

iterator - iterator to add

Returns:

the collection, allowing to create it on the fly when calling this method

addAll

@NotNull
public static <C extends java.util.Collection<T>,T> C addAll(@NotNull
                                                                      C collection,
                                                                      @NotNull
                                                                      java.util.Iterator<? extends T> iterator)

Add all elements of an iterator to a collection. This will propagate over the complete iteration, so it is after it's end after calling this method.

Type Parameters:

C - collection type

T - collection/iterator type

Parameters:

collection - collection to add to, has to be modifiable

iterator - iterator to add

Returns:

the collection, allowing to create it on the fly when calling this method

addEnumeration

@NotNull
 @Deprecated
public static <C extends java.util.Collection<T>,T> C addEnumeration(@NotNull
                                                                                           C collection,
                                                                                           @NotNull
                                                                                           java.util.Enumeration<? extends T> enumeration)

Deprecated. Use addAll(Collection, Enumeration) instead

Add an enumeration to a collection. This will propagate over the complete enumeration, so it can no longer be enumerated after calling this method.

Type Parameters:

C - collection type

T - collection/iterator type

Parameters:

collection - collection to add to, has to be modifiable

enumeration - enumeration to add

Returns:

the collection, allowing to create it on the fly when calling this method

addAll

@NotNull
public static <C extends java.util.Collection<T>,T> C addAll(@NotNull
                                                                      C collection,
                                                                      @NotNull
                                                                      java.util.Enumeration<? extends T> enumeration)

Add all elements of an enumeration to a collection. This will propagate over the complete enumeration, so it can no longer be enumerated after calling this method.

Type Parameters:

C - collection type

T - collection/iterator type

Parameters:

collection - collection to add to, has to be modifiable

enumeration - enumeration to add

Returns:

the collection, allowing to create it on the fly when calling this method

makeList

@NotNull
public static <T> java.util.LinkedList<T> makeList(@NotNull
                                                            java.lang.Iterable<T> iterable)

Create a list from an iterable. This copies all elements of the iterable to a linked list.

Type Parameters:

T - iterable/list type

Parameters:

iterable - iterable

Returns:

linked list containing the elements of the iterable

makeList

@NotNull
public static <T> java.util.LinkedList<T> makeList(@NotNull
                                                            java.util.Iterator<T> iterator)

Create a list from an iterator. This copies all elements of the iterator to a linked list.

Type Parameters:

T - iterator/list type

Parameters:

iterator - iterator

Returns:

linked list containing the elements of the iterator

makeList

@NotNull
public static <T> java.util.LinkedList<T> makeList(@NotNull
                                                            java.util.Enumeration<T> enumeration)

Create a list from an enumeration. This copies all elements of the enumeration to a linked list.

Type Parameters:

T - enumeration/list type

Parameters:

enumeration - enumeration

Returns:

linked list containing the elements of the enumeration

toPairs

@NotNull
public static <K,V> java.util.ArrayList<OrderedPair<K,V>> toPairs(@NotNull
                                                                           java.util.Map<K,V> map)

Get all entries of a map as a list of ordered pairs. The map keys become the first pair value, the map values the second pair value.

Type Parameters:

K - map key / first pair value type

V - map value / second pair value type

Parameters:

map - map to convert

Returns:

array list with ordered pair values

toPairs

@NotNull
public static <K,V,C extends java.util.Collection<OrderedPair<K,V>>> C toPairs(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Map<K,V> map)

Get all entries of a map as a collection of ordered pairs. The map keys become the first pair value, the map values the second pair value.

Type Parameters:

K - map key / first pair value type

V - map value / second pair value type

C - collection type

Parameters:

target - collection where the pairs are added

map - map to convert

Returns:

the target collection

synchronizedCollection

@NotNull
public static <T> java.util.Collection<T> synchronizedCollection(@NotNull
                                                                          java.util.Collection<T> collection)

Get a synchronized collection from a basic collection which is optimized for being often iterated, but rarely changed.

To make the synchronization work it is adamant that the basic collection is never accessed directly, only via the returned collection. Different from Collections.synchronizedCollection(java.util.Collection) special handling for iterations is not necessary.

Type Parameters:

T - element type

Parameters:

collection - basic collection

Returns:

synchronized collection

See Also:

SynchronizedCollection

synchronizedList

public static <T> java.util.List<T> synchronizedList(@NotNull
                                                     java.util.List<T> list)

Get a synchronized list from a basic collection which is optimized for being often iterated, but rarely changed.

To make the synchronization work it is adamant that the basic list is never accessed directly, only via the returned list. Different from Collections.synchronizedList(List) special handling for iterations is not necessary.

Type Parameters:

T - element type

Parameters:

list - basic list

Returns:

synchronized list

See Also:

SynchronizedList

extract

@NotNull
public static <T> java.util.LinkedList<T> extract(@NotNull
                                                           java.lang.Object[] array,
                                                           @NotNull
                                                           java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

Parameters:

array - array with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.lang.Object[] array,
                                                                               @NotNull
                                                                               java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

C - target collection type

Parameters:

target - target collection

array - array with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T> java.util.LinkedList<T> extract(@NotNull
                                                           java.lang.Iterable<?> iterable,
                                                           @NotNull
                                                           java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design.

Example:

 public Collection<String> getStrings(Collection<?> collection) {
   return Types.extract(collection, String.class);
 }
 

Type Parameters:

T - target type

Parameters:

iterable - iterable with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.lang.Iterable<?> iterable,
                                                                               @NotNull
                                                                               java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

C - target collection type

Parameters:

target - target collection

iterable - iterable with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T> java.util.LinkedList<T> extract(@NotNull
                                                           java.util.Iterator<?> iterator,
                                                           @NotNull
                                                           java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

Parameters:

iterator - iterator with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.util.Iterator<?> iterator,
                                                                               @NotNull
                                                                               java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

C - target collection type

Parameters:

target - target collection

iterator - iterator with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T> java.util.LinkedList<T> extract(@NotNull
                                                           java.util.Enumeration<?> enumeration,
                                                           @NotNull
                                                           java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

Parameters:

enumeration - enumeration with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

extract

@NotNull
public static <T,C extends java.util.Collection<? super T>> C extract(@NotNull
                                                                               C target,
                                                                               @NotNull
                                                                               java.util.Enumeration<?> enumeration,
                                                                               @NotNull
                                                                               java.lang.Class<T> targetType)

Extract all elements of a given type.

Internally this is using reflection, namely the Class.isInstance(Object) method, which is not considered fast. If you need this method often, rethink your design. Compare extract(Iterable, Class) for an easily adaptable example.

Type Parameters:

T - target type

C - target collection type

Parameters:

target - target collection

enumeration - enumeration with arbitrary elements

targetType - type of elements which shall be extracted

Returns:

a linked list containing only the elements of the target type (including extending types)

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.util.Collection<T1> c1,
                                       @NotNull
                                       java.util.Collection<T2> c2)

Are two collections equal?

This uses the equals() method of objects of the first collection for equality checking. Both collections are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first collection

T2 - type of second collection

Parameters:

c1 - first collection

c2 - second collection

Returns:

true if both collections are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.util.Collection<T1> c1,
                                       @NotNull
                                       java.util.Collection<T2> c2,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T1,? super T2> matcher)

Are two collections equal?

Both collections are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first collection

T2 - type of second collection

Parameters:

c1 - first collection

c2 - second collection

matcher - matcher for equality checking

Returns:

true if both collection are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       Countable<T1> c1,
                                       @NotNull
                                       Countable<T2> c2)

Are two countables equal?

This uses the equals() method of objects of the first countabel for equality checking. Both countables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first countable

T2 - type of second countable

Parameters:

c1 - first countable

c2 - second countable

Returns:

true if both countables are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       Countable<T1> c1,
                                       @NotNull
                                       Countable<T2> c2,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T1,? super T2> matcher)

Are two countables equal?

Both countables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first countable

T2 - type of second countable

Parameters:

c1 - first countable

c2 - second countable

matcher - matcher for equality checking

Returns:

true if both countable are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       T1[] arr1,
                                       @NotNull
                                       T2[] arr2)

Are two arrays equal?

This uses the equals() method of objects of the first array for equality checking. Both arrays are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first array

T2 - type of second array

Parameters:

arr1 - first array

arr2 - second array

Returns:

true if both arrays are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       T1[] arr1,
                                       @NotNull
                                       T2[] arr2,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T1,? super T2> matcher)

Are two arrays equal?

Both arrays are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first array

T2 - type of second array

Parameters:

arr1 - first array

arr2 - second array

matcher - matcher for equality checking

Returns:

true if both arrays are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.lang.Iterable<T1> it1,
                                       @NotNull
                                       java.lang.Iterable<T2> it2)

Are two iterables equal?

This uses the equals() method of objects of the first iterable for equality checking. Both iterables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first iterable

T2 - type of second iterable

Parameters:

it1 - first iterable

it2 - second iterable

Returns:

true if both iterables are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.lang.Iterable<T1> it1,
                                       @NotNull
                                       java.lang.Iterable<T2> it2,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T1,? super T2> matcher)

Are two iterables equal?

Both iterables are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first iterable

T2 - type of second iterable

Parameters:

it1 - first iterable

it2 - second iterable

matcher - matcher for equality checking

Returns:

true if both iterables are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.util.Iterator<T1> it1,
                                       @NotNull
                                       java.util.Iterator<T2> it2)

Are two iterations equal?

This uses the equals() method of objects of the first iterator for equality checking. Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first iterator

T2 - type of second iterator

Parameters:

it1 - first iterator

it2 - second iterator

Returns:

true if both iterators are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.util.Iterator<T1> it1,
                                       @NotNull
                                       java.util.Iterator<T2> it2,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T1,? super T2> matcher)

Are two iterations equal?

Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first iterator

T2 - type of second iterator

Parameters:

it1 - first iterator

it2 - second iterator

matcher - matcher for equality checking

Returns:

true if both iterators are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.util.Enumeration<T1> en1,
                                       @NotNull
                                       java.util.Enumeration<T2> en2)

Are two enumerators equal?

This uses the equals() method of objects of the first enumeration for equality checking. Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first enumeration

T2 - type of second enumeration

Parameters:

en1 - first enumeration

en2 - second enumeration

Returns:

true if both enumerations are equal
false if they are different

areEqual

public static <T1,T2> boolean areEqual(@NotNull
                                       java.util.Enumeration<T1> en1,
                                       @NotNull
                                       java.util.Enumeration<T2> en2,
                                       @NotNull
                                       java.util.function.BiPredicate<? super T1,? super T2> matcher)

Are two enumerators equal?

This uses the equals() method of objects of the first enumeration for equality checking. Both iterators are iterated over in order, so if both contain the same elements, but in different orders, they are considered different.

Type Parameters:

T1 - type of first enumeration

T2 - type of second enumeration

Parameters:

en1 - first enumeration

en2 - second enumeration

matcher - matcher for equality checking

Returns:

true if both enumerations are equal
false if they are different

get

public static <T> T get(@NotNull
                        java.lang.Iterable<T> iterable,
                        int index)

Get the nth element of an iterable.

Type Parameters:

T - type of iterable

Parameters:

iterable - iterable

index - index of requested element

Returns:

element with requested index

Throws:

java.lang.IndexOutOfBoundsException - if index is invalid

indexOf

public static <T,E> int indexOf(@NotNull
                                T[] array,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher)

Get the first index where a given element appears.

Type Parameters:

T - type of iterable

E - type of element

Parameters:

array - array to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

Returns:

-1 if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

indexOf

public static <T,E> int indexOf(@NotNull
                                T[] array,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher,
                                int start)

Get the first index where a given element appears.

Type Parameters:

T - type of iterable

E - type of element

Parameters:

array - array to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

-1 if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

indexOf

public static <T,E> int indexOf(@NotNull
                                java.lang.Iterable<T> iterable,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher)

Get the first index where a given element appears.

Type Parameters:

T - type of iterable

E - type of element

Parameters:

iterable - iterable to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

Returns:

-1 if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

indexOf

public static <T,E> int indexOf(@NotNull
                                java.lang.Iterable<T> iterable,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher,
                                int start)

Get the first index where a given element appears.

Type Parameters:

T - type of iterable

E - type of element

Parameters:

iterable - iterable to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

-1 if no element was found, otherwise the index of the element (i.e. the number of iterations minus one)

indexOf

public static <T,E> int indexOf(@NotNull
                                java.util.Iterator<T> iterator,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher)

Get the first index where a given element appears.

Type Parameters:

T - type of iterator

E - type of element

Parameters:

iterator - iterator to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

Returns:

-1 if no element was found, otherwise the index of the element

indexOf

public static <T,E> int indexOf(@NotNull
                                java.util.Iterator<T> iterator,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher,
                                int start)

Get the first index where a given element appears.

Type Parameters:

T - type of iterator

E - type of element

Parameters:

iterator - iterator to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

-1 if no element was found, otherwise the index of the element

indexOf

public static <T,E> int indexOf(@NotNull
                                java.util.Enumeration<T> enumeration,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher)

Get the first index where a given element appears.

Type Parameters:

T - type of enumeration

E - type of element

Parameters:

enumeration - enumeration to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

Returns:

-1 if no element was found, otherwise the index of the element

indexOf

public static <T,E> int indexOf(@NotNull
                                java.util.Enumeration<T> enumeration,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher,
                                int start)

Get the first index where a given element appears.

Type Parameters:

T - type of enumeration

E - type of element

Parameters:

enumeration - enumeration to iterate over

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

-1 if no element was found, otherwise the index of the element

indexOf

public static <T,E> int indexOf(@NotNull
                                java.util.List<T> list,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher,
                                int start)

Get the first index where a given element appears.

Type Parameters:

T - type of list

E - type of element

Parameters:

list - list to search through

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

-1 if no element was found, otherwise the index of the element

lastIndexOf

public static <T,E> int lastIndexOf(@NotNull
                                    java.util.List<T> list,
                                    E element,
                                    @NotNull
                                    java.util.function.BiPredicate<? super T,? super E> matcher,
                                    int start)

Get the last index where a given element appears.

Type Parameters:

T - type of list

E - type of element

Parameters:

list - list to search through

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

-1 if no element was found, otherwise the index of the element

lastIndexOf

public static <T,E> int lastIndexOf(@NotNull
                                    java.util.List<T> list,
                                    E element,
                                    @NotNull
                                    java.util.function.BiPredicate<? super T,? super E> matcher)

Get the last index where a given element appears.

Type Parameters:

T - type of list

E - type of element

Parameters:

list - list to search through

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

Returns:

-1 if no element was found, otherwise the index of the element

lastMatch

public static <T,E> T lastMatch(@NotNull
                                java.util.List<T> list,
                                E element,
                                @NotNull
                                java.util.function.BiPredicate<? super T,? super E> matcher,
                                int start)

Get the last matching element from a list.

Type Parameters:

T - type of list

E - type of element

Parameters:

list - list to search through

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

start - index where to start the search

Returns:

null if no element was found, otherwise the matching element

lastMatch

@Nullable
public static <T,E> T lastMatch(@NotNull
                                          java.util.List<T> list,
                                          E element,
                                          @NotNull
                                          java.util.function.BiPredicate<? super T,? super E> matcher)

Get the last matching element where a given element appears.

Type Parameters:

T - type of list

E - type of element

Parameters:

list - list to search through

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher to use for equality checking

Returns:

null if no element was found, otherwise the matching element

contains

public static <T,E> boolean contains(@NotNull
                                     T[] array,
                                     E element,
                                     @NotNull
                                     java.util.function.BiPredicate<? super T,? super E> matcher)

Is an element contained in an array?

Type Parameters:

T - type of iterable

E - type of element

Parameters:

array - array which possibly contains an element

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher for equality checking

Returns:

true if the element is contained (i.e. the matcher finds a match)
false otherwise

contains

public static <T,E> boolean contains(@NotNull
                                     java.lang.Iterable<T> iterable,
                                     E element,
                                     @NotNull
                                     java.util.function.BiPredicate<? super T,? super E> matcher)

Is an element contained in an iterable?

Type Parameters:

T - type of iterable

E - type of element

Parameters:

iterable - iterable which possibly contains an element

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher for equality checking

Returns:

true if the element is contained (i.e. the matcher finds a match)
false otherwise

contains

public static <T,E> boolean contains(@NotNull
                                     java.util.Iterator<T> iterator,
                                     E element,
                                     @NotNull
                                     java.util.function.BiPredicate<? super T,? super E> matcher)

Is an element contained in an iterator?

Type Parameters:

T - type of iterator

E - type of element

Parameters:

iterator - iterator which possibly contains an element

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher for equality checking

Returns:

true if the element is contained (i.e. the matcher finds a match)
false otherwise

contains

public static <T,E> boolean contains(@NotNull
                                     java.util.Enumeration<T> enumeration,
                                     E element,
                                     @NotNull
                                     java.util.function.BiPredicate<? super T,? super E> matcher)

Is an element contained in an enumeration?

Type Parameters:

T - type of iterator

E - type of element

Parameters:

enumeration - enumeration which possibly contains an element

element - element to look for, whether null is allowed depends on the matcher

matcher - matcher for equality checking

Returns:

true if the element is contained (i.e. the matcher finds a match)
false otherwise

copy

@NotNull
public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                           T[] array)

Get a copy of an array, while copying the content.

Type Parameters:

T - content type

Parameters:

array - array

Returns:

array list with copied elements

See Also:

copy(Collection, Copyable[])

copy

@NotNull
public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        T[] array)

Get a copy of an array, while copying the content.

Type Parameters:

T - content type

C - target collection type

Parameters:

target - target collection where the copies are stored

array - array

Returns:

collection copied elements

copy

@NotNull
public static <T extends Copyable<T>> java.util.LinkedList<T> copy(@NotNull
                                                                            java.lang.Iterable<T> iterable)

Get a copy of an iterable, while copying the content.

Type Parameters:

T - content type

Parameters:

iterable - iterable

Returns:

linked list with copied elements

copy

@NotNull
public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                           Indexable<T> indexable)

Get a copy of a indexable, while copying the content.

Type Parameters:

T - content type

Parameters:

indexable - indexable collection

Returns:

array list with copied elements

copy

@NotNull
public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                           java.util.Collection<T> collection)

Get a copy of a collection, while copying the content.

Type Parameters:

T - content type

Parameters:

collection - collection

Returns:

array list with copied elements

copy

@NotNull
public static <T extends Copyable<T>> java.util.ArrayList<T> copy(@NotNull
                                                                           Countable<T> countable)

Get a copy of a countable, while copying the content.

Type Parameters:

T - content type

Parameters:

countable - countable

Returns:

array list with copied elements

copy

@NotNull
public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.lang.Iterable<T> iterable)

Get a copy of an iterable, while copying the content.

Type Parameters:

T - content type

C - target collection type

Parameters:

target - target collection where the copies are stored

iterable - iterable

Returns:

collection copied elements

copy

@NotNull
public static <T extends Copyable<T>> java.util.LinkedList<T> copy(@NotNull
                                                                            java.util.Iterator<T> iterator)

Get a copy of an iterator, while copying the content.

Type Parameters:

T - content type

Parameters:

iterator - iterator

Returns:

linked list with copied elements

copy

@NotNull
public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Iterator<T> iterator)

Get a copy of an iterator while copying the content.

Type Parameters:

T - content type

C - target collection type

Parameters:

target - target collection where the copies are stored

iterator - iterator

Returns:

collection copied elements

copy

@NotNull
public static <T extends Copyable<T>> java.util.LinkedList<T> copy(@NotNull
                                                                            java.util.Enumeration<T> enumeration)

Get a copy of an enumeration, while copying the content.

Type Parameters:

T - content type

Parameters:

enumeration - enumeration

Returns:

linked list with copied elements

copy

@NotNull
public static <T extends Copyable<T>,C extends java.util.Collection<T>> C copy(@NotNull
                                                                                        C target,
                                                                                        @NotNull
                                                                                        java.util.Enumeration<T> enumeration)

Get a copy of an enumeration while copying the content.

Type Parameters:

T - content type

C - target collection type

Parameters:

target - target collection where the copies are stored

enumeration - enumeration

Returns:

collection copied elements

join

@NotNull
public static java.lang.String join(@NotNull
                                             java.lang.String glue,
                                             @NotNull
                                             java.lang.String... strings)

Join an array of strings into one.

Parameters:

glue - string to use as separator

strings - strings to join

Returns:

joined string

join

@NotNull
public static java.lang.String join(char glue,
                                             @NotNull
                                             java.lang.String... strings)

Join an array of strings into one.

Parameters:

glue - character to use as separator

strings - strings to join

Returns:

joined string

join

@NotNull
public static java.lang.String join(@NotNull
                                             java.lang.String glue,
                                             @NotNull
                                             java.lang.Iterable<java.lang.String> strings)

Join a bunch of strings into one.

Parameters:

glue - string to use as separator

strings - strings to join

Returns:

joined string

join

@NotNull
public static java.lang.String join(char glue,
                                             @NotNull
                                             java.lang.Iterable<java.lang.String> strings)

Join a bunch of strings into one.

Parameters:

glue - character to use as separator

strings - strings to join

Returns:

joined string

join

@NotNull
public static java.lang.String join(char glue,
                                             @NotNull
                                             java.util.Iterator<java.lang.String> strings)

Join a bunch of strings into one.

Parameters:

glue - scharacter to use as separator

strings - strings to join

Returns:

joined string

join

@NotNull
public static java.lang.String join(@NotNull
                                             java.lang.String glue,
                                             @NotNull
                                             java.util.Iterator<java.lang.String> strings)

Join a bunch of strings into one.

Parameters:

glue - string to use as separator

strings - strings to join

Returns:

joined string

join

@NotNull
public static java.lang.String join(@NotNull
                                             java.lang.String glue,
                                             @NotNull
                                             java.util.Enumeration<java.lang.String> strings)

Join a bunch of strings into one.

Parameters:

glue - string to use as separator

strings - strings to join

Returns:

joined string

view

@NotNull
public static <T,S> java.util.Iterator<T> view(@NotNull
                                                        java.util.Iterator<S> sourceIterator,
                                                        @NotNull
                                                        java.util.function.Function<? super S,? extends T> mapper)

View an iterator as if it belongs to another type. Instead of map(java.util.Iterator, Function) this will work transparently on the fly without creating an intermediate list.

Type Parameters:

T - target type

S - source type

Parameters:

sourceIterator - source iterator

mapper - mapper function which converts the source to the target type

Returns:

mapped iterator

view

@NotNull
public static <T,S> java.lang.Iterable<T> view(@NotNull
                                                        java.lang.Iterable<S> sourceIterable,
                                                        @NotNull
                                                        java.util.function.Function<? super S,? extends T> mapper)

View an iterable Instead of map(java.lang.Iterable, Function) this will work transparently on the fly.

Type Parameters:

T - target type

S - source type

Parameters:

sourceIterable - source iterable

mapper - mapper function which converts the source to the target type

Returns:

mapped iterable

doubleView

@NotNull
public static <S> java.util.PrimitiveIterator.OfDouble doubleView(@NotNull
                                                                           java.util.Iterator<S> sourceIterator,
                                                                           @NotNull
                                                                           java.util.function.ToDoubleFunction<? super S> doubleMapper)

View a generic iterator as if it is an iterator for primitive double values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

doubleMapper - mapper which maps the elements of the source iterator to double

Returns:

primitive double iterator

doubleView

@NotNull
public static <S> PrimitiveDoubleIterable doubleView(@NotNull
                                                              java.lang.Iterable<S> sourceIterable,
                                                              @NotNull
                                                              java.util.function.ToDoubleFunction<? super S> doubleMapper)

View a generic iterable as if it is an iterable of primitive double values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned double iterable with its looping functions: PrimitiveDoubleIterable.forEachDouble(DoubleConsumer) or PrimitiveDoubleIterable.forEachDoubleFragile(FragileDoubleConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

doubleMapper - mapper from the incoming elements to double

Returns:

primitive double iterable

floatView

@NotNull
public static <S> PrimitiveFloatIterator floatView(@NotNull
                                                            java.util.Iterator<S> sourceIterator,
                                                            @NotNull
                                                            ToFloatFunction<? super S> floatMapper)

View a generic iterator as if it is an iterator for primitive float values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

floatMapper - mapper which maps the elements of the source iterator to float

Returns:

primitive float iterator

floatView

@NotNull
public static <S> PrimitiveFloatIterable floatView(@NotNull
                                                            java.lang.Iterable<S> sourceIterable,
                                                            @NotNull
                                                            ToFloatFunction<? super S> floatMapper)

View a generic iterable as if it is an iterable of primitive float values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned float iterable with its looping functions: PrimitiveFloatIterable.forEachFloat(FloatConsumer) or PrimitiveFloatIterable.forEachFloatFragile(FragileFloatConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

floatMapper - mapper from the incoming elements to float

Returns:

primitive float iterable

longView

@NotNull
public static <S> java.util.PrimitiveIterator.OfLong longView(@NotNull
                                                                       java.util.Iterator<S> sourceIterator,
                                                                       @NotNull
                                                                       java.util.function.ToLongFunction<? super S> longMapper)

View a generic iterator as if it is an iterator for primitive long values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

longMapper - mapper which maps the elements of the source iterator to long

Returns:

primitive long iterator

longView

@NotNull
public static <S> PrimitiveLongIterable longView(@NotNull
                                                          java.lang.Iterable<S> sourceIterable,
                                                          @NotNull
                                                          java.util.function.ToLongFunction<? super S> longMapper)

View a generic iterable as if it is an iterable of primitive long values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned long iterable with its looping functions: PrimitiveLongIterable.forEachLong(LongConsumer) or PrimitiveLongIterable.forEachLongFragile(FragileLongConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

longMapper - mapper from the incoming elements to long

Returns:

primitive long iterable

intView

@NotNull
public static <S> java.util.PrimitiveIterator.OfInt intView(@NotNull
                                                                     java.util.Iterator<S> sourceIterator,
                                                                     @NotNull
                                                                     java.util.function.ToIntFunction<? super S> intMapper)

View a generic iterator as if it is an iterator for primitive int values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

intMapper - mapper which maps the elements of the source iterator to int

Returns:

primitive int iterator

intView

@NotNull
public static <S> PrimitiveIntIterable intView(@NotNull
                                                        java.lang.Iterable<S> sourceIterable,
                                                        @NotNull
                                                        java.util.function.ToIntFunction<? super S> intMapper)

View a generic iterable as if it is an iterable of primitive int values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned int iterable with its looping functions: PrimitiveIntIterable.forEachInt(IntConsumer) or PrimitiveIntIterable.forEachIntFragile(FragileIntConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

intMapper - mapper from the incoming elements to int

Returns:

primitive int iterable

shortView

@NotNull
public static <S> PrimitiveShortIterator shortView(@NotNull
                                                            java.util.Iterator<S> sourceIterator,
                                                            @NotNull
                                                            ToShortFunction<? super S> shortMapper)

View a generic iterator as if it is an iterator for primitive short values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

shortMapper - mapper which maps the elements of the source iterator to short

Returns:

primitive short iterator

shortView

@NotNull
public static <S> PrimitiveShortIterable shortView(@NotNull
                                                            java.lang.Iterable<S> sourceIterable,
                                                            @NotNull
                                                            ToShortFunction<? super S> shortMapper)

View a generic iterable as if it is an iterable of primitive short values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned short iterable with its looping functions: PrimitiveShortIterable.forEachShort(ShortConsumer) or PrimitiveShortIterable.forEachShortFragile(FragileShortConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

shortMapper - mapper from the incoming elements to short

Returns:

primitive short iterable

charView

@NotNull
public static <S> PrimitiveCharIterator charView(@NotNull
                                                          java.util.Iterator<S> sourceIterator,
                                                          @NotNull
                                                          ToCharFunction<? super S> charMapper)

View a generic iterator as if it is an iterator for primitive char values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

charMapper - mapper which maps the elements of the source iterator to char

Returns:

primitive char iterator

charView

@NotNull
public static <S> PrimitiveCharIterable charView(@NotNull
                                                          java.lang.Iterable<S> sourceIterable,
                                                          @NotNull
                                                          ToCharFunction<? super S> charMapper)

View a generic iterable as if it is an iterable of primitive char values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned char iterable with its looping functions: PrimitiveCharIterable.forEachChar(CharConsumer) or PrimitiveCharIterable.forEachCharFragile(FragileCharConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

charMapper - mapper from the incoming elements to char

Returns:

primitive char iterable

byteView

@NotNull
public static <S> PrimitiveByteIterator byteView(@NotNull
                                                          java.util.Iterator<S> sourceIterator,
                                                          @NotNull
                                                          ToByteFunction<? super S> byteMapper)

View a generic iterator as if it is an iterator for primitive byte values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

byteMapper - mapper which maps the elements of the source iterator to byte

Returns:

primitive byte iterator

byteView

@NotNull
public static <S> PrimitiveByteIterable byteView(@NotNull
                                                          java.lang.Iterable<S> sourceIterable,
                                                          @NotNull
                                                          ToByteFunction<? super S> byteMapper)

View a generic iterable as if it is an iterable of primitive byte values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned byte iterable with its looping functions: PrimitiveByteIterable.forEachByte(ByteConsumer) or PrimitiveByteIterable.forEachByteFragile(FragileByteConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

byteMapper - mapper from the incoming elements to byte

Returns:

primitive byte iterable

booleanView

@NotNull
public static <S> PrimitiveBooleanIterator booleanView(@NotNull
                                                                java.util.Iterator<S> sourceIterator,
                                                                @NotNull
                                                                java.util.function.Predicate<? super S> booleanMapper)

View a generic iterator as if it is an iterator for primitive boolean values.

Type Parameters:

S - source element type

Parameters:

sourceIterator - source iterator

booleanMapper - mapper which maps the elements of the source iterator to boolean

Returns:

primitive boolean iterator

booleanView

@NotNull
public static <S> PrimitiveBooleanIterable booleanView(@NotNull
                                                                java.lang.Iterable<S> sourceIterable,
                                                                @NotNull
                                                                java.util.function.Predicate<? super S> booleanMapper)

View a generic iterable as if it is an iterable of primitive boolean values.

Because for-each loops will silently introduce boxing/unboxing it is recommended to iterate over the returned boolean iterable with its looping functions: PrimitiveBooleanIterable.forEachBool(BooleanConsumer) or PrimitiveBooleanIterable.forEachBoolFragile(FragileBooleanConsumer) (if code throws checked exceptions).

Type Parameters:

S - source element type

Parameters:

sourceIterable - source iterable

booleanMapper - mapper from the incoming elements to boolean

Returns:

primitive boolean iterable

view

@NotNull
public static <T,S> Indexable<T> view(@NotNull
                                               Indexable<S> sourceIndexable,
                                               @NotNull
                                               java.util.function.Function<? super S,T> mapper)

View an indexable. Instead of map(java.lang.Iterable, Function) this will work transparently on the fly.

Type Parameters:

T - target type

S - source type

Parameters:

sourceIndexable - source indesxable

mapper - mapper function which converts the source to the target type

Returns:

mapped iterable

See Also:

Indexable.view(Function)

view

@NotNull
public static <T,S> java.util.ListIterator<T> view(@NotNull
                                                            java.util.ListIterator<S> sourceIterator,
                                                            @NotNull
                                                            java.util.function.Function<? super S,T> mapper)

View a list iterator as if it belongs to another type. Instead of map(java.util.Iterator, Function) this will work transparently on the fly without creating an intermediate list.

Type Parameters:

T - target type

S - source type

Parameters:

sourceIterator - source iterator

mapper - mapper function which converts the source to the target type

Returns:

mapped iterator

view

@NotNull
 @SafeVarargs
public static <T,S> java.lang.Iterable<T> view(@NotNull
                                                                      java.util.function.Function<? super S,T> mapper,
                                                                      @NotNull
                                                                      S... array)

View an array as if it belongs to another iterable type.

Changes to the array during the use of the resulting iterable will lead to undefined behavior.

Type Parameters:

T - target type

S - source type

Parameters:

mapper - mapper function which converts the source to the target type

array - array to be view differently

Returns:

iterable over array providing a different type

See Also:

Indexable.viewArray(Object[])

viewCollection

@NotNull
public static <T,S> java.util.Collection<T> viewCollection(@NotNull
                                                                    java.util.Collection<S> collection,
                                                                    @NotNull
                                                                    java.util.function.Function<? super S,T> mapper)

View a collection as if it has of another element type. This will return an unmodifiable collection with a different element type. It is considered useful in cases when you are in need of a readable collection, but only have one with a slightly different type. Compared to map(Collection, Function) this does not copy the collection, instead it applies the mapper on each access. So in general it is most useful when elements are rarely read, eg for iterating over them.

Possible restrictions on the source collection (eg a set may contain elements only once, or it may be ordered) are no longer guaranteed by the returned collection. Use map(Collection, Iterable, Function) where you can provide the required target collection in cases where these restrictions are required.

Type Parameters:

T - target type

S - source type

Parameters:

collection - original collection

mapper - mapper which creates the element type of the result collection

Returns:

unmodifiable collection with adapted element typee

viewList

@NotNull
public static <T,S> java.util.List<T> viewList(@NotNull
                                                        java.util.List<S> list,
                                                        @NotNull
                                                        java.util.function.Function<? super S,T> mapper)

View a list as if it has another element type. This will return an unmodifiable list with a different element type. It is considered useful in cases when you are in need of a readable list, but only have one with a slightly different type. Compared to map(Collection, Function) this does not copy the list, instead it applies the mapper on each access. So in general it is most useful when elements are rarely read, eg for iterating over them.

Type Parameters:

T - target type

S - source type

Parameters:

list - original list

mapper - mapper which creates the element type of the result collection

Returns:

unmodifiable collection with adapted element typee

unmodifiable

public static <T> java.util.Iterator<T> unmodifiable(@NotNull
                                                     java.util.Iterator<T> iterator)

Wrap an iterator to keep it from modifying the underlying collection.

The Iterator interface exports a method allowing to delete elements. The wrapper returned from this method will throw an UnsupportedOperationException for this method.

Type Parameters:

T - element type of iterator

Parameters:

iterator - iterator to wrap

Returns:

iterator which cannot modify the underlying collection

unmodifiable

public static <T> java.util.ListIterator<T> unmodifiable(@NotNull
                                                         java.util.ListIterator<T> iterator)

Wrap a list iterator to keep it from modifying the underlying collection.

The ListIterator interface exports methods allowing to modify the underlying list. The wrapper returned from this method will throw an UnsupportedOperationException for these methods.

Type Parameters:

T - element type of iterator

Parameters:

iterator - iterator to wrap

Returns:

iterator which cannot modify the underlying collection

makeFactory

public static <T> Factory<T> makeFactory(java.lang.Class<T> type)

Create a factory from a type.

The factory will only create new objects if there is an argumentless public default constructor for the given type. This method is thought for highly dynamic situations. In most cases it is recommended to create a factory as an anonymous class:

 // this is BAD style
 Factory<XY> factory1 = Types.makeFactory(XY.class);

 // this is GOOD style
 Factory<XY> factory2 = new Factory<XY>() {
   public XY create() { return new XY(); }
 };
 

Type Parameters:

T - type

Parameters:

type - type info

Returns:

factory using reflection to create new elements

makeArrayFactory

public static <T> ArrayFactory<T> makeArrayFactory(java.lang.Class<T> type)

Create an array factory from a type.

This method is thought for highly dynamic situations. In most cases it is recommended to create a factory as an anonymous class:

 // this is BAD style
 ArrayFactory<XY> factory1 = Types.makeArrayFactory(XY.class);

 // this is GOOD style
 ArrayFactory<XY> factory2 = new ArrayFactory<XY>() {
   public XY[] create(int length) { return new XY[length]; }
 };
 

Type Parameters:

T - type

Parameters:

type - type info

Returns:

factory using reflection to create new elements

asTypeConverter

@NotNull
public static <T,S> FragileTypeConverter<T,S> asTypeConverter(@NotNull
                                                                       FragileFunction1<T,? extends java.lang.Exception,S> function)

Use a fragile function with 1 argument as a type converter.

Type Parameters:

T - target type

S - source type

Parameters:

function - function to use

Returns:

fragile type converter

emptyIterator

@NotNull
public static <T> java.util.Iterator<T> emptyIterator()

Return an empty iterator which does not iterate. This is a low-cost method always returning the same object.

Type Parameters:

T - iteration type (ignored as no iteration is done)

Returns:

non-iterating iterator

emptyListIterator

@NotNull
public static <T> java.util.ListIterator<T> emptyListIterator()

Return an empty list iterator which does not iterate. This is a low-cost method always returning the same object.

Type Parameters:

T - iteration element type (ignored as no iteration is done)

Returns:

non-iterating list iterator

emptyEnumeration

@NotNull
public static <T> java.util.Enumeration<T> emptyEnumeration()

Return an empty enumeration which does not iterate. This is a low-cost method returning always the same object.

Type Parameters:

T - enumeration type (ignored as no iteration is done)

Returns:

non-iterating enumeration

emptyIterable

@NotNull
public static <T> java.lang.Iterable<T> emptyIterable()

Return an empty iterable which does not iterate. This is a low-cost method returning always the same object.

Type Parameters:

T - iterable type (ignored as no iteration is done)

Returns:

non-iterating iterable

getCopier

@NotNull
public static <T extends Copyable<T>> java.util.function.Function<T,T> getCopier(@NotNull
                                                                                          java.lang.Class<T> elemClass)

Get a copier function which creates an copy of its argument.

Type Parameters:

T - class type, has to implement Copyable

Parameters:

elemClass - element class

Returns:

copier function

clone

@NotNull
public static <T> java.util.ArrayList<T> clone(@NotNull
                                                        java.util.Collection<T> sourceCollection,
                                                        @NotNull
                                                        java.util.function.Function<T,T> cloner)

Clone a collection.

Type Parameters:

T - list type

Parameters:

sourceCollection - source collection

cloner - cloner which clones one list element

Returns:

array list with cloned elements

clone

@NotNull
public static <T> java.util.ArrayList<T> clone(@NotNull
                                                        Countable<T> sourceCountable,
                                                        @NotNull
                                                        java.util.function.Function<T,T> cloner)

Clone a countable.

Type Parameters:

T - list type

Parameters:

sourceCountable - source countable

cloner - cloner which clones one list element

Returns:

array list with cloned elements

concat

@SafeVarargs
 @NotNull
public static <T> java.lang.Iterable<T> concat(@NotNull
                                                                      java.lang.Iterable<? extends T>... iterables)

Concatenate some iterables to a combined iterable.

Type Parameters:

T - iteration element type

Parameters:

iterables - iterables to concatenate

Returns:

combined iterable which iterates over all the basic iterables one after the other

concatIterables

@NotNull
public static <T> java.lang.Iterable<T> concatIterables(@NotNull
                                                                 java.lang.Iterable<? extends java.lang.Iterable<? extends T>> iterables)

Concatenate some iterables to a combined iterable.

Type Parameters:

T - iteration element type

Parameters:

iterables - iterables to concatenate

Returns:

combined iterable which iterates over all the basic iterables one after the other

concat

@SafeVarargs
 @NotNull
public static <T> java.util.Iterator<T> concat(@NotNull
                                                                      java.util.Iterator<? extends T>... iterators)

Concatenate some iterators.

Type Parameters:

T - iteration element type

Parameters:

iterators - iterators to concatenate

Returns:

combined iterator which iterates over all the basic iterators one after the other

concatIterators

@NotNull
public static <T> java.util.Iterator<T> concatIterators(@NotNull
                                                                 java.lang.Iterable<? extends java.util.Iterator<? extends T>> iterators)

Concatenate some iterators.

Type Parameters:

T - iteration element type

Parameters:

iterators - iterators to concatenate

Returns:

combined iterator which iterates over all the basic iterators one after the other

notNull

@NotNull
public static <T,D extends T> T notNull(@Nullable
                                                 T item,
                                                 @NotNull
                                                 D defaultValue)

Make sure that something is not null. Use a default value if necessary.

Type Parameters:

T - item type

D - default value type

Parameters:

item - item which may be null

defaultValue - default value substituted if item is null

Returns:

item if it is not null, defaultValue otherwise

notNull

@NotNull
public static java.lang.String notNull(@Nullable
                                                java.lang.String str)

Make sure a string is not null. Use the empty string if necessary.

Parameters:

str - string which might be null

Returns:

the string if it is not null, the empty string otherwise

notNullOr

@NotNull
public static <T> T notNullOr(@Nullable
                                       T item,
                                       @NotNull
                                       java.util.function.Supplier<? extends T> provider)

Make sure that something is not null, but postpone the fallback creation. This is similar to notNull(Object, Object), but is creating the second defaultObject parameter only when required. This is preferable if creating the object is an expensive process.

Type Parameters:

T - type of nullable value

Parameters:

item - item which is tested for being null

provider - supplier asked to provide a fallback when item is null, required to return non-null object!

Returns:

non-null value, either item if it is not null, or a fallback created by provider

Throws:

java.lang.IllegalArgumentException - if provider creates null

See Also:

notNullOrN(Object, Supplier)

notNullOrN

@Nullable
public static <T> T notNullOrN(@Nullable
                                         T item,
                                         @NotNull
                                         java.util.function.Supplier<? extends T> provider)

Try to determine a fallback when a value is null.

This is useful in cases where the fallback creation is expensive. In difference to notNullOr(Object, Supplier) this accepts the fallback provider to return null. Thus, it is necessary to check the result of this method for being null.

Type Parameters:

T - type of nullable value

Parameters:

item - item which is tested for being