Constructor Detail

• U.Chain

  U.Chain(T item)

• U.Chain

  U.Chain(List<T> list)

• U.Chain

  U.Chain(Map<String, Object> map)

Method Detail

• first

   U.Chain<T> first()

• first

   U.Chain<T> first(int n)

• firstOrNull

   U.Chain<T> firstOrNull()

• firstOrNull

   U.Chain<T> firstOrNull(Predicate<T> pred)

• initial

   U.Chain<T> initial()

• initial

   U.Chain<T> initial(int n)

• last

   U.Chain<T> last()

• last

   U.Chain<T> last(int n)

• lastOrNull

   U.Chain<T> lastOrNull()

• lastOrNull

   U.Chain<T> lastOrNull(Predicate<T> pred)

• rest

   U.Chain<T> rest()

• rest

   U.Chain<T> rest(int n)

• compact

   U.Chain<T> compact()

• compact

   U.Chain<T> compact(T falsyValue)

• flatten

   U.Chain flatten()

• map

   <F> U.Chain<F> map(Function<in T, F> func)

• mapMulti

   <F> U.Chain<F> mapMulti(BiConsumer<in T, in Consumer<F>> mapper)

• mapIndexed

   <F> U.Chain<F> mapIndexed(BiFunction<Integer, in T, F> func)

• filter

   U.Chain<T> filter(Predicate<T> pred)

• filterIndexed

   U.Chain<T> filterIndexed(Underscore.PredicateIndexed<T> pred)

• rejectIndexed

   U.Chain<T> rejectIndexed(Underscore.PredicateIndexed<T> pred)

• reject

   U.Chain<T> reject(Predicate<T> pred)

• filterFalse

   U.Chain<T> filterFalse(Predicate<T> pred)

• reduce

   <F> U.Chain<F> reduce(BiFunction<F, T, F> func, F zeroElem)

• reduce

   U.Chain<Optional<T>> reduce(BinaryOperator<T> func)

• reduceRight

   <F> U.Chain<F> reduceRight(BiFunction<F, T, F> func, F zeroElem)

• reduceRight

   U.Chain<Optional<T>> reduceRight(BinaryOperator<T> func)

• find

   U.Chain<Optional<T>> find(Predicate<T> pred)

• findLast

   U.Chain<Optional<T>> findLast(Predicate<T> pred)

• max

   U.Chain<Comparable> max()

• max

   <F extends Comparable<in F>> U.Chain<T> max(Function<T, F> func)

• min

   U.Chain<Comparable> min()

• min

   <F extends Comparable<in F>> U.Chain<T> min(Function<T, F> func)

• sort

   U.Chain<Comparable> sort()

• sortWith

   <F extends Comparable<in F>> U.Chain<F> sortWith(Comparator<F> comparator)

• sortBy

   <F extends Comparable<in F>> U.Chain<T> sortBy(Function<T, F> func)

• sortBy

   <K> U.Chain<Map<K, Comparable>> sortBy(K key)

• groupBy

   <F> U.Chain<Map<F, List<T>>> groupBy(Function<T, F> func)

• associateBy

   <F> U.Chain<Map<F, T>> associateBy(Function<T, F> func)

• groupBy

   <F> U.Chain<Map<F, Optional<T>>> groupBy(Function<T, F> func, BinaryOperator<T> binaryOperator)

• indexBy

   U.Chain<Map<Object, List<T>>> indexBy(String property)

• countBy

   <F> U.Chain<Map<F, Integer>> countBy(Function<T, F> func)

• countBy

   U.Chain<Map<T, Integer>> countBy()

• shuffle

   U.Chain<T> shuffle()

• sample

   U.Chain<T> sample()

• sample

   U.Chain<T> sample(int howMany)

• tap

   U.Chain<T> tap(Consumer<T> func)

• forEach

   U.Chain<T> forEach(Consumer<T> func)

• forEachRight

   U.Chain<T> forEachRight(Consumer<T> func)

• every

   U.Chain<Boolean> every(Predicate<T> pred)

• some

   U.Chain<Boolean> some(Predicate<T> pred)

• count

   U.Chain<Integer> count(Predicate<T> pred)

• contains

   U.Chain<Boolean> contains(T elem)

• containsWith

   U.Chain<Boolean> containsWith(T elem)

• invoke

   U.Chain<T> invoke(String methodName, List<Object> args)

• invoke

   U.Chain<T> invoke(String methodName)

• pluck

   U.Chain<Object> pluck(String propertyName)

• where

   <E> U.Chain<T> where(List<Map.Entry<String, E>> properties)

• findWhere

   <E> U.Chain<Optional<T>> findWhere(List<Map.Entry<String, E>> properties)

• uniq

   U.Chain<T> uniq()

• uniq

   <F> U.Chain<T> uniq(Function<T, F> func)

• distinct

   U.Chain<T> distinct()

• distinctBy

   <F> U.Chain<F> distinctBy(Function<T, F> func)

• union

   U.Chain<T> union(Array<List<T>> lists)

• intersection

   U.Chain<T> intersection(Array<List<T>> lists)

• difference

   U.Chain<T> difference(Array<List<T>> lists)

• range

   U.Chain<Integer> range(int stop)

• range

   U.Chain<Integer> range(int start, int stop)

• range

   U.Chain<Integer> range(int start, int stop, int step)

• chunk

   U.Chain<List<T>> chunk(int size)

• chunk

   U.Chain<List<T>> chunk(int size, int step)

• chunkFill

   U.Chain<List<T>> chunkFill(int size, T fillValue)

• chunkFill

   U.Chain<List<T>> chunkFill(int size, int step, T fillValue)

• cycle

   U.Chain<T> cycle(int times)

• interpose

   U.Chain<T> interpose(T element)

• interposeByList

   U.Chain<T> interposeByList(Iterable<T> interIter)

• concat

   U.Chain<T> concat(Array<List<T>> lists)

• slice

   U.Chain<T> slice(int start)

• slice

   U.Chain<T> slice(int start, int end)

• set

   U.Chain<Map<String, Object>> set(String path, Object value)

• set

   U.Chain<Map<String, Object>> set(List<String> paths, Object value)

• reverse

   U.Chain<T> reverse()

• join

   U.Chain<String> join()

• join

   U.Chain<String> join(String separator)

• skip

   U.Chain<T> skip(int numberToSkip)

• limit

   U.Chain<T> limit(int size)

• toMap

   <K, V> U.Chain<Map<K, V>> toMap()

• drop

   U.Chain<T> drop()

• drop

   U.Chain<T> drop(Integer n)

• dropRight

   U.Chain<T> dropRight()

• dropRight

   U.Chain<T> dropRight(Integer n)

• dropWhile

   U.Chain<T> dropWhile(Predicate<T> pred)

• dropRightWhile

   U.Chain<T> dropRightWhile(Predicate<T> pred)

• fill

   U.Chain<Object> fill(Object value)

• fill

   U.Chain<Object> fill(Object value, Integer start, Integer end)

• flattenDeep

   U.Chain<Object> flattenDeep()

• pull

   U.Chain<Object> pull(Array<Object> values)

• pullAt

   U.Chain<Object> pullAt(Array<Integer> indexes)

• remove

   U.Chain<T> remove(Predicate<T> pred)

• take

   U.Chain<T> take()

• takeRight

   U.Chain<T> takeRight()

• take

   U.Chain<T> take(Integer n)

• takeRight

   U.Chain<T> takeRight(Integer n)

• takeWhile

   U.Chain<T> takeWhile(Predicate<T> pred)

• takeRightWhile

   U.Chain<T> takeRightWhile(Predicate<T> pred)

• xor

   U.Chain<T> xor(List<T> list)

• at

   U.Chain<T> at(Array<Integer> indexes)

• sum

   <F extends Number> U.Chain<F> sum()

• sum

   <F extends Number> U.Chain<F> sum(Function<T, F> func)

• mean

   U.Chain<Double> mean()

• median

   U.Chain<Double> median()

• camelCase

   U.Chain<String> camelCase()

• lowerFirst

   U.Chain<String> lowerFirst()

• upperFirst

   U.Chain<String> upperFirst()

• capitalize

   U.Chain<String> capitalize()

• deburr

   U.Chain<String> deburr()

• endsWith

   U.Chain<Boolean> endsWith(String target)

• endsWith

   U.Chain<Boolean> endsWith(String target, Integer position)

• kebabCase

   U.Chain<String> kebabCase()

• repeat

   U.Chain<String> repeat(int length)

• pad

   U.Chain<String> pad(int length)

• pad

   U.Chain<String> pad(int length, String chars)

• padStart

   U.Chain<String> padStart(int length)

• padStart

   U.Chain<String> padStart(int length, String chars)

• padEnd

   U.Chain<String> padEnd(int length)

• padEnd

   U.Chain<String> padEnd(int length, String chars)

• snakeCase

   U.Chain<String> snakeCase()

• startCase

   U.Chain<String> startCase()

• startsWith

   U.Chain<Boolean> startsWith(String target)

• startsWith

   U.Chain<Boolean> startsWith(String target, Integer position)

• trim

   U.Chain<String> trim()

• trim

   U.Chain<String> trim(String chars)

• trimStart

   U.Chain<String> trimStart()

• trimStart

   U.Chain<String> trimStart(String chars)

• trimEnd

   U.Chain<String> trimEnd()

• trunc

   U.Chain<String> trunc()

• trunc

   U.Chain<String> trunc(int length)

• trimEnd

   U.Chain<String> trimEnd(String chars)

• uncapitalize

   U.Chain<String> uncapitalize()

• words

   U.Chain<String> words()

• toJson

   U.Chain<String> toJson()

• fromJson

   U.Chain<Object> fromJson()

• toXml

   U.Chain<String> toXml()

• fromXml

   U.Chain<Object> fromXml()

• fetch

   U.Chain<String> fetch()

• fetch

   U.Chain<String> fetch(String method, String body)

• createPermutationWithRepetition

   U.Chain<List<T>> createPermutationWithRepetition(int permutationLength)

• xmlToJson

   U.Chain<String> xmlToJson()

• jsonToXml

   U.Chain<String> jsonToXml()