java.lang.Object
- com.util.lodash.Underscore<T>

Direct Known Subclasses:

U
```
public class Underscore<T>
extends java.lang.Object
```
Underscore-java is a java port of Underscore.js.

Author:

Valentyn Kolesnikov

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`Underscore.Chain<T>`
`static class`	`Underscore.ValueThenKeyComparator<K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<? super V>>`

Constructor Summary

Constructors
Constructor Description

Underscore(java.lang.Iterable<T> iterable)

Underscore(java.lang.String string)

Method Summary

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

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

Constructor Detail

Underscore

public Underscore(java.lang.Iterable<T> iterable)

Underscore

public Underscore(java.lang.String string)

Method Detail

templateSettings

public static void templateSettings(java.util.Map<java.lang.String,java.lang.String> templateSettings)

iteratee

public static <K,V> java.util.function.Function<java.util.Map<K,V>,V> iteratee(K key)

each

public static <T> void each(java.lang.Iterable<T> iterable,
                            java.util.function.Consumer<? super T> func)

eachIndexed

public static <T> void eachIndexed(java.lang.Iterable<T> iterable,
                                   java.util.function.BiConsumer<java.lang.Integer,? super T> func)

each

public void each(java.util.function.Consumer<? super T> func)

eachRight

public static <T> void eachRight(java.lang.Iterable<T> iterable,
                                 java.util.function.Consumer<? super T> func)

eachRight

public void eachRight(java.util.function.Consumer<? super T> func)

forEach

public static <T> void forEach(java.lang.Iterable<T> iterable,
                               java.util.function.Consumer<? super T> func)

forEachIndexed

public static <T> void forEachIndexed(java.lang.Iterable<T> iterable,
                                      java.util.function.BiConsumer<java.lang.Integer,? super T> func)

forEach

public void forEach(java.util.function.Consumer<? super T> func)

forEachIndexed

public void forEachIndexed(java.util.function.BiConsumer<java.lang.Integer,? super T> func)

forEachRight

public static <T> void forEachRight(java.lang.Iterable<T> iterable,
                                    java.util.function.Consumer<? super T> func)

forEachRight

public void forEachRight(java.util.function.Consumer<? super T> func)

map

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

mapMulti

public static <T,E> java.util.List<T> mapMulti(java.util.List<E> list,
                                                     java.util.function.BiConsumer<? super E,? super java.util.function.Consumer<T>> mapper)

map

public <F> java.util.List<F> map(java.util.function.Function<? super T,F> func)

map

public static <T> java.util.List<T> map(int[] array,
                                        java.util.function.Function<? super java.lang.Integer,T> func)

map

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

mapIndexed

public static <T,E> java.util.List<T> mapIndexed(java.util.List<E> list,
                                                       java.util.function.BiFunction<java.lang.Integer,? super E,T> func)

replace

public static <T> java.util.List<T> replace(java.lang.Iterable<T> iter,
                                            java.util.function.Predicate<T> pred,
                                            T value)

replace

public java.util.List<T> replace(java.util.function.Predicate<T> pred,
                                 T value)

replaceIndexed

public static <T> java.util.List<T> replaceIndexed(java.lang.Iterable<T> iter,
                                                   PredicateIndexed<T> pred,
                                                   T value)

replaceIndexed

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

mapIndexed

public <F> java.util.List<F> mapIndexed(java.util.function.BiFunction<java.lang.Integer,? super T,F> func)

collect

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

collect

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

reduce

public static <T,E> E reduce(java.lang.Iterable<T> iterable,
                                   java.util.function.BiFunction<E,T,E> func,
                                   E zeroElem)

reduce

public static <T> Optional<T> reduce(java.lang.Iterable<T> iterable,
                                     java.util.function.BinaryOperator<T> func)

reduce

public static <E> E reduce(int[] array,
                           java.util.function.BiFunction<E,? super java.lang.Integer,E> func,
                           E zeroElem)

reduce

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

foldl

public static <T,E> E foldl(java.lang.Iterable<T> iterable,
                                  java.util.function.BiFunction<E,T,E> func,
                                  E zeroElem)

inject

public static <T,E> E inject(java.lang.Iterable<T> iterable,
                                   java.util.function.BiFunction<E,T,E> func,
                                   E zeroElem)

reduceRight

public static <T,E> E reduceRight(java.lang.Iterable<T> iterable,
                                        java.util.function.BiFunction<E,T,E> func,
                                        E zeroElem)

reduceRight

public static <T> Optional<T> reduceRight(java.lang.Iterable<T> iterable,
                                          java.util.function.BinaryOperator<T> func)

reduceRight

public static <E> E reduceRight(int[] array,
                                java.util.function.BiFunction<E,? super java.lang.Integer,E> func,
                                E zeroElem)

reduceRight

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

foldr

public static <T,E> E foldr(java.lang.Iterable<T> iterable,
                                  java.util.function.BiFunction<E,T,E> func,
                                  E zeroElem)

find

public static <E> Optional<E> find(java.lang.Iterable<E> iterable,
                                   java.util.function.Predicate<E> pred)

detect

public static <E> Optional<E> detect(java.lang.Iterable<E> iterable,
                                     java.util.function.Predicate<E> pred)

findLast

public static <E> Optional<E> findLast(java.lang.Iterable<E> iterable,
                                       java.util.function.Predicate<E> pred)

filter

public static <E> java.util.List<E> filter(java.lang.Iterable<E> iterable,
                                           java.util.function.Predicate<E> pred)

filter

public static <E> java.util.List<E> filter(java.util.List<E> list,
                                           java.util.function.Predicate<E> pred)

filter

public java.util.List<T> filter(java.util.function.Predicate<T> pred)

filterIndexed

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

filter

public static <E> java.util.Set<E> filter(java.util.Set<E> set,
                                          java.util.function.Predicate<E> pred)

select

public static <E> java.util.List<E> select(java.util.List<E> list,
                                           java.util.function.Predicate<E> pred)

select

public static <E> java.util.Set<E> select(java.util.Set<E> set,
                                          java.util.function.Predicate<E> pred)

reject

public static <E> java.util.List<E> reject(java.util.List<E> list,
                                           java.util.function.Predicate<E> pred)

reject

public java.util.List<T> reject(java.util.function.Predicate<T> pred)

rejectIndexed

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

reject

public static <E> java.util.Set<E> reject(java.util.Set<E> set,
                                          java.util.function.Predicate<E> pred)

filterFalse

public static <E> java.util.List<E> filterFalse(java.util.List<E> list,
                                                java.util.function.Predicate<E> pred)

filterFalse

public java.util.List<T> filterFalse(java.util.function.Predicate<T> pred)

filterFalse

public static <E> java.util.Set<E> filterFalse(java.util.Set<E> set,
                                               java.util.function.Predicate<E> pred)

every

public static <E> boolean every(java.lang.Iterable<E> iterable,
                                java.util.function.Predicate<E> pred)

every

public boolean every(java.util.function.Predicate<T> pred)

all

public static <E> boolean all(java.lang.Iterable<E> iterable,
                              java.util.function.Predicate<E> pred)

all

public boolean all(java.util.function.Predicate<T> pred)

some

public static <E> boolean some(java.lang.Iterable<E> iterable,
                               java.util.function.Predicate<E> pred)

some

public boolean some(java.util.function.Predicate<T> pred)

any

public static <E> boolean any(java.lang.Iterable<E> iterable,
                              java.util.function.Predicate<E> pred)

any

public boolean any(java.util.function.Predicate<T> pred)

count

public static <E> int count(java.lang.Iterable<E> iterable,
                            java.util.function.Predicate<E> pred)

count

public int count(java.util.function.Predicate<T> pred)

contains

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

contains
```
public boolean contains(T elem)
```

containsWith

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

containsWith

public boolean containsWith(T elem)

contains

public static <E> boolean contains(java.lang.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(java.lang.Iterable<E> iterable,
                                          E value,
                                          int count)

containsAtMost

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

include

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

invoke

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

invoke

public java.util.List<T> invoke(java.lang.String methodName,
                                java.util.List<java.lang.Object> args)

invoke

public static <E> java.util.List<E> invoke(java.lang.Iterable<E> iterable,
                                           java.lang.String methodName)

invoke

public java.util.List<T> invoke(java.lang.String methodName)

pluck

public static <E> java.util.List<java.lang.Object> pluck(java.util.List<E> list,
                                                         java.lang.String propertyName)

pluck

public java.util.List<java.lang.Object> pluck(java.lang.String propertyName)

pluck

public static <E> java.util.Set<java.lang.Object> pluck(java.util.Set<E> set,
                                                        java.lang.String propertyName)

where

public static <T,E> java.util.List<E> where(java.util.List<E> list,
                                                  java.util.List<Tuple<java.lang.String,T>> properties)

where

public <E> java.util.List<T> where(java.util.List<Tuple<java.lang.String,E>> properties)

where

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

findWhere

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

findWhere

public <E> Optional<T> findWhere(java.util.List<Tuple<java.lang.String,E>> properties)

max

public static <E extends java.lang.Comparable<? super E>> E max(java.util.Collection<E> collection)

max
```
public T max()
```

max

public static <E,F extends java.lang.Comparable> E max(java.util.Collection<E> collection,
                                                             java.util.function.Function<E,F> func)

max

public <F extends java.lang.Comparable<? super F>> T max(java.util.function.Function<T,F> func)

min

public static <E extends java.lang.Comparable<? super E>> E min(java.util.Collection<E> collection)

min
```
public T min()
```

min

public static <E,F extends java.lang.Comparable> E min(java.util.Collection<E> collection,
                                                             java.util.function.Function<E,F> func)

min

public <F extends java.lang.Comparable<? super F>> T min(java.util.function.Function<T,F> func)

shuffle

public static <E> java.util.List<E> shuffle(java.lang.Iterable<E> iterable)

shuffle
```
public java.util.List<T> shuffle()
```

sample

public static <E> E sample(java.lang.Iterable<E> iterable)

sample
```
public T sample()
```

sample

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

sortWith

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

sortWith

public <E extends java.lang.Comparable<? super E>> java.util.List<E> sortWith(java.util.Comparator<E> comparator)

sortBy

public static <E,T extends java.lang.Comparable<? super T>> java.util.List<E> sortBy(java.lang.Iterable<E> iterable,
                                                                                           java.util.function.Function<E,T> func)

sortBy

public <E,V extends java.lang.Comparable<? super V>> java.util.List<E> sortBy(java.util.function.Function<E,V> func)

sortBy

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

groupBy

public static <K,E> java.util.Map<K,java.util.List<E>> groupBy(java.lang.Iterable<E> iterable,
                                                                           java.util.function.Function<E,K> func)

groupBy

public <K,E> java.util.Map<K,java.util.List<E>> groupBy(java.util.function.Function<E,K> func)

groupBy

public static <K,E> java.util.Map<K,Optional<E>> groupBy(java.lang.Iterable<E> iterable,
                                                                     java.util.function.Function<E,K> func,
                                                                     java.util.function.BinaryOperator<E> binaryOperator)

groupBy

public <K,E> java.util.Map<K,Optional<E>> groupBy(java.util.function.Function<E,K> func,
                                                              java.util.function.BinaryOperator<E> binaryOperator)

indexBy

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

indexBy

public <K,E> java.util.Map<K,java.util.List<E>> indexBy(java.lang.String property)

countBy

public static <K,E> java.util.Map<K,java.lang.Integer> countBy(java.lang.Iterable<E> iterable,
                                                                           java.util.function.Function<E,K> func)

countBy

public static <K> java.util.Map<K,java.lang.Integer> countBy(java.lang.Iterable<K> iterable)

countBy

public <K,E> java.util.Map<K,java.lang.Integer> countBy(java.util.function.Function<E,K> func)

countBy

public <K> java.util.Map<K,java.lang.Integer> countBy()

toArray

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

toArray
```
public <E> E[] toArray()
```

toMap

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

toMap

public <K,V> java.util.Map<K,V> toMap()

toMap

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

toCardinalityMap

public java.util.Map<T,java.lang.Integer> toCardinalityMap()

toCardinalityMap

public static <K> java.util.Map<K,java.lang.Integer> toCardinalityMap(java.lang.Iterable<K> iterable)

size

public static int size(java.lang.Iterable<?> iterable)

size
```
public int size()
```

size

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

partition

public static <E> java.util.List<java.util.List<E>> partition(java.lang.Iterable<E> iterable,
                                                              java.util.function.Predicate<E> pred)

partition

public static <E> java.util.List<E>[] partition(E[] iterable,
                                                java.util.function.Predicate<E> pred)

singleOrNull
```
public T singleOrNull()
```

singleOrNull

public T singleOrNull(java.util.function.Predicate<T> pred)

singleOrNull

public static <E> E singleOrNull(java.lang.Iterable<E> iterable)

singleOrNull

public static <E> E singleOrNull(java.lang.Iterable<E> iterable,
                                 java.util.function.Predicate<E> pred)

first

public static <E> E first(java.lang.Iterable<E> iterable)

first

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

first

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

first
```
public T first()
```

first

public java.util.List<T> first(int n)

first

public static <E> E first(java.lang.Iterable<E> iterable,
                          java.util.function.Predicate<E> pred)

first

public static <E> java.util.List<E> first(java.lang.Iterable<E> iterable,
                                          java.util.function.Predicate<E> pred,
                                          int n)

first

public T first(java.util.function.Predicate<T> pred)

first

public java.util.List<T> first(java.util.function.Predicate<T> pred,
                               int n)

firstOrNull

public static <E> E firstOrNull(java.lang.Iterable<E> iterable)

firstOrNull
```
public T firstOrNull()
```

firstOrNull

public static <E> E firstOrNull(java.lang.Iterable<E> iterable,
                                java.util.function.Predicate<E> pred)

firstOrNull

public T firstOrNull(java.util.function.Predicate<T> pred)

head

public static <E> E head(java.lang.Iterable<E> iterable)

head

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

head

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

head
```
public T head()
```

head

public java.util.List<T> head(int n)

initial

public static <E> java.util.List<E> initial(java.util.List<E> list)

initial

public static <E> java.util.List<E> initial(java.util.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 java.util.List<T> initial()
```

initial

public java.util.List<T> initial(int n)

last

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

last

public static <E> E last(java.util.List<E> list)

last

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

last
```
public T last()
```

last

public java.util.List<T> last(int n)

last

public static <E> E last(java.util.List<E> list,
                         java.util.function.Predicate<E> pred)

last

public T last(java.util.function.Predicate<T> pred)

lastOrNull

public static <E> E lastOrNull(java.util.List<E> list)

lastOrNull
```
public T lastOrNull()
```

lastOrNull

public static <E> E lastOrNull(java.util.List<E> list,
                               java.util.function.Predicate<E> pred)

lastOrNull

public T lastOrNull(java.util.function.Predicate<T> pred)

rest

public static <E> java.util.List<E> rest(java.util.List<E> list)

rest

public static <E> java.util.List<E> rest(java.util.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 java.util.List<T> rest()
```

rest

public java.util.List<T> rest(int n)

tail

public static <E> java.util.List<E> tail(java.util.List<E> list)

tail

public static <E> java.util.List<E> tail(java.util.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 java.util.List<T> tail()
```

tail

public java.util.List<T> tail(int n)

drop

public static <E> java.util.List<E> drop(java.util.List<E> list)

drop

public static <E> java.util.List<E> drop(java.util.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> java.util.List<E> compact(java.util.List<E> list)

compact

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

compact

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

compact

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

compact
```
public java.util.List<T> compact()
```

compact

public java.util.List<T> compact(T falsyValue)

flatten

public static <E> java.util.List<E> flatten(java.util.List<?> list)

flatten

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

flatten
```
public java.util.List<T> flatten()
```

flatten

public java.util.List<T> flatten(boolean shallow)

without

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

without

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

uniq

public static <E> java.util.List<E> uniq(java.util.List<E> list)

uniq

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

uniq

public static <K,E> java.util.Collection<E> uniq(java.lang.Iterable<E> iterable,
                                                       java.util.function.Function<E,K> func)

uniq

public static <K,E> E[] uniq(E[] array,
                                   java.util.function.Function<E,K> func)

distinct

public static <E> java.util.List<E> distinct(java.util.List<E> list)

distinct

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

distinctBy

public static <K,E> java.util.Collection<E> distinctBy(java.lang.Iterable<E> iterable,
                                                             java.util.function.Function<E,K> func)

distinctBy

public static <K,E> E[] distinctBy(E[] array,
                                         java.util.function.Function<E,K> func)

union

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

unionWith

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

union

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

intersection

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

intersection

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

intersectionWith

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

intersection

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

difference

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

difference

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

differenceWith

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

difference

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

zip

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

unzip

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

object

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

findIndex

public static <E> int findIndex(java.util.List<E> list,
                                java.util.function.Predicate<E> pred)

findIndex

public static <E> int findIndex(E[] array,
                                java.util.function.Predicate<E> pred)

findLastIndex

public static <E> int findLastIndex(java.util.List<E> list,
                                    java.util.function.Predicate<E> pred)

findLastIndex

public static <E> int findLastIndex(E[] array,
                                    java.util.function.Predicate<E> pred)

binarySearch

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

binarySearch

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

sortedIndex

public static <E extends java.lang.Comparable<E>> int sortedIndex(java.util.List<E> list,
                                                                  E value)

sortedIndex

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

sortedIndex

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

sortedIndex

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

indexOf

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

indexOf

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

lastIndexOf

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

lastIndexOf

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

range

public static java.util.List<java.lang.Integer> range(int stop)

range

public static java.util.List<java.lang.Integer> range(int start,
                                                      int stop)

range

public static java.util.List<java.lang.Integer> range(int start,
                                                      int stop,
                                                      int step)

range

public static java.util.List<java.lang.Character> range(char stop)

range

public static java.util.List<java.lang.Character> range(char start,
                                                        char stop)

range

public static java.util.List<java.lang.Character> range(char start,
                                                        char stop,
                                                        int step)

chunk

public static <T> java.util.List<java.util.List<T>> chunk(java.lang.Iterable<T> iterable,
                                                          int size)

chunk

public static <T> java.util.List<java.util.List<T>> chunk(java.lang.Iterable<T> iterable,
                                                          int size,
                                                          int step)

chunkFill

public static <T> java.util.List<java.util.List<T>> chunkFill(java.lang.Iterable<T> iterable,
                                                              int size,
                                                              T fillValue)

chunkFill

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

chunk

public java.util.List<java.util.List<T>> chunk(int size)

chunk

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

chunkFill

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

chunkFill

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

cycle

public static <T> java.util.List<T> cycle(java.lang.Iterable<T> iterable,
                                          int times)

cycle

public java.util.List<T> cycle(int times)

repeat

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

interpose

public static <T> java.util.List<T> interpose(java.lang.Iterable<T> iterable,
                                              T interElement)

interposeByList

public static <T> java.util.List<T> interposeByList(java.lang.Iterable<T> iterable,
                                                    java.lang.Iterable<T> interIter)

interpose

public java.util.List<T> interpose(T element)

interposeByList

public java.util.List<T> interposeByList(java.lang.Iterable<T> interIter)

bind

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

memoize

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

delay

public static <T> java.util.concurrent.ScheduledFuture<T> delay(java.util.function.Supplier<T> function,
                                                                int delayMilliseconds)

defer

public static <T> java.util.concurrent.ScheduledFuture<T> defer(java.util.function.Supplier<T> function)

defer

public static java.util.concurrent.ScheduledFuture<java.lang.Void> defer(java.lang.Runnable runnable)

throttle

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

debounce

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

wrap

public static <T> java.util.function.Function<java.lang.Void,T> wrap(java.util.function.Function<T,T> function,
                                                                           java.util.function.Function<java.util.function.Function<T,T>,T> wrapper)

negate

public static <E> java.util.function.Predicate<E> negate(java.util.function.Predicate<E> pred)

compose

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

after

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

before

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

once

public static <T> java.util.function.Supplier<T> once(java.util.function.Supplier<T> function)

keys

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

values

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

mapObject

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

pairs

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

invert

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

functions

public static java.util.List<java.lang.String> functions(java.lang.Object object)

methods

public static java.util.List<java.lang.String> methods(java.lang.Object object)

extend

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

findKey

public static <E> E findKey(java.util.List<E> list,
                            java.util.function.Predicate<E> pred)

findKey

public static <E> E findKey(E[] array,
                            java.util.function.Predicate<E> pred)

findLastKey

public static <E> E findLastKey(java.util.List<E> list,
                                java.util.function.Predicate<E> pred)

findLastKey

public static <E> E findLastKey(E[] array,
                                java.util.function.Predicate<E> pred)

pick

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

pick

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

omit

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

omit

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

defaults

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

clone

public static java.lang.Object clone(java.lang.Object obj)

clone

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

tap

public static <T> void tap(java.lang.Iterable<T> iterable,
                           java.util.function.Consumer<? super T> func)

isMatch

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

isEqual

public static boolean isEqual(java.lang.Object object,
                              java.lang.Object other)

isEmpty

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

isEmpty

public static <T> boolean isEmpty(java.lang.Iterable<T> iterable)

isEmpty
```
public boolean isEmpty()
```

isNotEmpty

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

isNotEmpty

public static <T> boolean isNotEmpty(java.lang.Iterable<T> iterable)

isNotEmpty
```
public boolean isNotEmpty()
```

isArray

public static boolean isArray(java.lang.Object object)

isObject

public static boolean isObject(java.lang.Object object)

isFunction

public static boolean isFunction(java.lang.Object object)

isString

public static boolean isString(java.lang.Object object)

isNumber

public static boolean isNumber(java.lang.Object object)

isDate

public static boolean isDate(java.lang.Object object)

isRegExp

public static boolean isRegExp(java.lang.Object object)

isError

public static boolean isError(java.lang.Object object)

isBoolean

public static boolean isBoolean(java.lang.Object object)

isNull

public static boolean isNull(java.lang.Object object)

has

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

identity

public static <E> E identity(E value)

constant

public static <E> java.util.function.Supplier<E> constant(E value)

property

public static <K,V> java.util.function.Function<java.util.Map<K,V>,V> property(K key)

propertyOf

public static <K,V> java.util.function.Function<K,V> propertyOf(java.util.Map<K,V> object)

matcher

public static <K,V> java.util.function.Predicate<java.util.Map<K,V>> matcher(java.util.Map<K,V> object)

times

public static void times(int count,
                         java.lang.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 java.lang.String escape(java.lang.String value)

unescape

public static java.lang.String unescape(java.lang.String value)

result

public static <E> java.lang.Object result(java.lang.Iterable<E> iterable,
                                          java.util.function.Predicate<E> pred)

uniqueId

public static java.lang.String uniqueId(java.lang.String prefix)

uniquePassword

public static java.lang.String uniquePassword()

template

public static <K,V> Template<java.util.Map<K,V>> template(java.lang.String template)

format

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

iterate

public static <T> java.lang.Iterable<T> iterate(T seed,
                                                java.util.function.UnaryOperator<T> unaryOperator)

chain

public static <T> Underscore.Chain<T> chain(java.util.List<T> list)

chain

public static Underscore.Chain<java.util.Map<java.lang.String,java.lang.Object>> chain(java.util.Map<java.lang.String,java.lang.Object> map)

chain

public static <T> Underscore.Chain<T> chain(java.lang.Iterable<T> iterable)

chain

public static <T> Underscore.Chain<T> chain(java.lang.Iterable<T> iterable,
                                            int size)

chain

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

chain

public static Underscore.Chain<java.lang.Integer> chain(int[] array)

chain
```
public Underscore.Chain<T> chain()
```

of

public static <T> Underscore.Chain<T> of(java.util.List<T> list)

of

public static <T> Underscore.Chain<T> of(java.lang.Iterable<T> iterable)

of

public static <T> Underscore.Chain<T> of(java.lang.Iterable<T> iterable,
                                         int size)

of

public static <T> Underscore.Chain<T> of(T... array)

of

public static Underscore.Chain<java.lang.Integer> of(int[] array)

of
```
public Underscore.Chain<T> of()
```

mixin

public static void mixin(java.lang.String funcName,
                         java.util.function.UnaryOperator<java.lang.String> func)

call

public Optional<java.lang.String> call(java.lang.String funcName)

sort

public static <T extends java.lang.Comparable<T>> java.util.List<T> sort(java.lang.Iterable<T> iterable)

sort

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

sort

public java.util.List<java.lang.Comparable> sort()

join

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

join

public static <T> java.lang.String join(java.lang.Iterable<T> iterable)

join

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

join

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

join

public java.lang.String join(java.lang.String separator)

join
```
public java.lang.String join()
```

push

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

push

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

pop

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

pop

public Tuple<T,java.util.List<T>> pop()

unshift

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

unshift

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

shift

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

shift

public Tuple<T,java.util.List<T>> shift()

concat

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

concat

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

concatWith

public java.util.List<T> concatWith(java.lang.Iterable<T>... other)

slice

public static <T> java.util.List<T> slice(java.lang.Iterable<T> iterable,
                                          int start)

slice

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

slice

public java.util.List<T> slice(int start)

slice

public static <T> java.util.List<T> slice(java.lang.Iterable<T> iterable,
                                          int start,
                                          int end)

slice

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

slice

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

splitAt

public static <T> java.util.List<java.util.List<T>> splitAt(java.lang.Iterable<T> iterable,
                                                            int position)

splitAt

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

splitAt

public java.util.List<java.util.List<T>> splitAt(int position)

takeSkipping

public static <T> java.util.List<T> takeSkipping(java.lang.Iterable<T> iterable,
                                                 int stepSize)

takeSkipping

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

takeSkipping

public java.util.List<T> takeSkipping(int stepSize)

reverse

public static <T> java.util.List<T> reverse(java.lang.Iterable<T> iterable)

reverse

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

reverse

public static java.util.List<java.lang.Integer> reverse(int[] array)

reverse
```
public java.util.List<T> reverse()
```

getIterable

public java.lang.Iterable<T> getIterable()

value
```
public java.lang.Iterable<T> value()
```

getString

public Optional<java.lang.String> getString()

setTimeout

public static <T> java.util.concurrent.ScheduledFuture<T> setTimeout(java.util.function.Supplier<T> function,
                                                                     int delayMilliseconds)

clearTimeout

public static void clearTimeout(java.util.concurrent.ScheduledFuture<?> scheduledFuture)

setInterval

public static <T> java.util.concurrent.ScheduledFuture setInterval(java.util.function.Supplier<T> function,
                                                                   int delayMilliseconds)

clearInterval

public static void clearInterval(java.util.concurrent.ScheduledFuture scheduledFuture)

copyOf

public static <T> java.util.List<T> copyOf(java.lang.Iterable<T> iterable)

copyOf
```
public java.util.List<T> copyOf()
```

copyOfRange

public static <T> java.util.List<T> copyOfRange(java.lang.Iterable<T> iterable,
                                                int start,
                                                int end)

copyOfRange

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

elementAt

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

elementAt
```
public T elementAt(int index)
```

get

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

get
```
public T get(int index)
```

set

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

set

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

elementAtOrElse

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

elementAtOrElse

public T elementAtOrElse(int index,
                         T defaultValue)

elementAtOrNull

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

elementAtOrNull

public T elementAtOrNull(int index)

lastIndex

public static <T> int lastIndex(java.lang.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> java.util.List<T> checkNotNullElements(java.util.List<T> references)

checkNotNull

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

nonNull

public static boolean nonNull(java.lang.Object obj)

defaultTo

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

and

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

or

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

minimumDays

public static int minimumDays(int rows,
                              int columns,
                              java.util.List<java.util.List<java.lang.Integer>> grid)

topNCompetitors

public static java.util.List<java.lang.String> topNCompetitors(int numCompetitors,
                                                               int topNCompetitors,
                                                               java.util.List<java.lang.String> competitors,
                                                               int numReviews,
                                                               java.util.List<java.lang.String> reviews)

main

public static void main(java.lang.String... args)

Constructor	Description
`Underscore(java.lang.Iterable<T> iterable)`
`Underscore(java.lang.String string)`

Class Underscore<T>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Underscore

Underscore

Method Detail

templateSettings

iteratee

each

eachIndexed

each

eachRight

eachRight

forEach

forEachIndexed

forEach

forEachIndexed

forEachRight

forEachRight

map

mapMulti

map

map

map

mapIndexed

replace

replace

replaceIndexed

replaceIndexed

mapIndexed

collect

collect

reduce

reduce

reduce

reduce

foldl

inject

reduceRight

reduceRight

reduceRight

reduceRight

foldr

find

detect

findLast

filter

filter

filter

filterIndexed

filter

select

select

reject

reject

rejectIndexed

reject

filterFalse

filterFalse

filterFalse

every

every

all

all

some

some

any

any

count

count

contains

contains

containsWith

containsWith

contains

containsAtLeast

containsAtMost