Package com.github.underscore

Class U<T>

java.lang.Object

com.github.underscore.U<T>

Direct Known Subclasses:

U

public class U<T>
extends Object

Underscore-java11 is a java 11 port of Underscore.js.

Author:

Valentyn Kolesnikov

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	U.Chain<T>

Constructor Summary

Constructors

Constructor	Description
U(Iterable<T> iterable)
U(String string)

Method Summary

Modifier and Type	Method	Description
static <E> Supplier<E>	after(int count, Supplier<E> function)
static <E> boolean	all(Iterable<E> iterable, Predicate<E> pred)
boolean	all(Predicate<T> pred)
static <T> Predicate<T>	and(Predicate<? super T> pred1, Predicate<? super T> pred2, Predicate<? super T>... rest)
static <E> boolean	any(Iterable<E> iterable, Predicate<E> pred)
boolean	any(Predicate<T> pred)
static <E> Supplier<E>	before(int count, Supplier<E> function)
static <E extends Comparable<E>> int	binarySearch(E[] array, E key)
static <E extends Comparable<E>> int	binarySearch(Iterable<E> iterable, E key)
static <T,F> Function<F,T>	bind(Function<F,T> function)
Optional<String>	call(String funcName)
U.Chain<T>	chain()
static U.Chain<Integer>	chain(int[] array)
static <T> U.Chain<T>	chain(Iterable<T> iterable)
static <T> U.Chain<T>	chain(Iterable<T> iterable, int size)
static <T> U.Chain<T>	chain(List<T> list)
static <T> U.Chain<T>	chain(T... array)
static <T> T	checkNotNull(T reference)
static <T> T	checkNotNull(T reference, Object errorMessage)
static <T> List<T>	checkNotNullElements(List<T> references)
List<List<T>>	chunk(int size)
List<List<T>>	chunk(int size, int step)
static <T> List<List<T>>	chunk(Iterable<T> iterable, int size)
static <T> List<List<T>>	chunk(Iterable<T> iterable, int size, int step)
List<List<T>>	chunkFill(int size, int step, T fillvalue)
List<List<T>>	chunkFill(int size, T fillvalue)
static <T> List<List<T>>	chunkFill(Iterable<T> iterable, int size, int step, T fillValue)
static <T> List<List<T>>	chunkFill(Iterable<T> iterable, int size, T fillValue)
static void	clearInterval(ScheduledFuture scheduledFuture)
static void	clearTimeout(ScheduledFuture<?> scheduledFuture)
static <E> E[]	clone(E... iterable)
static Object	clone(Object obj)
static <T,E> List<T>	collect(List<E> list, Function<? super E,T> func)
static <T,E> Set<T>	collect(Set<E> set, Function<? super E,T> func)
List<T>	compact()
static <E> E[]	compact(E... array)
static <E> E[]	compact(E[] array, E falsyValue)
static <E> List<E>	compact(List<E> list)
static <E> List<E>	compact(List<E> list, E falsyValue)
List<T>	compact(T falsyValue)
static <T> Function<T,T>	compose(Function<T,T>... func)
static <T> List<T>	concat(Iterable<T> first, Iterable<T>... other)
static <T> T[]	concat(T[] first, T[]... other)
List<T>	concatWith(Iterable<T>... other)
static <E> Supplier<E>	constant(E value)
static <E> boolean	contains(Iterable<E> iterable, E elem)
static <E> boolean	contains(Iterable<E> iterable, E elem, int fromIndex)
boolean	contains(T elem)
static <E> boolean	containsAtLeast(Iterable<E> iterable, E value, int count)
boolean	containsAtLeast(T value, int count)
static <E> boolean	containsAtMost(Iterable<E> iterable, E value, int count)
boolean	containsAtMost(T value, int count)
static <E> boolean	containsWith(Iterable<E> iterable, E elem)
boolean	containsWith(T elem)
List<T>	copyOf()
static <T> List<T>	copyOf(Iterable<T> iterable)
List<T>	copyOfRange(int start, int end)
static <T> List<T>	copyOfRange(Iterable<T> iterable, int start, int end)
static <E> int	count(Iterable<E> iterable, Predicate<E> pred)
int	count(Predicate<T> pred)
<K> Map<K,Integer>	countBy()
static <K,E> Map<K,Integer>	countBy(Iterable<E> iterable, Function<E,K> func)
static <K> Map<K,Integer>	countBy(Iterable<K> iterable)
<K,E> Map<K,Integer>	countBy(Function<E,K> func)
List<T>	cycle(int times)
static <T> List<T>	cycle(Iterable<T> iterable, int times)
static <T> Supplier<T>	debounce(Supplier<T> function, int delayMilliseconds)
static <K,V> Map<K,V>	defaults(Map<K,V> object, Map<K,V> defaults)
static <T> T	defaultTo(T value, T defaultValue)
static ScheduledFuture<Void>	defer(Runnable runnable)
static <T> ScheduledFuture<T>	defer(Supplier<T> function)
static <T> ScheduledFuture<T>	delay(Supplier<T> function, int delayMilliseconds)
static <E> Optional<E>	detect(Iterable<E> iterable, Predicate<E> pred)
static <E> E[]	difference(E[]... arrays)
static <E> List<E>	difference(List<E> list1, List<E> list2)
static <E> List<E>	difference(List<E> list, List<E>... lists)
List<T>	differenceWith(List<T>... lists)
static <E> E[]	distinct(E... array)
static <E> List<E>	distinct(List<E> list)
static <K,E> E[]	distinctBy(E[] array, Function<E,K> func)
static <K,E> Collection<E>	distinctBy(Iterable<E> iterable, Function<E,K> func)
static <E> E[]	drop(E... array)
static <E> E[]	drop(E[] array, int n)
static <E> List<E>	drop(List<E> list)
static <E> List<E>	drop(List<E> list, int n)
static <T> void	each(Iterable<T> iterable, Consumer<? super T> func)
void	each(Consumer<? super T> func)
static <T> void	eachIndexed(Iterable<T> iterable, BiConsumer<Integer,? super T> func)
static <T> void	eachRight(Iterable<T> iterable, Consumer<? super T> func)
void	eachRight(Consumer<? super T> func)
T	elementAt(int index)
static <T> T	elementAt(List<T> list, int index)
T	elementAtOrElse(int index, T defaultValue)
static <T> T	elementAtOrElse(List<T> list, int index, T defaultValue)
T	elementAtOrNull(int index)
static <T> T	elementAtOrNull(List<T> list, int index)
static String	escape(String value)
static <E> boolean	every(Iterable<E> iterable, Predicate<E> pred)
boolean	every(Predicate<T> pred)
static <K,V> Map<K,V>	extend(Map<K,V> destination, Map<K,V>... sources)
static <E> List<E>	filter(Iterable<E> iterable, Predicate<E> pred)
List<T>	filter(Predicate<T> pred)
static <E> List<E>	filter(List<E> list, Predicate<E> pred)
static <E> Set<E>	filter(Set<E> set, Predicate<E> pred)
List<T>	filterFalse(Predicate<T> pred)
static <E> List<E>	filterFalse(List<E> list, Predicate<E> pred)
static <E> Set<E>	filterFalse(Set<E> set, Predicate<E> pred)
static <E> List<E>	filterIndexed(List<E> list, PredicateIndexed<E> pred)
static <E> Optional<E>	find(Iterable<E> iterable, Predicate<E> pred)
static <E> int	findIndex(E[] array, Predicate<E> pred)
static <E> int	findIndex(List<E> list, Predicate<E> pred)
static <E> E	findKey(E[] array, Predicate<E> pred)
static <E> E	findKey(List<E> list, Predicate<E> pred)
static <E> Optional<E>	findLast(Iterable<E> iterable, Predicate<E> pred)
static <E> int	findLastIndex(E[] array, Predicate<E> pred)
static <E> int	findLastIndex(List<E> list, Predicate<E> pred)
static <E> E	findLastKey(E[] array, Predicate<E> pred)
static <E> E	findLastKey(List<E> list, Predicate<E> pred)
static <T,E> Optional<E>	findWhere(Iterable<E> iterable, List<Tuple<String,T>> properties)
<E> Optional<T>	findWhere(List<Tuple<String,E>> properties)
T	first()
List<T>	first(int n)
static <E> E	first(E... array)
static <E> E	first(Iterable<E> iterable)
static <E> E	first(Iterable<E> iterable, Predicate<E> pred)
static <E> List<E>	first(Iterable<E> iterable, Predicate<E> pred, int n)
T	first(Predicate<T> pred)
List<T>	first(Predicate<T> pred, int n)
static <E> List<E>	first(List<E> list, int n)
T	firstOrNull()
static <E> E	firstOrNull(Iterable<E> iterable)
static <E> E	firstOrNull(Iterable<E> iterable, Predicate<E> pred)
T	firstOrNull(Predicate<T> pred)
List<T>	flatten()
List<T>	flatten(boolean shallow)
static <E> List<E>	flatten(List<?> list)
static <E> List<E>	flatten(List<?> list, boolean shallow)
static <T,E> E	foldl(Iterable<T> iterable, BiFunction<E,T,E> func, E zeroElem)
static <T,E> E	foldr(Iterable<T> iterable, BiFunction<E,T,E> func, E zeroElem)
static <T> void	forEach(Iterable<T> iterable, Consumer<? super T> func)
void	forEach(Consumer<? super T> func)
static <T> void	forEachIndexed(Iterable<T> iterable, BiConsumer<Integer,? super T> func)
void	forEachIndexed(BiConsumer<Integer,? super T> func)
static <T> void	forEachRight(Iterable<T> iterable, Consumer<? super T> func)
void	forEachRight(Consumer<? super T> func)
static String	format(String template, Object... params)
static List<String>	functions(Object object)
T	get(int index)
static <T> T	get(List<T> list, int index)
Iterable<T>	getIterable()
Optional<String>	getString()
static <K,E> Map<K,List<E>>	groupBy(Iterable<E> iterable, Function<E,K> func)
static <K,E> Map<K,Optional<E>>	groupBy(Iterable<E> iterable, Function<E,K> func, BinaryOperator<E> binaryOperator)
<K,E> Map<K,List<E>>	groupBy(Function<E,K> func)
<K,E> Map<K,Optional<E>>	groupBy(Function<E,K> func, BinaryOperator<E> binaryOperator)
static <K,V> boolean	has(Map<K,V> object, K key)
T	head()
List<T>	head(int n)
static <E> E	head(E... array)
static <E> E	head(Iterable<E> iterable)
static <E> List<E>	head(List<E> list, int n)
static <E> E	identity(E value)
static <E> boolean	include(Iterable<E> iterable, E elem)
static <K,E> Map<K,List<E>>	indexBy(Iterable<E> iterable, String property)
<K,E> Map<K,List<E>>	indexBy(String property)
static <E> int	indexOf(E[] array, E value)
static <E> int	indexOf(List<E> list, E value)
List<T>	initial()
List<T>	initial(int n)
static <E> E[]	initial(E... array)
static <E> E[]	initial(E[] array, int n)
static <E> List<E>	initial(List<E> list)
static <E> List<E>	initial(List<E> list, int n)
static <T,E> E	inject(Iterable<T> iterable, BiFunction<E,T,E> func, E zeroElem)
static <T> List<T>	interpose(Iterable<T> iterable, T interElement)
List<T>	interpose(T element)
List<T>	interposeByList(Iterable<T> interIter)
static <T> List<T>	interposeByList(Iterable<T> iterable, Iterable<T> interIter)
static <E> E[]	intersection(E[]... arrays)
static <E> List<E>	intersection(List<E> list1, List<E> list2)
static <E> List<E>	intersection(List<E> list, List<E>... lists)
List<T>	intersectionWith(List<T>... lists)
static <K,V> List<Tuple<V,K>>	invert(Map<K,V> object)
static <E> List<E>	invoke(Iterable<E> iterable, String methodName)
static <E> List<E>	invoke(Iterable<E> iterable, String methodName, List<Object> args)
List<T>	invoke(String methodName)
List<T>	invoke(String methodName, List<Object> args)
static boolean	isArray(Object object)
static boolean	isBoolean(Object object)
static boolean	isDate(Object object)
boolean	isEmpty()
static <T> boolean	isEmpty(Iterable<T> iterable)
static <K,V> boolean	isEmpty(Map<K,V> object)
static boolean	isEqual(Object object, Object other)
static boolean	isError(Object object)
static boolean	isFunction(Object object)
static <K,V> boolean	isMatch(Map<K,V> object, Map<K,V> properties)
boolean	isNotEmpty()
static <T> boolean	isNotEmpty(Iterable<T> iterable)
static <K,V> boolean	isNotEmpty(Map<K,V> object)
static boolean	isNull(Object object)
static boolean	isNumber(Object object)
static boolean	isObject(Object object)
static boolean	isRegExp(Object object)
static boolean	isString(Object object)
static <T> Iterable<T>	iterate(T seed, UnaryOperator<T> unaryOperator)
static <K,V> Function<Map<K,V>,V>	iteratee(K key)
String	join()
static <T> String	join(Iterable<T> iterable)
static <T> String	join(Iterable<T> iterable, String separator)
String	join(String separator)
static <T> String	join(T[] array)
static <T> String	join(T[] array, String separator)
static <K,V> Set<K>	keys(Map<K,V> object)
T	last()
List<T>	last(int n)
static <E> E	last(E... array)
T	last(Predicate<T> pred)
static <E> E	last(List<E> list)
static <E> List<E>	last(List<E> list, int n)
static <E> E	last(List<E> list, Predicate<E> pred)
static int	lastIndex(int[] array)
static <T> int	lastIndex(Iterable<T> iterable)
static <T> int	lastIndex(T[] array)
static <E> int	lastIndexOf(E[] array, E value)
static <E> int	lastIndexOf(List<E> list, E value)
T	lastOrNull()
T	lastOrNull(Predicate<T> pred)
static <E> E	lastOrNull(List<E> list)
static <E> E	lastOrNull(List<E> list, Predicate<E> pred)
static void	main(String... args)
static <T> List<T>	map(int[] array, Function<? super Integer,T> func)
<F> List<F>	map(Function<? super T,F> func)
static <T,E> List<T>	map(List<E> list, Function<? super E,T> func)
static <T,E> Set<T>	map(Set<E> set, Function<? super E,T> func)
<F> List<F>	mapIndexed(BiFunction<Integer,? super T,F> func)
static <T,E> List<T>	mapIndexed(List<E> list, BiFunction<Integer,? super E,T> func)
static <K,V> List<Tuple<K,V>>	mapObject(Map<K,V> object, Function<? super V,V> func)
static <K,V> Predicate<Map<K,V>>	matcher(Map<K,V> object)
T	max()
static <E extends Comparable<? super E>> E	max(Collection<E> collection)
static <E,F extends Comparable> E	max(Collection<E> collection, Function<E,F> func)
<F extends Comparable<? super F>> T	max(Function<T,F> func)
static <T,F> Function<F,T>	memoize(Function<F,T> function)
static List<String>	methods(Object object)
T	min()
static <E extends Comparable<? super E>> E	min(Collection<E> collection)
static <E,F extends Comparable> E	min(Collection<E> collection, Function<E,F> func)
<F extends Comparable<? super F>> T	min(Function<T,F> func)
static void	mixin(String funcName, Function<String,String> func)
static <E> Predicate<E>	negate(Predicate<E> pred)
protected static <T> List<T>	newArrayList()
protected static <T> List<T>	newArrayList(Iterable<T> iterable)
protected static <T> List<T>	newArrayList(Iterable<T> iterable, int size)
protected static <T> List<T>	newArrayList(T object)
protected static <T> List<T>	newArrayListWithExpectedSize(int size)
protected static List<Integer>	newIntegerList(int... array)
protected static <K,E> Map<K,E>	newLinkedHashMap()
protected static <T> Set<T>	newLinkedHashSet()
protected static <T> Set<T>	newLinkedHashSet(Iterable<T> iterable)
protected static <T> Set<T>	newLinkedHashSetWithExpectedSize(int size)
static boolean	nonNull(Object obj)
static long	now()
static <K,V> List<Tuple<K,V>>	object(List<K> keys, List<V> values)
static <K,V> List<Tuple<K,V>>	omit(Map<K,V> object, Predicate<V> pred)
static <K,V> List<Tuple<K,V>>	omit(Map<K,V> object, K... keys)
static <T> Supplier<T>	once(Supplier<T> function)
static <T> Predicate<T>	or(Predicate<? super T> pred1, Predicate<? super T> pred2, Predicate<? super T>... rest)
static <K,V> List<Tuple<K,V>>	pairs(Map<K,V> object)
static <E> List<E>[]	partition(E[] iterable, Predicate<E> pred)
static <E> List<List<E>>	partition(Iterable<E> iterable, Predicate<E> pred)
static <K,V> List<Tuple<K,V>>	pick(Map<K,V> object, Predicate<V> pred)
static <K,V> List<Tuple<K,V>>	pick(Map<K,V> object, K... keys)
List<Object>	pluck(String propertyName)
static <E> List<Object>	pluck(List<E> list, String propertyName)
static <E> Set<Object>	pluck(Set<E> set, String propertyName)
Tuple<T,List<T>>	pop()
static <T> Tuple<T,List<T>>	pop(List<T> list)
static <K,V> Function<Map<K,V>,V>	property(K key)
static <K,V> Function<K,V>	propertyOf(Map<K,V> object)
static <T> List<T>	push(List<T> list, T... values)
List<T>	push(T... values)
static int	random(int max)
static int	random(int min, int max)
static List<Character>	range(char stop)
static List<Character>	range(char start, char stop)
static List<Character>	range(char start, char stop, int step)
static List<Integer>	range(int stop)
static List<Integer>	range(int start, int stop)
static List<Integer>	range(int start, int stop, int step)
static <E> E	reduce(int[] array, BiFunction<E,? super Integer,E> func, E zeroElem)
static <T,E> E	reduce(Iterable<T> iterable, BiFunction<E,T,E> func, E zeroElem)
static <T> Optional<T>	reduce(Iterable<T> iterable, BinaryOperator<T> func)
static <T,E> E	reduce(T[] array, BiFunction<E,T,E> func, E zeroElem)
static <E> E	reduceRight(int[] array, BiFunction<E,? super Integer,E> func, E zeroElem)
static <T,E> E	reduceRight(Iterable<T> iterable, BiFunction<E,T,E> func, E zeroElem)
static <T> Optional<T>	reduceRight(Iterable<T> iterable, BinaryOperator<T> func)
static <T,E> E	reduceRight(T[] array, BiFunction<E,T,E> func, E zeroElem)
List<T>	reject(Predicate<T> pred)
static <E> List<E>	reject(List<E> list, Predicate<E> pred)
static <E> Set<E>	reject(Set<E> set, Predicate<E> pred)
static <E> List<E>	rejectIndexed(List<E> list, PredicateIndexed<E> pred)
static <T> List<T>	repeat(T element, int times)
static <T> List<T>	replace(Iterable<T> iter, Predicate<T> pred, T value)
List<T>	replace(Predicate<T> pred, T value)
List<T>	replaceIndexed(PredicateIndexed<T> pred, T value)
static <T> List<T>	replaceIndexed(Iterable<T> iter, PredicateIndexed<T> pred, T value)
List<T>	rest()
List<T>	rest(int n)
static <E> E[]	rest(E... array)
static <E> E[]	rest(E[] array, int n)
static <E> List<E>	rest(List<E> list)
static <E> List<E>	rest(List<E> list, int n)
static <E> Object	result(Iterable<E> iterable, Predicate<E> pred)
List<T>	reverse()
static List<Integer>	reverse(int[] array)
static <T> List<T>	reverse(Iterable<T> iterable)
static <T> T[]	reverse(T... array)
T	sample()
static <E> E	sample(Iterable<E> iterable)
static <E> Set<E>	sample(List<E> list, int howMany)
static <E> List<E>	select(List<E> list, Predicate<E> pred)
static <E> Set<E>	select(Set<E> set, Predicate<E> pred)
Tuple<T,List<T>>	set(int index, T value)
static <T> Tuple<T,List<T>>	set(List<T> list, int index, T value)
static <T> ScheduledFuture	setInterval(Supplier<T> function, int delayMilliseconds)
static <T> ScheduledFuture<T>	setTimeout(Supplier<T> function, int delayMilliseconds)
Tuple<T,List<T>>	shift()
static <T> Tuple<T,List<T>>	shift(List<T> list)
List<T>	shuffle()
static <E> List<E>	shuffle(Iterable<E> iterable)
T	singleOrNull()
static <E> E	singleOrNull(Iterable<E> iterable)
static <E> E	singleOrNull(Iterable<E> iterable, Predicate<E> pred)
T	singleOrNull(Predicate<T> pred)
int	size()
static <E> int	size(E... array)
static int	size(Iterable<?> iterable)
List<T>	slice(int start)
List<T>	slice(int start, int end)
static <T> List<T>	slice(Iterable<T> iterable, int start)
static <T> List<T>	slice(Iterable<T> iterable, int start, int end)
static <T> T[]	slice(T[] array, int start)
static <T> T[]	slice(T[] array, int start, int end)
static <E> boolean	some(Iterable<E> iterable, Predicate<E> pred)
boolean	some(Predicate<T> pred)
List<Comparable>	sort()
static <T extends Comparable<T>> List<T>	sort(Iterable<T> iterable)
static <T extends Comparable<T>> T[]	sort(T... array)
static <E,T extends Comparable<? super T>> List<E>	sortBy(Iterable<E> iterable, Function<E,T> func)
static <K,V extends Comparable<? super V>> List<Map<K,V>>	sortBy(Iterable<Map<K,V>> iterable, K key)
<E,V extends Comparable<? super V>> List<E>	sortBy(Function<E,V> func)
static <E extends Comparable<E>> int	sortedIndex(E[] array, E value)
static <E extends Comparable<E>> int	sortedIndex(E[] array, E value, String propertyName)
static <E extends Comparable<E>> int	sortedIndex(List<E> list, E value)
static <E extends Comparable<E>> int	sortedIndex(List<E> list, E value, String propertyName)
static <T extends Comparable<? super T>> List<T>	sortWith(Iterable<T> iterable, Comparator<T> comparator)
<E extends Comparable<? super E>> List<E>	sortWith(Comparator<E> comparator)
List<List<T>>	splitAt(int position)
static <T> List<List<T>>	splitAt(Iterable<T> iterable, int position)
static <T> List<List<T>>	splitAt(T[] array, int position)
List<T>	tail()
List<T>	tail(int n)
static <E> E[]	tail(E... array)
static <E> E[]	tail(E[] array, int n)
static <E> List<E>	tail(List<E> list)
static <E> List<E>	tail(List<E> list, int n)
List<T>	takeSkipping(int stepSize)
static <T> List<T>	takeSkipping(Iterable<T> iterable, int stepSize)
static <T> List<T>	takeSkipping(T[] array, int stepSize)
static <T> void	tap(Iterable<T> iterable, Consumer<? super T> func)
static <K,V> Template<Map<K,V>>	template(String template)
static void	templateSettings(Map<String,String> templateSettings)
static <T> Supplier<T>	throttle(Supplier<T> function, int waitMilliseconds)
static void	times(int count, Runnable runnable)
<E> E[]	toArray()
static <E> E[]	toArray(Iterable<E> iterable)
Map<T,Integer>	toCardinalityMap()
static <K> Map<K,Integer>	toCardinalityMap(Iterable<K> iterable)
<K,V> Map<K,V>	toMap()
static <K,V> Map<K,V>	toMap(Iterable<Map.Entry<K,V>> iterable)
static <K,V> Map<K,V>	toMap(List<Tuple<K,V>> tuples)
static String	unescape(String value)
static <E> E[]	union(E[]... arrays)
static <E> List<E>	union(List<E> list, List<E>... lists)
List<T>	unionWith(List<T>... lists)
static <E> E[]	uniq(E... array)
static <K,E> E[]	uniq(E[] array, Function<E,K> func)
static <K,E> Collection<E>	uniq(Iterable<E> iterable, Function<E,K> func)
static <E> List<E>	uniq(List<E> list)
static String	uniqueId(String prefix)
static String	uniquePassword()
static <T> List<T>	unshift(List<T> list, T... values)
List<T>	unshift(T... values)
static <T> List<List<T>>	unzip(List<T>... lists)
Iterable<T>	value()
static <K,V> Collection<V>	values(Map<K,V> object)
<E> List<T>	where(List<Tuple<String,E>> properties)
static <T,E> List<E>	where(List<E> list, List<Tuple<String,T>> properties)
static <T,E> Set<E>	where(Set<E> set, List<Tuple<String,T>> properties)
static <E> E[]	without(E[] array, E... values)
static <E> List<E>	without(List<E> list, E... values)
static <T> Function<Void,T>	wrap(Function<T,T> function, Function<Function<T,T>,T> wrapper)
static <T> List<List<T>>	zip(List<T>... lists)

Methods inherited from class java.lang.Object

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

Constructor Detail

U

public U(Iterable<T> iterable)

U

public U(String string)

Method Detail

templateSettings

public static void templateSettings(Map<String,String> templateSettings)

iteratee

public static <K,V> Function<Map<K,V>,V> iteratee(K key)

each

public static <T> void each(Iterable<T> iterable,
                            Consumer<? super T> func)

eachIndexed

public static <T> void eachIndexed(Iterable<T> iterable,
                                   BiConsumer<Integer,? super T> func)

each

public void each(Consumer<? super T> func)

eachRight

public static <T> void eachRight(Iterable<T> iterable,
                                 Consumer<? super T> func)

eachRight

public void eachRight(Consumer<? super T> func)

forEach

public static <T> void forEach(Iterable<T> iterable,
                               Consumer<? super T> func)

forEachIndexed

public static <T> void forEachIndexed(Iterable<T> iterable,
                                      BiConsumer<Integer,? super T> func)

forEach

public void forEach(Consumer<? super T> func)

forEachIndexed

public void forEachIndexed(BiConsumer<Integer,? super T> func)

forEachRight

public static <T> void forEachRight(Iterable<T> iterable,
                                    Consumer<? super T> func)

forEachRight

public void forEachRight(Consumer<? super T> func)

map

public static <T,E> List<T> map(List<E> list,
                                      Function<? super E,T> func)

map

public <F> List<F> map(Function<? super T,F> func)

map

public static <T> List<T> map(int[] array,
                              Function<? super Integer,T> func)

map

public static <T,E> Set<T> map(Set<E> set,
                                     Function<? super E,T> func)

mapIndexed

public static <T,E> List<T> mapIndexed(List<E> list,
                                             BiFunction<Integer,? super E,T> func)

replace

public static <T> List<T> replace(Iterable<T> iter,
                                  Predicate<T> pred,
                                  T value)

replace

public List<T> replace(Predicate<T> pred,
                       T value)

replaceIndexed

public static <T> List<T> replaceIndexed(Iterable<T> iter,
                                         PredicateIndexed<T> pred,
                                         T value)

replaceIndexed

public List<T> replaceIndexed(PredicateIndexed<T> pred,
                              T value)

mapIndexed

public <F> List<F> mapIndexed(BiFunction<Integer,? super T,F> func)

collect

public static <T,E> List<T> collect(List<E> list,
                                          Function<? super E,T> func)

collect

public static <T,E> Set<T> collect(Set<E> set,
                                         Function<? super E,T> func)

reduce

public static <T,E> E reduce(Iterable<T> iterable,
                                   BiFunction<E,T,E> func,
                                   E zeroElem)

reduce

public static <T> Optional<T> reduce(Iterable<T> iterable,
                                     BinaryOperator<T> func)

reduce

public static <E> E reduce(int[] array,
                           BiFunction<E,? super Integer,E> func,
                           E zeroElem)

reduce

public static <T,E> E reduce(T[] array,
                                   BiFunction<E,T,E> func,
                                   E zeroElem)

foldl

public static <T,E> E foldl(Iterable<T> iterable,
                                  BiFunction<E,T,E> func,
                                  E zeroElem)

inject

public static <T,E> E inject(Iterable<T> iterable,
                                   BiFunction<E,T,E> func,
                                   E zeroElem)

reduceRight

public static <T,E> E reduceRight(Iterable<T> iterable,
                                        BiFunction<E,T,E> func,
                                        E zeroElem)

reduceRight

public static <T> Optional<T> reduceRight(Iterable<T> iterable,
                                          BinaryOperator<T> func)

reduceRight

public static <E> E reduceRight(int[] array,
                                BiFunction<E,? super Integer,E> func,
                                E zeroElem)

reduceRight

public static <T,E> E reduceRight(T[] array,
                                        BiFunction<E,T,E> func,
                                        E zeroElem)

foldr

public static <T,E> E foldr(Iterable<T> iterable,
                                  BiFunction<E,T,E> func,
                                  E zeroElem)

find

public static <E> Optional<E> find(Iterable<E> iterable,
                                   Predicate<E> pred)

detect

public static <E> Optional<E> detect(Iterable<E> iterable,
                                     Predicate<E> pred)

findLast

public static <E> Optional<E> findLast(Iterable<E> iterable,
                                       Predicate<E> pred)

filter

public static <E> List<E> filter(Iterable<E> iterable,
                                 Predicate<E> pred)

filter

public static <E> List<E> filter(List<E> list,
                                 Predicate<E> pred)

filter

public List<T> filter(Predicate<T> pred)

filterIndexed

public static <E> List<E> filterIndexed(List<E> list,
                                        PredicateIndexed<E> pred)

filter

public static <E> Set<E> filter(Set<E> set,
                                Predicate<E> pred)

select

public static <E> List<E> select(List<E> list,
                                 Predicate<E> pred)

select

public static <E> Set<E> select(Set<E> set,
                                Predicate<E> pred)

reject

public static <E> List<E> reject(List<E> list,
                                 Predicate<E> pred)

reject

public List<T> reject(Predicate<T> pred)

rejectIndexed

public static <E> List<E> rejectIndexed(List<E> list,
                                        PredicateIndexed<E> pred)

reject

public static <E> Set<E> reject(Set<E> set,
                                Predicate<E> pred)

filterFalse

public static <E> List<E> filterFalse(List<E> list,
                                      Predicate<E> pred)

filterFalse

public List<T> filterFalse(Predicate<T> pred)

filterFalse

public static <E> Set<E> filterFalse(Set<E> set,
                                     Predicate<E> pred)

every

public static <E> boolean every(Iterable<E> iterable,
                                Predicate<E> pred)

every

public boolean every(Predicate<T> pred)

all

public static <E> boolean all(Iterable<E> iterable,
                              Predicate<E> pred)

all

public boolean all(Predicate<T> pred)

some

public static <E> boolean some(Iterable<E> iterable,
                               Predicate<E> pred)

some

public boolean some(Predicate<T> pred)

any

public static <E> boolean any(Iterable<E> iterable,
                              Predicate<E> pred)

any

public boolean any(Predicate<T> pred)

count

public static <E> int count(Iterable<E> iterable,
                            Predicate<E> pred)

count

public int count(Predicate<T> pred)

contains

public static <E> boolean contains(Iterable<E> iterable,
                                   E elem)

contains

public boolean contains(T elem)

containsWith

public static <E> boolean containsWith(Iterable<E> iterable,
                                       E elem)

containsWith

public boolean containsWith(T elem)

contains

public static <E> boolean contains(Iterable<E> iterable,
                                   E elem,
                                   int fromIndex)

containsAtLeast

public boolean containsAtLeast(T value,
                               int count)

containsAtMost

public boolean containsAtMost(T value,
                              int count)

containsAtLeast

public static <E> boolean containsAtLeast(Iterable<E> iterable,
                                          E value,
                                          int count)

containsAtMost

public static <E> boolean containsAtMost(Iterable<E> iterable,
                                         E value,
                                         int count)

include

public static <E> boolean include(Iterable<E> iterable,
                                  E elem)

invoke

public static <E> List<E> invoke(Iterable<E> iterable,
                                 String methodName,
                                 List<Object> args)

invoke

public List<T> invoke(String methodName,
                      List<Object> args)

invoke

public static <E> List<E> invoke(Iterable<E> iterable,
                                 String methodName)

invoke

public List<T> invoke(String methodName)

pluck

public static <E> List<Object> pluck(List<E> list,
                                     String propertyName)

pluck

public List<Object> pluck(String propertyName)

pluck

public static <E> Set<Object> pluck(Set<E> set,
                                    String propertyName)

where

public static <T,E> List<E> where(List<E> list,
                                        List<Tuple<String,T>> properties)

where

public <E> List<T> where(List<Tuple<String,E>> properties)

where

public static <T,E> Set<E> where(Set<E> set,
                                       List<Tuple<String,T>> properties)

findWhere

public static <T,E> Optional<E> findWhere(Iterable<E> iterable,
                                                List<Tuple<String,T>> properties)

findWhere

public <E> Optional<T> findWhere(List<Tuple<String,E>> properties)

max

public static <E extends Comparable<? super E>> E max(Collection<E> collection)

max

public T max()

max

public static <E,F extends Comparable> E max(Collection<E> collection,
                                                   Function<E,F> func)

max

public <F extends Comparable<? super F>> T max(Function<T,F> func)

min

public static <E extends Comparable<? super E>> E min(Collection<E> collection)

min

public T min()

min

public static <E,F extends Comparable> E min(Collection<E> collection,
                                                   Function<E,F> func)

min

public <F extends Comparable<? super F>> T min(Function<T,F> func)

shuffle

public static <E> List<E> shuffle(Iterable<E> iterable)

shuffle

public List<T> shuffle()

sample

public static <E> E sample(Iterable<E> iterable)

sample

public T sample()

sample

public static <E> Set<E> sample(List<E> list,
                                int howMany)

sortWith

public static <T extends Comparable<? super T>> List<T> sortWith(Iterable<T> iterable,
                                                                 Comparator<T> comparator)

sortWith

public <E extends Comparable<? super E>> List<E> sortWith(Comparator<E> comparator)

sortBy

public static <E,T extends Comparable<? super T>> List<E> sortBy(Iterable<E> iterable,
                                                                       Function<E,T> func)

sortBy

public <E,V extends Comparable<? super V>> List<E> sortBy(Function<E,V> func)

sortBy

public static <K,V extends Comparable<? super V>> List<Map<K,V>> sortBy(Iterable<Map<K,V>> iterable,
                                                                                    K key)

groupBy

public static <K,E> Map<K,List<E>> groupBy(Iterable<E> iterable,
                                                       Function<E,K> func)

groupBy

public <K,E> Map<K,List<E>> groupBy(Function<E,K> func)

groupBy

public static <K,E> Map<K,Optional<E>> groupBy(Iterable<E> iterable,
                                                           Function<E,K> func,
                                                           BinaryOperator<E> binaryOperator)

groupBy

public <K,E> Map<K,Optional<E>> groupBy(Function<E,K> func,
                                                    BinaryOperator<E> binaryOperator)

indexBy

public static <K,E> Map<K,List<E>> indexBy(Iterable<E> iterable,
                                                       String property)

indexBy

public <K,E> Map<K,List<E>> indexBy(String property)

countBy

public static <K,E> Map<K,Integer> countBy(Iterable<E> iterable,
                                                       Function<E,K> func)

countBy

public static <K> Map<K,Integer> countBy(Iterable<K> iterable)

countBy

public <K,E> Map<K,Integer> countBy(Function<E,K> func)

countBy

public <K> Map<K,Integer> countBy()

toArray

public static <E> E[] toArray(Iterable<E> iterable)

toArray

public <E> E[] toArray()

toMap

public static <K,V> Map<K,V> toMap(Iterable<Map.Entry<K,V>> iterable)

toMap

public <K,V> Map<K,V> toMap()

toMap

public static <K,V> Map<K,V> toMap(List<Tuple<K,V>> tuples)

toCardinalityMap

public Map<T,Integer> toCardinalityMap()

toCardinalityMap

public static <K> Map<K,Integer> toCardinalityMap(Iterable<K> iterable)

size

public static int size(Iterable<?> iterable)

size

public int size()

size

public static <E> int size(E... array)

partition

public static <E> List<List<E>> partition(Iterable<E> iterable,
                                          Predicate<E> pred)

partition

public static <E> List<E>[] partition(E[] iterable,
                                      Predicate<E> pred)

singleOrNull

public T singleOrNull()

singleOrNull

public T singleOrNull(Predicate<T> pred)

singleOrNull

public static <E> E singleOrNull(Iterable<E> iterable)

singleOrNull

public static <E> E singleOrNull(Iterable<E> iterable,
                                 Predicate<E> pred)

first

public static <E> E first(Iterable<E> iterable)

first

public static <E> E first(E... array)

first

public static <E> List<E> first(List<E> list,
                                int n)

first

public T first()

first

public List<T> first(int n)

first

public static <E> E first(Iterable<E> iterable,
                          Predicate<E> pred)

first

public static <E> List<E> first(Iterable<E> iterable,
                                Predicate<E> pred,
                                int n)

first

public T first(Predicate<T> pred)

first

public List<T> first(Predicate<T> pred,
                     int n)

firstOrNull

public static <E> E firstOrNull(Iterable<E> iterable)

firstOrNull

public T firstOrNull()

firstOrNull

public static <E> E firstOrNull(Iterable<E> iterable,
                                Predicate<E> pred)

firstOrNull

public T firstOrNull(Predicate<T> pred)

head

public static <E> E head(Iterable<E> iterable)

head

public static <E> E head(E... array)

head

public static <E> List<E> head(List<E> list,
                               int n)

head

public T head()

head

public List<T> head(int n)

initial

public static <E> List<E> initial(List<E> list)

initial

public static <E> List<E> initial(List<E> list,
                                  int n)

initial

public static <E> E[] initial(E... array)

initial

public static <E> E[] initial(E[] array,
                              int n)

initial

public List<T> initial()

initial

public List<T> initial(int n)

last

public static <E> E last(E... array)

last

public static <E> E last(List<E> list)

last

public static <E> List<E> last(List<E> list,
                               int n)

last

public T last()

last

public List<T> last(int n)

last

public static <E> E last(List<E> list,
                         Predicate<E> pred)

last

public T last(Predicate<T> pred)

lastOrNull

public static <E> E lastOrNull(List<E> list)

lastOrNull

public T lastOrNull()

lastOrNull

public static <E> E lastOrNull(List<E> list,
                               Predicate<E> pred)

lastOrNull

public T lastOrNull(Predicate<T> pred)

rest

public static <E> List<E> rest(List<E> list)

rest

public static <E> List<E> rest(List<E> list,
                               int n)

rest

public static <E> E[] rest(E... array)

rest

public static <E> E[] rest(E[] array,
                           int n)

rest

public List<T> rest()

rest

public List<T> rest(int n)

tail

public static <E> List<E> tail(List<E> list)

tail

public static <E> List<E> tail(List<E> list,
                               int n)

tail

public static <E> E[] tail(E... array)

tail

public static <E> E[] tail(E[] array,
                           int n)

tail

public List<T> tail()

tail

public List<T> tail(int n)

drop

public static <E> List<E> drop(List<E> list)

drop

public static <E> List<E> drop(List<E> list,
                               int n)

drop

public static <E> E[] drop(E... array)

drop

public static <E> E[] drop(E[] array,
                           int n)

compact

public static <E> List<E> compact(List<E> list)

compact

public static <E> E[] compact(E... array)

compact

public static <E> List<E> compact(List<E> list,
                                  E falsyValue)

compact

public static <E> E[] compact(E[] array,
                              E falsyValue)

compact

public List<T> compact()

compact

public List<T> compact(T falsyValue)

flatten

public static <E> List<E> flatten(List<?> list)

flatten

public static <E> List<E> flatten(List<?> list,
                                  boolean shallow)

flatten

public List<T> flatten()

flatten

public List<T> flatten(boolean shallow)

without

public static <E> List<E> without(List<E> list,
                                  E... values)

without

public static <E> E[] without(E[] array,
                              E... values)

uniq

public static <E> List<E> uniq(List<E> list)

uniq

public static <E> E[] uniq(E... array)

uniq

public static <K,E> Collection<E> uniq(Iterable<E> iterable,
                                             Function<E,K> func)

uniq

public static <K,E> E[] uniq(E[] array,
                                   Function<E,K> func)

distinct

public static <E> List<E> distinct(List<E> list)

distinct

public static <E> E[] distinct(E... array)

distinctBy

public static <K,E> Collection<E> distinctBy(Iterable<E> iterable,
                                                   Function<E,K> func)

distinctBy

public static <K,E> E[] distinctBy(E[] array,
                                         Function<E,K> func)

union

public static <E> List<E> union(List<E> list,
                                List<E>... lists)

unionWith

public List<T> unionWith(List<T>... lists)

union

public static <E> E[] union(E[]... arrays)

intersection

public static <E> List<E> intersection(List<E> list1,
                                       List<E> list2)

intersection

public static <E> List<E> intersection(List<E> list,
                                       List<E>... lists)

intersectionWith

public List<T> intersectionWith(List<T>... lists)

intersection

public static <E> E[] intersection(E[]... arrays)

difference

public static <E> List<E> difference(List<E> list1,
                                     List<E> list2)

difference

public static <E> List<E> difference(List<E> list,
                                     List<E>... lists)

differenceWith

public List<T> differenceWith(List<T>... lists)

difference

public static <E> E[] difference(E[]... arrays)

zip

public static <T> List<List<T>> zip(List<T>... lists)

unzip

public static <T> List<List<T>> unzip(List<T>... lists)

object

public static <K,V> List<Tuple<K,V>> object(List<K> keys,
                                                        List<V> values)

findIndex

public static <E> int findIndex(List<E> list,
                                Predicate<E> pred)

findIndex

public static <E> int findIndex(E[] array,
                                Predicate<E> pred)

findLastIndex

public static <E> int findLastIndex(List<E> list,
                                    Predicate<E> pred)

findLastIndex

public static <E> int findLastIndex(E[] array,
                                    Predicate<E> pred)

binarySearch

public static <E extends Comparable<E>> int binarySearch(Iterable<E> iterable,
                                                         E key)

binarySearch

public static <E extends Comparable<E>> int binarySearch(E[] array,
                                                         E key)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(List<E> list,
                                                        E value)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(E[] array,
                                                        E value)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(List<E> list,
                                                        E value,
                                                        String propertyName)

sortedIndex

public static <E extends Comparable<E>> int sortedIndex(E[] array,
                                                        E value,
                                                        String propertyName)

indexOf

public static <E> int indexOf(List<E> list,
                              E value)

indexOf

public static <E> int indexOf(E[] array,
                              E value)

lastIndexOf

public static <E> int lastIndexOf(List<E> list,
                                  E value)

lastIndexOf

public static <E> int lastIndexOf(E[] array,
                                  E value)

range

public static List<Integer> range(int stop)

range

public static List<Integer> range(int start,
                                  int stop)

range

public static List<Integer> range(int start,
                                  int stop,
                                  int step)

range

public static List<Character> range(char stop)

range

public static List<Character> range(char start,
                                    char stop)

range

public static List<Character> range(char start,
                                    char stop,
                                    int step)

chunk

public static <T> List<List<T>> chunk(Iterable<T> iterable,
                                      int size)

chunk

public static <T> List<List<T>> chunk(Iterable<T> iterable,
                                      int size,
                                      int step)

chunkFill

public static <T> List<List<T>> chunkFill(Iterable<T> iterable,
                                          int size,
                                          T fillValue)

chunkFill

public static <T> List<List<T>> chunkFill(Iterable<T> iterable,
                                          int size,
                                          int step,
                                          T fillValue)

chunk

public List<List<T>> chunk(int size)

chunk

public List<List<T>> chunk(int size,
                           int step)

chunkFill

public List<List<T>> chunkFill(int size,
                               T fillvalue)

chunkFill

public List<List<T>> chunkFill(int size,
                               int step,
                               T fillvalue)

cycle

public static <T> List<T> cycle(Iterable<T> iterable,
                                int times)

cycle

public List<T> cycle(int times)

repeat

public static <T> List<T> repeat(T element,
                                 int times)

interpose

public static <T> List<T> interpose(Iterable<T> iterable,
                                    T interElement)

interposeByList

public static <T> List<T> interposeByList(Iterable<T> iterable,
                                          Iterable<T> interIter)

interpose

public List<T> interpose(T element)

interposeByList

public List<T> interposeByList(Iterable<T> interIter)

bind

public static <T,F> Function<F,T> bind(Function<F,T> function)

memoize

public static <T,F> Function<F,T> memoize(Function<F,T> function)

delay

public static <T> ScheduledFuture<T> delay(Supplier<T> function,
                                           int delayMilliseconds)

defer

public static <T> ScheduledFuture<T> defer(Supplier<T> function)

defer

public static ScheduledFuture<Void> defer(Runnable runnable)

throttle

public static <T> Supplier<T> throttle(Supplier<T> function,
                                       int waitMilliseconds)

debounce

public static <T> Supplier<T> debounce(Supplier<T> function,
                                       int delayMilliseconds)

wrap

public static <T> Function<Void,T> wrap(Function<T,T> function,
                                              Function<Function<T,T>,T> wrapper)

negate

public static <E> Predicate<E> negate(Predicate<E> pred)

compose

public static <T> Function<T,T> compose(Function<T,T>... func)

after

public static <E> Supplier<E> after(int count,
                                    Supplier<E> function)

before

public static <E> Supplier<E> before(int count,
                                     Supplier<E> function)

once

public static <T> Supplier<T> once(Supplier<T> function)

keys

public static <K,V> Set<K> keys(Map<K,V> object)

values

public static <K,V> Collection<V> values(Map<K,V> object)

mapObject

public static <K,V> List<Tuple<K,V>> mapObject(Map<K,V> object,
                                                           Function<? super V,V> func)

pairs

public static <K,V> List<Tuple<K,V>> pairs(Map<K,V> object)

invert

public static <K,V> List<Tuple<V,K>> invert(Map<K,V> object)

functions

public static List<String> functions(Object object)

methods

public static List<String> methods(Object object)

extend

public static <K,V> Map<K,V> extend(Map<K,V> destination,
                                                Map<K,V>... sources)

findKey

public static <E> E findKey(List<E> list,
                            Predicate<E> pred)

findKey

public static <E> E findKey(E[] array,
                            Predicate<E> pred)

findLastKey

public static <E> E findLastKey(List<E> list,
                                Predicate<E> pred)

findLastKey

public static <E> E findLastKey(E[] array,
                                Predicate<E> pred)

pick

public static <K,V> List<Tuple<K,V>> pick(Map<K,V> object,
                                                      K... keys)

pick

public static <K,V> List<Tuple<K,V>> pick(Map<K,V> object,
                                                      Predicate<V> pred)

omit

public static <K,V> List<Tuple<K,V>> omit(Map<K,V> object,
                                                      K... keys)

omit

public static <K,V> List<Tuple<K,V>> omit(Map<K,V> object,
                                                      Predicate<V> pred)

defaults

public static <K,V> Map<K,V> defaults(Map<K,V> object,
                                                  Map<K,V> defaults)

clone

public static Object clone(Object obj)

clone

public static <E> E[] clone(E... iterable)

tap

public static <T> void tap(Iterable<T> iterable,
                           Consumer<? super T> func)

isMatch

public static <K,V> boolean isMatch(Map<K,V> object,
                                          Map<K,V> properties)

isEqual

public static boolean isEqual(Object object,
                              Object other)

isEmpty

public static <K,V> boolean isEmpty(Map<K,V> object)

isEmpty

public static <T> boolean isEmpty(Iterable<T> iterable)

isEmpty

public boolean isEmpty()

isNotEmpty

public static <K,V> boolean isNotEmpty(Map<K,V> object)

isNotEmpty

public static <T> boolean isNotEmpty(Iterable<T> iterable)

isNotEmpty

public boolean isNotEmpty()

isArray

public static boolean isArray(Object object)

isObject

public static boolean isObject(Object object)

isFunction

public static boolean isFunction(Object object)

isString

public static boolean isString(Object object)

isNumber

public static boolean isNumber(Object object)

isDate

public static boolean isDate(Object object)

isRegExp

public static boolean isRegExp(Object object)

isError

public static boolean isError(Object object)

isBoolean

public static boolean isBoolean(Object object)

isNull

public static boolean isNull(Object object)

has

public static <K,V> boolean has(Map<K,V> object,
                                      K key)

identity

public static <E> E identity(E value)

constant

public static <E> Supplier<E> constant(E value)

property

public static <K,V> Function<Map<K,V>,V> property(K key)

propertyOf

public static <K,V> Function<K,V> propertyOf(Map<K,V> object)

matcher

public static <K,V> Predicate<Map<K,V>> matcher(Map<K,V> object)

times

public static void times(int count,
                         Runnable runnable)

random

public static int random(int min,
                         int max)

random

public static int random(int max)

now

public static long now()

escape

public static String escape(String value)

unescape

public static String unescape(String value)

result

public static <E> Object result(Iterable<E> iterable,
                                Predicate<E> pred)

uniqueId

public static String uniqueId(String prefix)

uniquePassword

public static String uniquePassword()

template

public static <K,V> Template<Map<K,V>> template(String template)

format

public static String format(String template,
                            Object... params)

iterate

public static <T> Iterable<T> iterate(T seed,
                                      UnaryOperator<T> unaryOperator)

chain

public static <T> U.Chain<T> chain(List<T> list)

chain

public static <T> U.Chain<T> chain(Iterable<T> iterable)

chain

public static <T> U.Chain<T> chain(Iterable<T> iterable,
                                   int size)

chain

public static <T> U.Chain<T> chain(T... array)

chain

public static U.Chain<Integer> chain(int[] array)

chain

public U.Chain<T> chain()

mixin

public static void mixin(String funcName,
                         Function<String,String> func)

call

public Optional<String> call(String funcName)

sort

public static <T extends Comparable<T>> List<T> sort(Iterable<T> iterable)

sort

public static <T extends Comparable<T>> T[] sort(T... array)

sort

public List<Comparable> sort()

join

public static <T> String join(Iterable<T> iterable,
                              String separator)

join

public static <T> String join(Iterable<T> iterable)

join

public static <T> String join(T[] array,
                              String separator)

join

public static <T> String join(T[] array)

join

public String join(String separator)

join

public String join()

push

public static <T> List<T> push(List<T> list,
                               T... values)

push

public List<T> push(T... values)

pop

public static <T> Tuple<T,List<T>> pop(List<T> list)

pop

public Tuple<T,List<T>> pop()

unshift

public static <T> List<T> unshift(List<T> list,
                                  T... values)

unshift

public List<T> unshift(T... values)

shift

public static <T> Tuple<T,List<T>> shift(List<T> list)

shift

public Tuple<T,List<T>> shift()

concat

public static <T> T[] concat(T[] first,
                             T[]... other)

concat

public static <T> List<T> concat(Iterable<T> first,
                                 Iterable<T>... other)

concatWith

public List<T> concatWith(Iterable<T>... other)

slice

public static <T> List<T> slice(Iterable<T> iterable,
                                int start)

slice

public static <T> T[] slice(T[] array,
                            int start)

slice

public List<T> slice(int start)

slice

public static <T> List<T> slice(Iterable<T> iterable,
                                int start,
                                int end)

slice

public static <T> T[] slice(T[] array,
                            int start,
                            int end)

slice

public List<T> slice(int start,
                     int end)

splitAt

public static <T> List<List<T>> splitAt(Iterable<T> iterable,
                                        int position)

splitAt

public static <T> List<List<T>> splitAt(T[] array,
                                        int position)

splitAt

public List<List<T>> splitAt(int position)

takeSkipping

public static <T> List<T> takeSkipping(Iterable<T> iterable,
                                       int stepSize)

takeSkipping

public static <T> List<T> takeSkipping(T[] array,
                                       int stepSize)

takeSkipping

public List<T> takeSkipping(int stepSize)

reverse

public static <T> List<T> reverse(Iterable<T> iterable)

reverse

public static <T> T[] reverse(T... array)

reverse

public static List<Integer> reverse(int[] array)

reverse

public List<T> reverse()

getIterable

public Iterable<T> getIterable()

value

public Iterable<T> value()

getString

public Optional<String> getString()

setTimeout

public static <T> ScheduledFuture<T> setTimeout(Supplier<T> function,
                                                int delayMilliseconds)

clearTimeout

public static void clearTimeout(ScheduledFuture<?> scheduledFuture)

setInterval

public static <T> ScheduledFuture setInterval(Supplier<T> function,
                                              int delayMilliseconds)

clearInterval

public static void clearInterval(ScheduledFuture scheduledFuture)

copyOf

public static <T> List<T> copyOf(Iterable<T> iterable)

copyOf

public List<T> copyOf()

copyOfRange

public static <T> List<T> copyOfRange(Iterable<T> iterable,
                                      int start,
                                      int end)

copyOfRange

public List<T> copyOfRange(int start,
                           int end)

elementAt

public static <T> T elementAt(List<T> list,
                              int index)

elementAt

public T elementAt(int index)

get

public static <T> T get(List<T> list,
                        int index)

get

public T get(int index)

set

public static <T> Tuple<T,List<T>> set(List<T> list,
                                             int index,
                                             T value)

set

public Tuple<T,List<T>> set(int index,
                                  T value)

elementAtOrElse

public static <T> T elementAtOrElse(List<T> list,
                                    int index,
                                    T defaultValue)

elementAtOrElse

public T elementAtOrElse(int index,
                         T defaultValue)

elementAtOrNull

public static <T> T elementAtOrNull(List<T> list,
                                    int index)

elementAtOrNull

public T elementAtOrNull(int index)

lastIndex

public static <T> int lastIndex(Iterable<T> iterable)

lastIndex

public static <T> int lastIndex(T[] array)

lastIndex

public static int lastIndex(int[] array)

checkNotNull

public static <T> T checkNotNull(T reference)

checkNotNullElements

public static <T> List<T> checkNotNullElements(List<T> references)

checkNotNull

public static <T> T checkNotNull(T reference,
                                 Object errorMessage)

nonNull

public static boolean nonNull(Object obj)

defaultTo

public static <T> T defaultTo(T value,
                              T defaultValue)

newArrayList

protected static <T> List<T> newArrayList()

newArrayList

protected static <T> List<T> newArrayList(Iterable<T> iterable)

newArrayList

protected static <T> List<T> newArrayList(T object)

newArrayList

protected static <T> List<T> newArrayList(Iterable<T> iterable,
                                          int size)

newIntegerList

protected static List<Integer> newIntegerList(int... array)

newArrayListWithExpectedSize

protected static <T> List<T> newArrayListWithExpectedSize(int size)

newLinkedHashSet

protected static <T> Set<T> newLinkedHashSet()

newLinkedHashSet

protected static <T> Set<T> newLinkedHashSet(Iterable<T> iterable)

newLinkedHashSetWithExpectedSize

protected static <T> Set<T> newLinkedHashSetWithExpectedSize(int size)

newLinkedHashMap

protected static <K,E> Map<K,E> newLinkedHashMap()

and

public static <T> Predicate<T> and(Predicate<? super T> pred1,
                                   Predicate<? super T> pred2,
                                   Predicate<? super T>... rest)

or

public static <T> Predicate<T> or(Predicate<? super T> pred1,
                                  Predicate<? super T> pred2,
                                  Predicate<? super T>... rest)

main

public static void main(String... args)