Package com.github.underscore

Class Underscore<T>

java.lang.Object
com.github.underscore.Underscore<T>
Direct Known Subclasses:
U
public class Underscore<T> extends Object
Underscore-java11 is a java 11 port of Underscore.js.
Author:
Valentyn Kolesnikov

  • Field Details

  • Constructor Details

    • Underscore

      public Underscore(Iterable<T> iterable)

    • Underscore

      public Underscore(String string)

  • Method Details

    • setTemplateKey

      private static void setTemplateKey(Map<String,String> templateSettings, String key)

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

    • mapMulti

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

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

    • doInvoke

      private static <E> void doInvoke(List<Object> args, List<E> result, Method method, E arg)

    • 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

      private static <E> void flatten(List<?> fromTreeList, List<E> toFlatList, int shallowLevel)

    • 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(UnaryOperator<T> function, Function<UnaryOperator<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> Underscore.Chain<T> chain(List<T> list)

    • chain

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

    • chain

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

    • chain

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

    • chain

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

    • chain

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

    • chain

      public Underscore.Chain<T> chain()

    • of

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

    • of

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

    • of

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

    • of

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

    • of

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

    • of

      public Underscore.Chain<T> of()

    • mixin

      public static void mixin(String funcName, UnaryOperator<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)

    • minimumDays

      public static int minimumDays(int rows, int columns, List<List<Integer>> grid)

    • getInteger

      private static int getInteger(int rows, int columns, List<List<Integer>> grid, Queue<int[]> queue, int cnt)

    • topNCompetitors

      public static List<String> topNCompetitors(int numCompetitors, int topNCompetitors, List<String> competitors, int numReviews, List<String> reviews)

    • getEntries

      private static List<Map.Entry<String,Integer>> getEntries(List<String> reviews, Set<String> competitorsSet, Map<String,Integer> topCompetitorsMap)

    • getEntries

      private static List<Map.Entry<String,Integer>> getEntries(Map<String,Integer> topCompetitorsMap)

    • main

      public static void main(String... args)