Package com.landawn.abacus.util

Class Fn

java.lang.Object

com.landawn.abacus.util.Fn

public final class Fn
extends Object

Factory utility class for functional interfaces.
Note: Don't save and reuse any Function/Predicat/Consumer/... created by calling the methods in this class. The method should be called every time.

 

 Map<String, Integer> map = N.asMap("a", 1, "b", 2, "c", 3);
 // Instead of
 Stream.of(map).filter(e -> e.getKey().equals("a") || e.getKey().equals("b")).toMap(e -> e.getKey(), e -> e.getValue());
 // Using Fn
 Stream.of(map).filter(Fn.testByKey(k -> k.equals("a") || k.equals("b"))).collect(Collectors.toMap());

 
 

Author:

haiyang li

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static final class	Fn.BiConsumers	The Class BiConsumers.
static final class	Fn.BiFunctions	The Class BiFunctions.
static final class	Fn.BinaryOperators	The Class BinaryOperators.
static final class	Fn.BiPredicates	The Class BiPredicates.
static final class	Fn.Consumers	The Class Consumers.
static final class	Fn.Disposables	The Class Disposables.
static final class	Fn.Entries	The Class Entries.
static class	Fn.Factory	The Class Factory.
static final class	Fn.FB	Utility class for BytePredicate/Function/Consumer.
static final class	Fn.FC	Utility class for CharPredicate/Function/Consumer.
static final class	Fn.FD	Utility class for DoublePredicate/Function/Consumer.
static final class	Fn.FF	Utility class for FloatPredicate/Function/Consumer.
static final class	Fn.FI	Utility class for IntPredicate/Function/Consumer.
static final class	Fn.FL	Utility class for LongPredicate/Function/Consumer.
static final class	Fn.Fnn	Utility class for exceptional Predicate/Function/Consumer.
static final class	Fn.FS	Utility class for ShortPredicate/Function/Consumer.
static final class	Fn.Functions	The Class Functions.
static final class	Fn.IntFunctions	The Class
static final class	Fn.LongSuppliers
static final class	Fn.Pairs	The Class Pairs.
static final class	Fn.Predicates	The Class Predicates.
static final class	Fn.Suppliers
static final class	Fn.TriConsumers	The Class TriConsumers.
static final class	Fn.TriFunctions	The Class TriFunctions.
static final class	Fn.Triples	The Class Triples.
static final class	Fn.TriPredicates	The Class TriPredicates.
static final class	Fn.UnaryOperators	The Class UnaryOperators.

Field Summary

Fields

Modifier and Type	Field	Description
static final ToBooleanFunction<u.OptionalBoolean>	GET_AS_BOOLEAN
static final ToByteFunction<u.OptionalByte>	GET_AS_BYTE
static final ToCharFunction<u.OptionalChar>	GET_AS_CHAR
static final ToDoubleFunction<u.OptionalDouble>	GET_AS_DOUBLE
static final ToDoubleFunction<OptionalDouble>	GET_AS_DOUBLE_JDK
static final ToFloatFunction<u.OptionalFloat>	GET_AS_FLOAT
static final ToIntFunction<u.OptionalInt>	GET_AS_INT
static final ToIntFunction<OptionalInt>	GET_AS_INT_JDK
static final ToLongFunction<u.OptionalLong>	GET_AS_LONG
static final ToLongFunction<OptionalLong>	GET_AS_LONG_JDK
static final ToShortFunction<u.OptionalShort>	GET_AS_SHORT
static final Predicate<u.OptionalBoolean>	IS_PRESENT_BOOLEAN
static final Predicate<u.OptionalByte>	IS_PRESENT_BYTE
static final Predicate<u.OptionalChar>	IS_PRESENT_CHAR
static final Predicate<u.OptionalDouble>	IS_PRESENT_DOUBLE
static final Predicate<OptionalDouble>	IS_PRESENT_DOUBLE_JDK
static final Predicate<u.OptionalFloat>	IS_PRESENT_FLOAT
static final Predicate<u.OptionalInt>	IS_PRESENT_INT
static final Predicate<OptionalInt>	IS_PRESENT_INT_JDK
static final Predicate<u.OptionalLong>	IS_PRESENT_LONG
static final Predicate<OptionalLong>	IS_PRESENT_LONG_JDK
static final Predicate<u.OptionalShort>	IS_PRESENT_SHORT

Method Summary

Modifier and Type	Method	Description
static <K, V> Consumer<Map.Entry<K,V>>	acceptByKey(Consumer<? super K> consumer)	Accept by key.
static <K, V> Consumer<Map.Entry<K,V>>	acceptByValue(Consumer<? super V> consumer)	Accept by value.
static <T> Consumer<T>	acceptIf(Predicate<? super T> predicate, Consumer<? super T> consumer)
static <T> Consumer<T>	acceptIfOrElse(Predicate<? super T> predicate, Consumer<? super T> consumerForTrue, Consumer<? super T> consumerForFalse)
static <K, V> Consumer<Map.Entry<K,V>>	acceptKeyVal(BiConsumer<? super K,? super V> consumer)	Accept key val.
static <T> Predicate<T>	alwaysFalse()
static <T> Predicate<T>	alwaysTrue()
static <T> Predicate<T>	and(Collection<? extends Predicate<? super T>> c)
static <T, U> BiPredicate<T,U>	and(BiPredicate<? super T,? super U> first, BiPredicate<? super T,? super U> second)
static <T, U> BiPredicate<T,U>	and(BiPredicate<? super T,? super U> first, BiPredicate<? super T,? super U> second, BiPredicate<? super T,? super U> third)
static BooleanSupplier	and(BooleanSupplier first, BooleanSupplier second)
static BooleanSupplier	and(BooleanSupplier first, BooleanSupplier second, BooleanSupplier third)
static <T> Predicate<T>	and(Predicate<? super T> first, Predicate<? super T> second)
static <T> Predicate<T>	and(Predicate<? super T> first, Predicate<? super T> second, Predicate<? super T> third)
static <T, U> BiPredicate<T,U>	and(List<? extends BiPredicate<? super T,? super U>> c)
static <K, V, R> Function<Map.Entry<K,V>,R>	applyByKey(Function<? super K,? extends R> func)	Apply by key.
static <K, V, R> Function<Map.Entry<K,V>,R>	applyByValue(Function<? super V,? extends R> func)	Apply by value.
static <A, B, R> Function<A,R>	applyIfNotNullOrDefault(Function<A,B> mapperA, Function<B,? extends R> mapperB, R defaultValue)	Apply if not null or default.
static <A, B, C, R> Function<A,R>	applyIfNotNullOrDefault(Function<A,B> mapperA, Function<B,C> mapperB, Function<C,? extends R> mapperC, R defaultValue)	Apply if not null or default.
static <A, B, C, D, R> Function<A,R>	applyIfNotNullOrDefault(Function<A,B> mapperA, Function<B,C> mapperB, Function<C,D> mapperC, Function<D,? extends R> mapperD, R defaultValue)	Apply if not null or default.
static <A, B, R> Function<A,R>	applyIfNotNullOrElseGet(Function<A,B> mapperA, Function<B,? extends R> mapperB, Supplier<R> supplier)	Apply if not null or get.
static <A, B, C, R> Function<A,R>	applyIfNotNullOrElseGet(Function<A,B> mapperA, Function<B,C> mapperB, Function<C,? extends R> mapperC, Supplier<R> supplier)	Apply if not null or get.
static <A, B, C, D, R> Function<A,R>	applyIfNotNullOrElseGet(Function<A,B> mapperA, Function<B,C> mapperB, Function<C,D> mapperC, Function<D,? extends R> mapperD, Supplier<R> supplier)	Apply if not null or get.
static <T, R> Function<T,R>	applyIfOrElseDefault(Predicate<? super T> predicate, Function<? super T,? extends R> func, R defaultValue)
static <T, R> Function<T,R>	applyIfOrElseGet(Predicate<? super T> predicate, Function<? super T,? extends R> func, Supplier<? extends R> supplier)
static <K, V, R> Function<Map.Entry<K,V>,R>	applyKeyVal(BiFunction<? super K,? super V,? extends R> func)	Apply key val.
static <T> Predicate<T>	atMost(int count)
static <T extends Comparable<? super T>> Predicate<T>	between(T minValue, T maxValue)	Deprecated. replaced by gtAndLt.
static <A, B, T> Consumer<T>	c(A a, B b, TriConsumer<A,B,T> triConsumer)
static <A, T, U> BiConsumer<T,U>	c(A a, TriConsumer<A,T,U> triConsumer)
static <A, T> Consumer<T>	c(A a, BiConsumer<A,T> biConsumer)
static <T, U> BiConsumer<T,U>	c(BiConsumer<T,U> biConsumer)
static <R> Callable<R>	c(Callable<R> callable)
static <T> Consumer<T>	c(Consumer<T> predicate)
static <A, B, C> TriConsumer<A,B,C>	c(TriConsumer<A,B,C> triConsumer)
static <A, B, C> TriFunction<A,B,C,Void>	c2f(TriConsumer<? super A,? super B,? super C> action)
static <A, B, C, R> TriFunction<A,B,C,R>	c2f(TriConsumer<? super A,? super B,? super C> action, R valueToReturn)
static <T, U> BiFunction<T,U,Void>	c2f(BiConsumer<? super T,? super U> action)
static <T, U, R> BiFunction<T,U,R>	c2f(BiConsumer<? super T,? super U> action, R valueToReturn)
static <T> Function<T,Void>	c2f(Consumer<? super T> action)
static <T, R> Function<T,R>	c2f(Consumer<? super T> action, R valueToReturn)
static <R> Runnable	c2r(Callable<R> callable)
static <T, U> Function<T,U>	cast(Class<U> clazz)
static <A, B, T> Consumer<T>	cc(A a, B b, Throwables.TriConsumer<A,B,T,? extends Exception> triConsumer)
static <A, T> Consumer<T>	cc(A a, Throwables.BiConsumer<A,T,? extends Exception> biConsumer)
static <A, T, U> BiConsumer<T,U>	cc(A a, Throwables.TriConsumer<A,T,U,? extends Exception> triConsumer)
static <T, U> BiConsumer<T,U>	cc(Throwables.BiConsumer<T,U,? extends Exception> biConsumer)
static <R> Callable<R>	cc(Throwables.Callable<R,? extends Exception> callable)
static <T> Consumer<T>	cc(Throwables.Consumer<T,? extends Exception> consumer)
static <A, B, C> TriConsumer<A,B,C>	cc(Throwables.TriConsumer<A,B,C,? extends Exception> triConsumer)
static <T extends AutoCloseable> Consumer<T>	close()
static Runnable	close(AutoCloseable closeable)
static Runnable	closeAll(AutoCloseable... a)
static Runnable	closeAll(Collection<? extends AutoCloseable> c)
static Runnable	closeAllQuietly(AutoCloseable... a)	Close all quietly.
static Runnable	closeAllQuietly(Collection<? extends AutoCloseable> c)	Close all quietly.
static <T extends AutoCloseable> Consumer<T>	closeQuietly()
static Runnable	closeQuietly(AutoCloseable closeable)
static <T extends Comparable<? super T>> BiFunction<T,T,Integer>	compare()
static <T> BiFunction<T,T,Integer>	compare(Comparator<? super T> cmp)
static <T extends Comparable<? super T>> Function<T,Integer>	compareTo(T target)
static <T> Function<T,Integer>	compareTo(T target, Comparator<? super T> cmp)
static Predicate<String>	contains(String str)
static Function<String,Number>	createNumber()	Creates the number.
static <T> Consumer<T>	doNothing()
static Runnable	emptyAction()
static Predicate<String>	endsWith(String suffix)
static <K, V> BiFunction<K,V,Map.Entry<K,V>>	entry()
static <K, V> Function<V,Map.Entry<K,V>>	entry(Function<? super V,K> keyMapper)	Deprecated. replaced by Fn#entryByKeyMapper(Function)
static <K, V> Function<V,Map.Entry<K,V>>	entry(K key)	Deprecated. replaced by Fn#entryWithKey(Object)
static <K, V> Function<V,Map.Entry<K,V>>	entryByKeyMapper(Function<? super V,K> keyMapper)
static <K, V> Function<K,Map.Entry<K,V>>	entryByValueMapper(Function<? super K,V> valueMapper)
static <K, V> Function<V,Map.Entry<K,V>>	entryWithKey(K key)
static <K, V> Function<K,Map.Entry<K,V>>	entryWithValue(V value)
static <T> Predicate<T>	eqOr(Object targetValue1, Object targetValue2)
static <T> Predicate<T>	eqOr(Object targetValue1, Object targetValue2, Object targetValue3)
static <T, U> BiPredicate<T,U>	equal()
static <T> Predicate<T>	equal(Object target)
static <A, B, T, R> Function<T,R>	f(A a, B b, TriFunction<A,B,T,R> triFunction)
static <A, T, U, R> BiFunction<T,U,R>	f(A a, TriFunction<A,T,U,R> triFunction)
static <A, T, R> Function<T,R>	f(A a, BiFunction<A,T,R> biFunction)
static <T, U, R> BiFunction<T,U,R>	f(BiFunction<T,U,R> biFunction)
static <T, R> Function<T,R>	f(Function<T,R> predicate)
static <A, B, C, R> TriFunction<A,B,C,R>	f(TriFunction<A,B,C,R> triFunction)
static <A, B, C> TriConsumer<A,B,C>	f2c(TriFunction<? super A,? super B,? super C,?> func)
static <T, U> BiConsumer<T,U>	f2c(BiFunction<? super T,? super U,?> func)
static <T> Consumer<T>	f2c(Function<? super T,?> func)	Returns a Consumer which calls the specified func.
static <A, B, T, R> Function<T,R>	ff(A a, B b, Throwables.TriFunction<A,B,T,R,? extends Exception> triFunction)
static <A, T, R> Function<T,R>	ff(A a, Throwables.BiFunction<A,T,R,? extends Exception> biFunction)
static <A, T, U, R> BiFunction<T,U,R>	ff(A a, Throwables.TriFunction<A,T,U,R,? extends Exception> triFunction)
static <T, U, R> BiFunction<T,U,R>	ff(Throwables.BiFunction<T,U,R,? extends Exception> biFunction)
static <T, U, R> BiFunction<T,U,R>	ff(Throwables.BiFunction<T,U,R,? extends Exception> biFunction, R defaultOnError)
static <T, R> Function<T,R>	ff(Throwables.Function<T,? extends R,? extends Exception> function)
static <T, R> Function<T,R>	ff(Throwables.Function<T,? extends R,? extends Exception> function, R defaultOnError)
static <A, B, C, R> TriFunction<A,B,C,R>	ff(Throwables.TriFunction<A,B,C,R,? extends Exception> triFunction)
static <A, B, C, R> TriFunction<A,B,C,R>	ff(Throwables.TriFunction<A,B,C,R,? extends Exception> triFunction, R defaultOnError)
static <T, U> BiPredicate<T,U>	filterThenLimit(BiPredicate<T,U> predicate, int limit)	Returns a stateful Predicate.
static <T> Predicate<T>	filterThenLimit(Predicate<T> predicate, int limit)	Returns a stateful Predicate.
static <K, V> Function<? super Map<K,? extends Collection<? extends V>>,List<Map<K,V>>>	flatToMap()	{a=[1, 2, 3], b=[4, 5, 6], c=[7, 8]} -> [{a=1, b=4, c=7}, {a=2, b=5, c=8}, {a=3, b=6}].
static <T, U> BiConsumer<T,U>	from(BiConsumer<T,U> consumer)
static <T, U, R> BiFunction<T,U,R>	from(BiFunction<T,U,? extends R> function)
static <T> BinaryOperator<T>	from(BinaryOperator<T> op)
static <T, U> BiPredicate<T,U>	from(BiPredicate<T,U> predicate)
static <T> Consumer<T>	from(Consumer<T> consumer)
static <T, R> Function<T,R>	from(Function<T,? extends R> function)
static <T> IntFunction<T>	from(IntFunction<? extends T> func)
static <T> Predicate<T>	from(Predicate<T> predicate)
static <T> Supplier<T>	from(Supplier<T> supplier)
static <T> UnaryOperator<T>	from(UnaryOperator<T> op)
static <T> Function<Future<T>,T>	futureGet()
static <T> Function<Future<T>,T>	futureGetOrDefaultOnError(T defaultValue)
static <T extends Comparable<? super T>> Predicate<T>	geAndLe(T minValue, T maxValue)	Checks if the value/element: minValue <= e <= maxValue.
static <T extends Comparable<? super T>> Predicate<T>	geAndLt(T minValue, T maxValue)	Checks if the value/element: minValue <= e < maxValue.
static <T> Function<u.Optional<? extends T>,T>	getIfPresentOrElseNull()
static <T> Function<Optional<? extends T>,T>	getIfPresentOrElseNullJdk()
static <T extends Comparable<? super T>> BiPredicate<T,T>	greaterEqual()
static <T extends Comparable<? super T>> Predicate<T>	greaterEqual(T target)
static <T extends Comparable<? super T>> BiPredicate<T,T>	greaterThan()
static <T extends Comparable<? super T>> Predicate<T>	greaterThan(T target)
static <T extends Comparable<? super T>> Predicate<T>	gtAndLe(T minValue, T maxValue)	Checks if the value/element: minValue < e <= maxValue.
static <T extends Comparable<? super T>> Predicate<T>	gtAndLt(T minValue, T maxValue)	Checks if the value/element: minValue < e < maxValue.
static <T> Function<T,T>	identity()
static <T> BinaryOperator<T>	ignoringMerger()
static <T> Predicate<T>	in(Collection<?> c)
static <T> Function<T,Indexed<T>>	indexed()	Returns a stateful Predicate.
static <T> Predicate<T>	indexed(IntObjPredicate<T> predicate)	Returns a stateful Predicate.
static <T> Predicate<T>	instanceOf(Class<?> clazz)
static <K, V> Function<Map.Entry<K,V>,Map.Entry<V,K>>	inverse()
static <T extends CharSequence> Predicate<T>	isBlank()	Checks if is null or empty or blank.
static <T> Predicate<T>	isBlank(Function<T,? extends CharSequence> valueExtractor)
static Predicate<File>	isDirectory()	Checks if is directory.
static <T extends CharSequence> Predicate<T>	isEmpty()	Checks if is null or empty.
static <T> Predicate<T>	isEmpty(Function<T,? extends CharSequence> valueExtractor)
static <T> Predicate<T[]>	isEmptyA()
static <T extends Collection> Predicate<T>	isEmptyC()
static <T extends Map> Predicate<T>	isEmptyM()
static Predicate<File>	isFile()	Checks if is file.
static <T> Predicate<T>	isNull()	Checks if is null.
static <T> Predicate<T>	isNull(Function<T,?> valueExtractor)	Checks if is null.
static <T> Predicate<u.Optional<? extends T>>	isPresent()
static <T> Predicate<Optional<? extends T>>	isPresentJdk()
static <R> Callable<R>	jc(Callable<R> callable)
static <R> Callable<R>	jc2c(Callable<R> callable)
static Runnable	jc2r(Callable<?> callable)
static Runnable	jr(Runnable runnable)
static Runnable	jr2r(Runnable runnable)
static <K, V> Function<Map.Entry<K,V>,K>	key()
static <K, T> Function<T,Keyed<K,T>>	keyed(Function<? super T,K> keyMapper)
static <T, K, V> Function<Map.Entry<Keyed<K,T>,V>,T>	kkv()
static <L, R> Function<Pair<L,R>,L>	left()
static <T> Function<T[],Integer>	len()
static <T extends CharSequence> Function<T,Integer>	length()
static <T extends Comparable<? super T>> BiPredicate<T,T>	lessEqual()
static <T extends Comparable<? super T>> Predicate<T>	lessEqual(T target)
static <T extends Comparable<? super T>> BiPredicate<T,T>	lessThan()
static <T extends Comparable<? super T>> Predicate<T>	lessThan(T target)
static <T, U> BiPredicate<T,U>	limitThenFilter(int limit, BiPredicate<T,U> predicate)	Returns a stateful Predicate.
static <T> Predicate<T>	limitThenFilter(int limit, Predicate<T> predicate)	Returns a stateful Predicate.
static <K, V, KK> Function<Map.Entry<K,V>,Map.Entry<KK,V>>	mapKey(Function<? super K,? extends KK> func)
static <K, V, VV> Function<Map.Entry<K,V>,Map.Entry<K,VV>>	mapValue(Function<? super V,? extends VV> func)
static Predicate<CharSequence>	matches(Pattern pattern)
static <T extends Comparable<? super T>> BinaryOperator<T>	max()
static <T> BinaryOperator<T>	max(Comparator<? super T> comparator)
static <T> BinaryOperator<T>	maxBy(Function<? super T,? extends Comparable> keyMapper)
static <K extends Comparable<? super K>, V> BinaryOperator<Map.Entry<K,V>>	maxByKey()
static <K, V extends Comparable<? super V>> BinaryOperator<Map.Entry<K,V>>	maxByValue()
static <T, R> Function<T,R>	memoize(Function<? super T,? extends R> func)
static <T> Supplier<T>	memoize(Supplier<T> supplier)	Returns a Supplier which returns a single instance created by calling the specified supplier.get().
static <T extends Comparable<? super T>> BinaryOperator<T>	min()
static <T> BinaryOperator<T>	min(Comparator<? super T> comparator)
static <T> BinaryOperator<T>	minBy(Function<? super T,? extends Comparable> keyMapper)
static <K extends Comparable<? super K>, V> BinaryOperator<Map.Entry<K,V>>	minByKey()
static <K, V extends Comparable<? super V>> BinaryOperator<Map.Entry<K,V>>	minByValue()
static <A, B, C> TriPredicate<A,B,C>	not(TriPredicate<A,B,C> triPredicate)
static <T, U> BiPredicate<T,U>	not(BiPredicate<T,U> biPredicate)
static <T> Predicate<T>	not(Predicate<T> predicate)
static <T extends CharSequence> Predicate<T>	notBlank()	Not null or empty or blank.
static <T> Predicate<T>	notBlank(Function<T,? extends CharSequence> valueExtractor)
static Predicate<String>	notContains(String str)
static <T extends CharSequence> Predicate<T>	notEmpty()	Not null or empty.
static <T> Predicate<T>	notEmpty(Function<T,? extends CharSequence> valueExtractor)
static <T> Predicate<T[]>	notEmptyA()
static <T extends Collection> Predicate<T>	notEmptyC()
static <T extends Map> Predicate<T>	notEmptyM()
static Predicate<String>	notEndsWith(String suffix)	Not ends with.
static <T, U> BiPredicate<T,U>	notEqual()
static <T> Predicate<T>	notEqual(Object target)
static <T> Predicate<T>	notIn(Collection<?> c)
static <T> Predicate<T>	notNull()
static <T> Predicate<T>	notNull(Function<T,?> valueExtractor)	Not null.
static Predicate<String>	notStartsWith(String prefix)	Not starts with.
static Function<String,String>	nullToEmpty()
static <T> Function<List<T>,List<T>>	nullToEmptyL()	Deprecated. replaced by nullToEmptyList
static <T> Function<List<T>,List<T>>	nullToEmptyList()
static <K, V> Function<Map<K,V>,Map<K,V>>	nullToEmptyM()	Deprecated. replaced by nullToEmptyMap
static <K, V> Function<Map<K,V>,Map<K,V>>	nullToEmptyMap()
static <T> Function<Set<T>,Set<T>>	nullToEmptyS()	Deprecated. replaced by nullToEmptySet
static <T> Function<Set<T>,Set<T>>	nullToEmptySet()
static <T extends Number> ToDoubleFunction<T>	numToDouble()	Num to double.
static <T extends Number> ToIntFunction<T>	numToInt()	Num to int.
static <T extends Number> ToLongFunction<T>	numToLong()	Num to long.
static <T> Predicate<T>	or(Collection<? extends Predicate<? super T>> c)
static <T, U> BiPredicate<T,U>	or(BiPredicate<? super T,? super U> first, BiPredicate<? super T,? super U> second)
static <T, U> BiPredicate<T,U>	or(BiPredicate<? super T,? super U> first, BiPredicate<? super T,? super U> second, BiPredicate<? super T,? super U> third)
static BooleanSupplier	or(BooleanSupplier first, BooleanSupplier second)
static BooleanSupplier	or(BooleanSupplier first, BooleanSupplier second, BooleanSupplier third)
static <T> Predicate<T>	or(Predicate<? super T> first, Predicate<? super T> second)
static <T> Predicate<T>	or(Predicate<? super T> first, Predicate<? super T> second, Predicate<? super T> third)
static <T, U> BiPredicate<T,U>	or(List<? extends BiPredicate<? super T,? super U>> c)
static <A, B, T> Predicate<T>	p(A a, B b, TriPredicate<A,B,T> triPredicate)
static <A, T, U> BiPredicate<T,U>	p(A a, TriPredicate<A,T,U> triPredicate)
static <A, T> Predicate<T>	p(A a, BiPredicate<A,T> biPredicate)
static <T, U> BiPredicate<T,U>	p(BiPredicate<T,U> biPredicate)
static <T> Predicate<T>	p(Predicate<T> predicate)
static <A, B, C> TriPredicate<A,B,C>	p(TriPredicate<A,B,C> triPredicate)
static <L, R> BiFunction<L,R,Pair<L,R>>	pair()
static Function<String,Byte>	parseByte()	Parses the byte.
static Function<String,Double>	parseDouble()	Parses the double.
static Function<String,Float>	parseFloat()	Parses the float.
static Function<String,Integer>	parseInt()	Parses the int.
static Function<String,Long>	parseLong()	Parses the long.
static Function<String,Short>	parseShort()	Parses the short.
static <A, B, T> Predicate<T>	pp(A a, B b, Throwables.TriPredicate<A,B,T,? extends Exception> triPredicate)
static <A, T> Predicate<T>	pp(A a, Throwables.BiPredicate<A,T,? extends Exception> biPredicate)
static <A, T, U> BiPredicate<T,U>	pp(A a, Throwables.TriPredicate<A,T,U,? extends Exception> triPredicate)
static <T, U> BiPredicate<T,U>	pp(Throwables.BiPredicate<T,U,? extends Exception> biPredicate)
static <T> Predicate<T>	pp(Throwables.Predicate<T,? extends Exception> predicate)
static <A, B, C> TriPredicate<A,B,C>	pp(Throwables.TriPredicate<A,B,C,? extends Exception> triPredicate)
static <T> Consumer<T>	println()
static <T, U> BiConsumer<T,U>	println(String separator)
static Runnable	r(Runnable runnable)
static Callable<Void>	r2c(Runnable runnable)
static <R> Callable<R>	r2c(Runnable runnable, R valueToReturn)
static <T> Consumer<T>	rateLimiter(double permitsPerSecond)	Returns a stateful Consumer.
static <T> Consumer<T>	rateLimiter(RateLimiter rateLimiter)	Returns a stateful Consumer.
static <T> BinaryOperator<T>	replacingMerger()
static <L, R> Function<Pair<L,R>,R>	right()
static Runnable	rr(Throwables.Runnable<? extends Exception> runnbale)
static <A, T> Consumer<T>	sc(Object mutex, A a, BiConsumer<A,T> biConsumer)	Synchronized Consumer.
static <T, U> BiConsumer<T,U>	sc(Object mutex, BiConsumer<T,U> biConsumer)	Synchronized BiConsumer.
static <T> Consumer<T>	sc(Object mutex, Consumer<T> consumer)	Synchronized Consumer.
static <T> BinaryOperator<T>	selectFirst()
static <T> BinaryOperator<T>	selectSecond()
static <A, T, R> Function<T,R>	sf(Object mutex, A a, BiFunction<A,T,R> biFunction)	Synchronized Function.
static <T, U, R> BiFunction<T,U,R>	sf(Object mutex, BiFunction<T,U,R> biFunction)	Synchronized BiFunction.
static <T, R> Function<T,R>	sf(Object mutex, Function<T,? extends R> function)	Synchronized Function.
static Runnable	shutDown(ExecutorService service)
static Runnable	shutDown(ExecutorService service, long terminationTimeout, TimeUnit timeUnit)
static <T extends Collection> Function<T,Integer>	size()
static <T extends Map> Function<T,Integer>	sizeM()
static <T> Consumer<T>	sleep(long millis)
static <T> Consumer<T>	sleepUninterruptibly(long millis)
static <A, B, T> Predicate<T>	sp(Object mutex, A a, B b, TriPredicate<A,B,T> triPredicate)	Synchronized Predicate.
static <A, T> Predicate<T>	sp(Object mutex, A a, BiPredicate<A,T> biPredicate)	Synchronized Predicate.
static <T, U> BiPredicate<T,U>	sp(Object mutex, BiPredicate<T,U> biPredicate)	Synchronized BiPredicate.
static <T> Predicate<T>	sp(Object mutex, Predicate<T> predicate)	Synchronized Predicate.
static Predicate<String>	startsWith(String prefix)
static Function<String,String>	strip()
static Function<String,String>	stripToEmpty()
static Function<String,String>	stripToNull()
static Predicate<Class>	subtypeOf(Class<?> clazz)
static <T> BiFunction<T,T,MergeResult>	switchOnNext()	Returns a stateful BiFunction.
static <K, V> Predicate<Map.Entry<K,V>>	testByKey(Predicate<? super K> predicate)	Test by key.
static <K, V> Predicate<Map.Entry<K,V>>	testByValue(Predicate<? super V> predicate)	Test by value.
static <K, V> Predicate<Map.Entry<K,V>>	testKeyVal(BiPredicate<? super K,? super V> predicate)	Test key val.
static <T> Consumer<T>	throwException(Supplier<? extends RuntimeException> excpetionSupplier)
static <T> BinaryOperator<T>	throwingMerger()
static <T> Consumer<T>	throwRuntimeException(String errorMessage)
static <T> Predicate<T>	timeLimit(long timeInMillis)	Returns a stateful Predicate.
static <T> Predicate<T>	timeLimit(Duration duration)	Returns a stateful Predicate.
static Function<String,String>	toCamelCase()	To camel case.
static <T> Function<T,String>	toJson()
static Function<String,String>	toLowerCase()	To lower case.
static Function<String,String>	toLowerCaseWithUnderscore()	To lower case with underscore.
static Function<Throwable,RuntimeException>	toRuntimeException()
static <T> Function<T,String>	toStr()
static Function<String,String>	toUpperCase()	To upper case.
static Function<String,String>	toUpperCaseWithUnderscore()	To upper case with underscore.
static <T> Function<T,String>	toXml()
static Function<String,String>	trim()
static Function<String,String>	trimToEmpty()
static Function<String,String>	trimToNull()
static <L, M, R> TriFunction<L,M,R,Triple<L,M,R>>	triple()
static <T> Function<T,Tuple.Tuple1<T>>	tuple1()
static <T, U> BiFunction<T,U,Tuple.Tuple2<T,U>>	tuple2()
static <A, B, C> TriFunction<A,B,C,Tuple.Tuple3<A,B,C>>	tuple3()
static <A, B, C, D> QuadFunction<A,B,C,D,Tuple.Tuple4<A,B,C,D>>	tuple4()
static <T> Function<Wrapper<T>,T>	unwrap()
static <K, T> Function<Keyed<K,T>,T>	val()
static <K, V> Function<Map.Entry<K,V>,V>	value()
static <T> Function<T,Wrapper<T>>	wrap()
static <T> Function<T,Wrapper<T>>	wrap(ToIntFunction<? super T> hashFunction, BiPredicate<? super T,? super T> equalsFunction)

Methods inherited from class java.lang.Object

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

Field Details

GET_AS_BOOLEAN

public static final ToBooleanFunction<u.OptionalBoolean> GET_AS_BOOLEAN

GET_AS_CHAR

public static final ToCharFunction<u.OptionalChar> GET_AS_CHAR

GET_AS_BYTE

public static final ToByteFunction<u.OptionalByte> GET_AS_BYTE

GET_AS_SHORT

public static final ToShortFunction<u.OptionalShort> GET_AS_SHORT

GET_AS_INT

public static final ToIntFunction<u.OptionalInt> GET_AS_INT

GET_AS_LONG

public static final ToLongFunction<u.OptionalLong> GET_AS_LONG

GET_AS_FLOAT

public static final ToFloatFunction<u.OptionalFloat> GET_AS_FLOAT

GET_AS_DOUBLE

public static final ToDoubleFunction<u.OptionalDouble> GET_AS_DOUBLE

GET_AS_INT_JDK

public static final ToIntFunction<OptionalInt> GET_AS_INT_JDK

GET_AS_LONG_JDK

public static final ToLongFunction<OptionalLong> GET_AS_LONG_JDK

GET_AS_DOUBLE_JDK

public static final ToDoubleFunction<OptionalDouble> GET_AS_DOUBLE_JDK

IS_PRESENT_BOOLEAN

public static final Predicate<u.OptionalBoolean> IS_PRESENT_BOOLEAN

IS_PRESENT_CHAR

public static final Predicate<u.OptionalChar> IS_PRESENT_CHAR

IS_PRESENT_BYTE

public static final Predicate<u.OptionalByte> IS_PRESENT_BYTE

IS_PRESENT_SHORT

public static final Predicate<u.OptionalShort> IS_PRESENT_SHORT

IS_PRESENT_INT

public static final Predicate<u.OptionalInt> IS_PRESENT_INT

IS_PRESENT_LONG

public static final Predicate<u.OptionalLong> IS_PRESENT_LONG

IS_PRESENT_FLOAT

public static final Predicate<u.OptionalFloat> IS_PRESENT_FLOAT

IS_PRESENT_DOUBLE

public static final Predicate<u.OptionalDouble> IS_PRESENT_DOUBLE

IS_PRESENT_INT_JDK

public static final Predicate<OptionalInt> IS_PRESENT_INT_JDK

IS_PRESENT_LONG_JDK

public static final Predicate<OptionalLong> IS_PRESENT_LONG_JDK

IS_PRESENT_DOUBLE_JDK

public static final Predicate<OptionalDouble> IS_PRESENT_DOUBLE_JDK

Method Details

memoize

@Beta
@SequentialOnly
@Stateful
public static <T> Supplier<T> memoize(Supplier<T> supplier)

Returns a Supplier which returns a single instance created by calling the specified supplier.get().

Type Parameters:

T -

Parameters:

supplier -

Returns:

memoize

@Beta
@SequentialOnly
@Stateful
public static <T,
R> Function<T,R> memoize(Function<? super T,? extends R> func)

Type Parameters:

T -

R -

Parameters:

func -

Returns:

close

public static Runnable close(AutoCloseable closeable)

Parameters:

closeable -

Returns:

closeAll

@SafeVarargs
public static Runnable closeAll(AutoCloseable... a)

Parameters:

a -

Returns:

closeAll

public static Runnable closeAll(Collection<? extends AutoCloseable> c)

Parameters:

c -

Returns:

closeQuietly

public static Runnable closeQuietly(AutoCloseable closeable)

Parameters:

closeable -

Returns:

closeAllQuietly

@SafeVarargs
public static Runnable closeAllQuietly(AutoCloseable... a)

Close all quietly.

Parameters:

a -

Returns:

closeAllQuietly

public static Runnable closeAllQuietly(Collection<? extends AutoCloseable> c)

Close all quietly.

Parameters:

c -

Returns:

emptyAction

public static Runnable emptyAction()

Returns:

shutDown

public static Runnable shutDown(ExecutorService service)

Parameters:

service -

Returns:

shutDown

public static Runnable shutDown(ExecutorService service,
 long terminationTimeout,
 TimeUnit timeUnit)

Parameters:

service -

terminationTimeout -

timeUnit -

Returns:

doNothing

public static <T> Consumer<T> doNothing()

Type Parameters:

T -

Returns:

throwRuntimeException

public static <T> Consumer<T> throwRuntimeException(String errorMessage)

Type Parameters:

T -

Parameters:

errorMessage -

Returns:

throwException

public static <T> Consumer<T> throwException(Supplier<? extends RuntimeException> excpetionSupplier)

Type Parameters:

T -

Parameters:

excpetionSupplier -

Returns:

toRuntimeException

public static Function<Throwable,RuntimeException> toRuntimeException()

Returns:

close

public static <T extends AutoCloseable> Consumer<T> close()

Type Parameters:

T -

Returns:

closeQuietly

public static <T extends AutoCloseable> Consumer<T> closeQuietly()

Type Parameters:

T -

Returns:

sleep

public static <T> Consumer<T> sleep(long millis)

Type Parameters:

T -

Parameters:

millis -

Returns:

sleepUninterruptibly

public static <T> Consumer<T> sleepUninterruptibly(long millis)

Type Parameters:

T -

Parameters:

millis -

Returns:

rateLimiter

@Stateful
public static <T> Consumer<T> rateLimiter(double permitsPerSecond)

Returns a stateful Consumer. Don't save or cache for reuse

Type Parameters:

T -

Parameters:

permitsPerSecond -

Returns:

See Also:

• RateLimiter.acquire()
• RateLimiter.create(double)

rateLimiter

@Stateful
public static <T> Consumer<T> rateLimiter(RateLimiter rateLimiter)

Returns a stateful Consumer. Don't save or cache for reuse

Type Parameters:

T -

Parameters:

rateLimiter -

Returns:

See Also:

• RateLimiter.acquire()

println

public static <T> Consumer<T> println()

Type Parameters:

T -

Returns:

println

public static <T,
U> BiConsumer<T,U> println(String separator)

Type Parameters:

T -

U -

Parameters:

separator -

Returns:

toStr

public static <T> Function<T,String> toStr()

Type Parameters:

T -

Returns:

toCamelCase

public static Function<String,String> toCamelCase()

To camel case.

Returns:

toLowerCase

public static Function<String,String> toLowerCase()

To lower case.

Returns:

toLowerCaseWithUnderscore

public static Function<String,String> toLowerCaseWithUnderscore()

To lower case with underscore.

Returns:

toUpperCase

public static Function<String,String> toUpperCase()

To upper case.

Returns:

toUpperCaseWithUnderscore

public static Function<String,String> toUpperCaseWithUnderscore()

To upper case with underscore.

Returns:

toJson

public static <T> Function<T,String> toJson()

Type Parameters:

T -

Returns:

toXml

public static <T> Function<T,String> toXml()

Type Parameters:

T -

Returns:

identity

public static <T> Function<T,T> identity()

Type Parameters:

T -

Returns:

keyed

public static <K,
T> Function<T,Keyed<K,T>> keyed(Function<? super T,K> keyMapper)

Type Parameters:

K - the key type

T -

Parameters:

keyMapper -

Returns:

val

public static <K,
T> Function<Keyed<K,T>,T> val()

Type Parameters:

K - the key type

T -

Returns:

kkv

public static <T,
K,
V>
Function<Map.Entry<Keyed<K,T>,V>,T> kkv()

Type Parameters:

T -

K - the key type

V - the value type

Returns:

wrap

public static <T> Function<T,Wrapper<T>> wrap()

Type Parameters:

T -

Returns:

wrap

public static <T> Function<T,Wrapper<T>> wrap(ToIntFunction<? super T> hashFunction,
 BiPredicate<? super T,? super T> equalsFunction)

Type Parameters:

T -

Parameters:

hashFunction -

equalsFunction -

Returns:

unwrap

public static <T> Function<Wrapper<T>,T> unwrap()

Type Parameters:

T -

Returns:

key

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

Type Parameters:

K - the key type

V - the value type

Returns:

value

public static <K,
V> Function<Map.Entry<K,V>,V> value()

Type Parameters:

K - the key type

V - the value type

Returns:

left

public static <L,
R> Function<Pair<L,R>,L> left()

Type Parameters:

L -

R -

Returns:

right

public static <L,
R> Function<Pair<L,R>,R> right()

Type Parameters:

L -

R -

Returns:

inverse

public static <K,
V>
Function<Map.Entry<K,V>,Map.Entry<V,K>> inverse()

Type Parameters:

K - the key type

V - the value type

Returns:

entry

public static <K,
V> BiFunction<K,V,Map.Entry<K,V>> entry()

Type Parameters:

K - the key type

V - the value type

Returns:

entry

@Deprecated
public static <K,
V> Function<V,Map.Entry<K,V>> entry(K key)

Deprecated.

replaced by Fn#entryWithKey(Object)

Type Parameters:

K - the key type

V - the value type

Parameters:

key -

Returns:

entry

@Deprecated
public static <K,
V> Function<V,Map.Entry<K,V>> entry(Function<? super V,K> keyMapper)

Deprecated.

replaced by Fn#entryByKeyMapper(Function)

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

Returns:

entryWithKey

public static <K,
V> Function<V,Map.Entry<K,V>> entryWithKey(K key)

Type Parameters:

K - the key type

V - the value type

Parameters:

key -

Returns:

entryByKeyMapper

public static <K,
V> Function<V,Map.Entry<K,V>> entryByKeyMapper(Function<? super V,K> keyMapper)

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

Returns:

entryWithValue

public static <K,
V> Function<K,Map.Entry<K,V>> entryWithValue(V value)

Type Parameters:

K - the key type

V - the value type

Parameters:

value -

Returns:

entryByValueMapper

public static <K,
V> Function<K,Map.Entry<K,V>> entryByValueMapper(Function<? super K,V> valueMapper)

Type Parameters:

K - the key type

V - the value type

Parameters:

valueMapper -

Returns:

pair

public static <L,
R> BiFunction<L,R,Pair<L,R>> pair()

Type Parameters:

L -

R -

Returns:

triple

public static <L,
M,
R>
TriFunction<L,M,R,Triple<L,M,R>> triple()

Type Parameters:

L -

M -

R -

Returns:

tuple1

public static <T> Function<T,Tuple.Tuple1<T>> tuple1()

Type Parameters:

T -

Returns:

tuple2

public static <T,
U>
BiFunction<T,U,Tuple.Tuple2<T,U>> tuple2()

Type Parameters:

T -

U -

Returns:

tuple3

public static <A,
B,
C>
TriFunction<A,B,C,Tuple.Tuple3<A,B,C>> tuple3()

Type Parameters:

A -

B -

C -

Returns:

tuple4

public static <A,
B,
C,
D>
QuadFunction<A,B,C,D,Tuple.Tuple4<A,B,C,D>> tuple4()

Type Parameters:

A -

B -

C -

D -

Returns:

trim

public static Function<String,String> trim()

Returns:

trimToEmpty

public static Function<String,String> trimToEmpty()

Returns:

trimToNull

public static Function<String,String> trimToNull()

Returns:

strip

public static Function<String,String> strip()

Returns:

stripToEmpty

public static Function<String,String> stripToEmpty()

Returns:

stripToNull

public static Function<String,String> stripToNull()

Returns:

nullToEmpty

public static Function<String,String> nullToEmpty()

Returns:

nullToEmptyL

@Deprecated
public static <T> Function<List<T>,List<T>> nullToEmptyL()

Deprecated.

replaced by nullToEmptyList

Type Parameters:

T -

Returns:

nullToEmptyList

public static <T> Function<List<T>,List<T>> nullToEmptyList()

Type Parameters:

T -

Returns:

nullToEmptyS

@Deprecated
public static <T> Function<Set<T>,Set<T>> nullToEmptyS()

Deprecated.

replaced by nullToEmptySet

Type Parameters:

T -

Returns:

nullToEmptySet

public static <T> Function<Set<T>,Set<T>> nullToEmptySet()

Type Parameters:

T -

Returns:

nullToEmptyM

@Deprecated
public static <K,
V> Function<Map<K,V>,Map<K,V>> nullToEmptyM()

Deprecated.

replaced by nullToEmptyMap

Type Parameters:

K - the key type

V - the value type

Returns:

nullToEmptyMap

public static <K,
V> Function<Map<K,V>,Map<K,V>> nullToEmptyMap()

Type Parameters:

K - the key type

V - the value type

Returns:

len

public static <T> Function<T[],Integer> len()

Type Parameters:

T -

Returns:

length

public static <T extends CharSequence>
Function<T,Integer> length()

Type Parameters:

T -

Returns:

size

public static <T extends Collection>
Function<T,Integer> size()

Type Parameters:

T -

Returns:

sizeM

public static <T extends Map> Function<T,Integer> sizeM()

Type Parameters:

T -

Returns:

cast

public static <T,
U> Function<T,U> cast(Class<U> clazz)

Type Parameters:

T -

U -

Parameters:

clazz -

Returns:

alwaysTrue

public static <T> Predicate<T> alwaysTrue()

Type Parameters:

T -

Returns:

alwaysFalse

public static <T> Predicate<T> alwaysFalse()

Type Parameters:

T -

Returns:

isNull

public static <T> Predicate<T> isNull()

Checks if is null.

Type Parameters:

T -

Returns:

isNull

public static <T> Predicate<T> isNull(Function<T,?> valueExtractor)

Checks if is null.

Type Parameters:

T -

Parameters:

valueExtractor -

Returns:

isEmpty

public static <T extends CharSequence> Predicate<T> isEmpty()

Checks if is null or empty.

Type Parameters:

T -

Returns:

isEmpty

public static <T> Predicate<T> isEmpty(Function<T,? extends CharSequence> valueExtractor)

Type Parameters:

T -

Parameters:

valueExtractor -

Returns:

isBlank

public static <T extends CharSequence> Predicate<T> isBlank()

Checks if is null or empty or blank.

Type Parameters:

T -

Returns:

isBlank

public static <T> Predicate<T> isBlank(Function<T,? extends CharSequence> valueExtractor)

Type Parameters:

T -

Parameters:

valueExtractor -

Returns:

isEmptyA

@Beta
public static <T> Predicate<T[]> isEmptyA()

Type Parameters:

T -

Returns:

isEmptyC

@Beta
public static <T extends Collection> Predicate<T> isEmptyC()

Type Parameters:

T -

Returns:

isEmptyM

@Beta
public static <T extends Map> Predicate<T> isEmptyM()

Type Parameters:

T -

Returns:

notNull

public static <T> Predicate<T> notNull()

Type Parameters:

T -

Returns:

notNull

public static <T> Predicate<T> notNull(Function<T,?> valueExtractor)

Not null.

Type Parameters:

T -

Parameters:

valueExtractor -

Returns:

notEmpty

public static <T extends CharSequence> Predicate<T> notEmpty()

Not null or empty.

Type Parameters:

T -

Returns:

notEmpty

public static <T> Predicate<T> notEmpty(Function<T,? extends CharSequence> valueExtractor)

Type Parameters:

T -

Parameters:

valueExtractor -

Returns:

notBlank

public static <T extends CharSequence> Predicate<T> notBlank()

Not null or empty or blank.

Type Parameters:

T -

Returns:

notBlank

public static <T> Predicate<T> notBlank(Function<T,? extends CharSequence> valueExtractor)

Type Parameters:

T -

Parameters:

valueExtractor -

Returns:

notEmptyA

@Beta
public static <T> Predicate<T[]> notEmptyA()

Type Parameters:

T -

Returns:

notEmptyC

@Beta
public static <T extends Collection> Predicate<T> notEmptyC()

Type Parameters:

T -

Returns:

notEmptyM

@Beta
public static <T extends Map> Predicate<T> notEmptyM()

Type Parameters:

T -

Returns:

isFile

public static Predicate<File> isFile()

Checks if is file.

Returns:

isDirectory

public static Predicate<File> isDirectory()

Checks if is directory.

Returns:

equal

public static <T> Predicate<T> equal(Object target)

Type Parameters:

T -

Parameters:

target -

Returns:

eqOr

public static <T> Predicate<T> eqOr(Object targetValue1,
 Object targetValue2)

Type Parameters:

T -

Parameters:

targetValue1 -

targetValue2 -

Returns:

eqOr

public static <T> Predicate<T> eqOr(Object targetValue1,
 Object targetValue2,
 Object targetValue3)

Type Parameters:

T -

Parameters:

targetValue1 -

targetValue2 -

targetValue3 -

Returns:

notEqual

public static <T> Predicate<T> notEqual(Object target)

Type Parameters:

T -

Parameters:

target -

Returns:

greaterThan

public static <T extends Comparable<? super T>>
Predicate<T> greaterThan(T target)

Type Parameters:

T -

Parameters:

target -

Returns:

greaterEqual

public static <T extends Comparable<? super T>>
Predicate<T> greaterEqual(T target)

Type Parameters:

T -

Parameters:

target -

Returns:

lessThan

public static <T extends Comparable<? super T>>
Predicate<T> lessThan(T target)

Type Parameters:

T -

Parameters:

target -

Returns:

lessEqual

public static <T extends Comparable<? super T>>
Predicate<T> lessEqual(T target)

Type Parameters:

T -

Parameters:

target -

Returns:

gtAndLt

public static <T extends Comparable<? super T>>
Predicate<T> gtAndLt(T minValue,
 T maxValue)

Checks if the value/element: minValue < e < maxValue.

Type Parameters:

T -

Parameters:

minValue -

maxValue -

Returns:

geAndLt

public static <T extends Comparable<? super T>>
Predicate<T> geAndLt(T minValue,
 T maxValue)

Checks if the value/element: minValue <= e < maxValue.

Type Parameters:

T -

Parameters:

minValue -

maxValue -

Returns:

geAndLe

public static <T extends Comparable<? super T>>
Predicate<T> geAndLe(T minValue,
 T maxValue)

Checks if the value/element: minValue <= e <= maxValue.

Type Parameters:

T -

Parameters:

minValue -

maxValue -

Returns:

gtAndLe

public static <T extends Comparable<? super T>>
Predicate<T> gtAndLe(T minValue,
 T maxValue)

Checks if the value/element: minValue < e <= maxValue.

Type Parameters:

T -

Parameters:

minValue -

maxValue -

Returns:

between

@Deprecated
public static <T extends Comparable<? super T>>
Predicate<T> between(T minValue,
 T maxValue)

Deprecated.

replaced by gtAndLt.

Checks if the value/element: minValue < e < maxValue.

Type Parameters:

T -

Parameters:

minValue -

maxValue -

Returns:

in

public static <T> Predicate<T> in(Collection<?> c)

Type Parameters:

T -

Parameters:

c -

Returns:

notIn

public static <T> Predicate<T> notIn(Collection<?> c)

Type Parameters:

T -

Parameters:

c -

Returns:

instanceOf

public static <T> Predicate<T> instanceOf(Class<?> clazz)

Type Parameters:

T -

Parameters:

clazz -

Returns:

subtypeOf

public static Predicate<Class> subtypeOf(Class<?> clazz)

Parameters:

clazz -

Returns:

startsWith

public static Predicate<String> startsWith(String prefix)

Parameters:

prefix -

Returns:

endsWith

public static Predicate<String> endsWith(String suffix)

Parameters:

suffix -

Returns:

contains

public static Predicate<String> contains(String str)

Parameters:

str -

Returns:

notStartsWith

public static Predicate<String> notStartsWith(String prefix)

Not starts with.

Parameters:

prefix -

Returns:

notEndsWith

public static Predicate<String> notEndsWith(String suffix)

Not ends with.

Parameters:

suffix -

Returns:

notContains

public static Predicate<String> notContains(String str)

Parameters:

str -

Returns:

matches

public static Predicate<CharSequence> matches(Pattern pattern)

Parameters:

pattern -

Returns:

equal

public static <T,
U> BiPredicate<T,U> equal()

Type Parameters:

T -

U -

Returns:

notEqual

public static <T,
U> BiPredicate<T,U> notEqual()

Type Parameters:

T -

U -

Returns:

greaterThan

public static <T extends Comparable<? super T>>
BiPredicate<T,T> greaterThan()

Type Parameters:

T -

Returns:

greaterEqual

public static <T extends Comparable<? super T>>
BiPredicate<T,T> greaterEqual()

Type Parameters:

T -

Returns:

lessThan

public static <T extends Comparable<? super T>>
BiPredicate<T,T> lessThan()

Type Parameters:

T -

Returns:

lessEqual

public static <T extends Comparable<? super T>>
BiPredicate<T,T> lessEqual()

Type Parameters:

T -

Returns:

not

public static <T> Predicate<T> not(Predicate<T> predicate)

Type Parameters:

T -

Parameters:

predicate -

Returns:

not

public static <T,
U> BiPredicate<T,U> not(BiPredicate<T,U> biPredicate)

Type Parameters:

T -

U -

Parameters:

biPredicate -

Returns:

not

public static <A,
B,
C> TriPredicate<A,B,C> not(TriPredicate<A,B,C> triPredicate)

Type Parameters:

A -

B -

C -

Parameters:

triPredicate -

Returns:

and

public static BooleanSupplier and(BooleanSupplier first,
 BooleanSupplier second)

Parameters:

first -

second -

Returns:

and

public static BooleanSupplier and(BooleanSupplier first,
 BooleanSupplier second,
 BooleanSupplier third)

Parameters:

first -

second -

third -

Returns:

and

public static <T> Predicate<T> and(Predicate<? super T> first,
 Predicate<? super T> second)

Type Parameters:

T -

Parameters:

first -

second -

Returns:

and

public static <T> Predicate<T> and(Predicate<? super T> first,
 Predicate<? super T> second,
 Predicate<? super T> third)

Type Parameters:

T -

Parameters:

first -

second -

third -

Returns:

and

public static <T> Predicate<T> and(Collection<? extends Predicate<? super T>> c)
                            throws IllegalArgumentException

Type Parameters:

T -

Parameters:

c -

Returns:

Throws:

IllegalArgumentException - if the specified c is null or empty.

and

public static <T,
U> BiPredicate<T,U> and(BiPredicate<? super T,? super U> first,
 BiPredicate<? super T,? super U> second)

Type Parameters:

T -

U -

Parameters:

first -

second -

Returns:

and

public static <T,
U> BiPredicate<T,U> and(BiPredicate<? super T,? super U> first,
 BiPredicate<? super T,? super U> second,
 BiPredicate<? super T,? super U> third)

Type Parameters:

T -

U -

Parameters:

first -

second -

third -

Returns:

and

public static <T,
U> BiPredicate<T,U> and(List<? extends BiPredicate<? super T,? super U>> c)
                                  throws IllegalArgumentException

Type Parameters:

T -

U -

Parameters:

c -

Returns:

Throws:

IllegalArgumentException - if the specified c is null or empty.

or

public static BooleanSupplier or(BooleanSupplier first,
 BooleanSupplier second)

Parameters:

first -

second -

Returns:

or

public static BooleanSupplier or(BooleanSupplier first,
 BooleanSupplier second,
 BooleanSupplier third)

Parameters:

first -

second -

third -

Returns:

or

public static <T> Predicate<T> or(Predicate<? super T> first,
 Predicate<? super T> second)

Type Parameters:

T -

Parameters:

first -

second -

Returns:

or

public static <T> Predicate<T> or(Predicate<? super T> first,
 Predicate<? super T> second,
 Predicate<? super T> third)

Type Parameters:

T -

Parameters:

first -

second -

third -

Returns:

or

public static <T> Predicate<T> or(Collection<? extends Predicate<? super T>> c)
                           throws IllegalArgumentException

Type Parameters:

T -

Parameters:

c -

Returns:

Throws:

IllegalArgumentException - if the specified c is null or empty.

or

public static <T,
U> BiPredicate<T,U> or(BiPredicate<? super T,? super U> first,
 BiPredicate<? super T,? super U> second)

Type Parameters:

T -

U -

Parameters:

first -

second -

Returns:

or

public static <T,
U> BiPredicate<T,U> or(BiPredicate<? super T,? super U> first,
 BiPredicate<? super T,? super U> second,
 BiPredicate<? super T,? super U> third)

Type Parameters:

T -

U -

Parameters:

first -

second -

third -

Returns:

or

public static <T,
U> BiPredicate<T,U> or(List<? extends BiPredicate<? super T,? super U>> c)
                                 throws IllegalArgumentException

Type Parameters:

T -

U -

Parameters:

c -

Returns:

Throws:

IllegalArgumentException - if the specified c is null or empty.

testByKey

public static <K,
V> Predicate<Map.Entry<K,V>> testByKey(Predicate<? super K> predicate)

Test by key.

Type Parameters:

K - the key type

V - the value type

Parameters:

predicate -

Returns:

testByValue

public static <K,
V> Predicate<Map.Entry<K,V>> testByValue(Predicate<? super V> predicate)

Test by value.

Type Parameters:

K - the key type

V - the value type

Parameters:

predicate -

Returns:

acceptByKey

public static <K,
V> Consumer<Map.Entry<K,V>> acceptByKey(Consumer<? super K> consumer)

Accept by key.

Type Parameters:

K - the key type

V - the value type

Parameters:

consumer -

Returns:

acceptByValue

public static <K,
V> Consumer<Map.Entry<K,V>> acceptByValue(Consumer<? super V> consumer)

Accept by value.

Type Parameters:

K - the key type

V - the value type

Parameters:

consumer -

Returns:

acceptIf

@Beta
public static <T> Consumer<T> acceptIf(Predicate<? super T> predicate,
 Consumer<? super T> consumer)

Type Parameters:

T -

Parameters:

predicate -

consumer -

Returns:

acceptIfOrElse

@Beta
public static <T> Consumer<T> acceptIfOrElse(Predicate<? super T> predicate,
 Consumer<? super T> consumerForTrue,
 Consumer<? super T> consumerForFalse)

Type Parameters:

T -

Parameters:

predicate -

consumerForTrue -

consumerForFalse -

Returns:

applyByKey

public static <K,
V,
R> Function<Map.Entry<K,V>,R> applyByKey(Function<? super K,? extends R> func)

Apply by key.

Type Parameters:

K - the key type

V - the value type

R -

Parameters:

func -

Returns:

applyByValue

public static <K,
V,
R> Function<Map.Entry<K,V>,R> applyByValue(Function<? super V,? extends R> func)

Apply by value.

Type Parameters:

K - the key type

V - the value type

R -

Parameters:

func -

Returns:

applyIfOrElseDefault

@Beta
public static <T,
R> Function<T,R> applyIfOrElseDefault(Predicate<? super T> predicate,
 Function<? super T,? extends R> func,
 R defaultValue)

Type Parameters:

T -

R -

Parameters:

predicate -

func -

defaultValue -

Returns:

applyIfOrElseGet

@Beta
public static <T,
R> Function<T,R> applyIfOrElseGet(Predicate<? super T> predicate,
 Function<? super T,? extends R> func,
 Supplier<? extends R> supplier)

Type Parameters:

T -

R -

Parameters:

predicate -

func -

supplier -

Returns:

applyIfNotNullOrDefault

public static <A,
B,
R> Function<A,R> applyIfNotNullOrDefault(Function<A,B> mapperA,
 Function<B,? extends R> mapperB,
 R defaultValue)

Apply if not null or default.

Type Parameters:

A -

B -

R -

Parameters:

mapperA -

mapperB -

defaultValue -

Returns:

applyIfNotNullOrDefault

public static <A,
B,
C,
R> Function<A,R> applyIfNotNullOrDefault(Function<A,B> mapperA,
 Function<B,C> mapperB,
 Function<C,? extends R> mapperC,
 R defaultValue)

Apply if not null or default.

Type Parameters:

A -

B -

C -

R -

Parameters:

mapperA -

mapperB -

mapperC -

defaultValue -

Returns:

applyIfNotNullOrDefault

public static <A,
B,
C,
D,
R> Function<A,R> applyIfNotNullOrDefault(Function<A,B> mapperA,
 Function<B,C> mapperB,
 Function<C,D> mapperC,
 Function<D,? extends R> mapperD,
 R defaultValue)

Apply if not null or default.

Type Parameters:

A -

B -

C -

D -

R -

Parameters:

mapperA -

mapperB -

mapperC -

mapperD -

defaultValue -

Returns:

applyIfNotNullOrElseGet

public static <A,
B,
R> Function<A,R> applyIfNotNullOrElseGet(Function<A,B> mapperA,
 Function<B,? extends R> mapperB,
 Supplier<R> supplier)

Apply if not null or get.

Type Parameters:

A -

B -

R -

Parameters:

mapperA -

mapperB -

supplier -

Returns:

applyIfNotNullOrElseGet

public static <A,
B,
C,
R> Function<A,R> applyIfNotNullOrElseGet(Function<A,B> mapperA,
 Function<B,C> mapperB,
 Function<C,? extends R> mapperC,
 Supplier<R> supplier)

Apply if not null or get.

Type Parameters:

A -

B -

C -

R -

Parameters:

mapperA -

mapperB -

mapperC -

supplier -

Returns:

applyIfNotNullOrElseGet

public static <A,
B,
C,
D,
R> Function<A,R> applyIfNotNullOrElseGet(Function<A,B> mapperA,
 Function<B,C> mapperB,
 Function<C,D> mapperC,
 Function<D,? extends R> mapperD,
 Supplier<R> supplier)

Apply if not null or get.

Type Parameters:

A -

B -

C -

D -

R -

Parameters:

mapperA -

mapperB -

mapperC -

mapperD -

supplier -

Returns:

mapKey

public static <K,
V,
KK>
Function<Map.Entry<K,V>,Map.Entry<KK,V>> mapKey(Function<? super K,? extends KK> func)

Type Parameters:

K - the key type

V - the value type

KK -

Parameters:

func -

Returns:

mapValue

public static <K,
V,
VV>
Function<Map.Entry<K,V>,Map.Entry<K,VV>> mapValue(Function<? super V,? extends VV> func)

Type Parameters:

K - the key type

V - the value type

VV -

Parameters:

func -

Returns:

testKeyVal

public static <K,
V> Predicate<Map.Entry<K,V>> testKeyVal(BiPredicate<? super K,? super V> predicate)

Test key val.

Type Parameters:

K - the key type

V - the value type

Parameters:

predicate -

Returns:

acceptKeyVal

public static <K,
V> Consumer<Map.Entry<K,V>> acceptKeyVal(BiConsumer<? super K,? super V> consumer)

Accept key val.

Type Parameters:

K - the key type

V - the value type

Parameters:

consumer -

Returns:

applyKeyVal

public static <K,
V,
R> Function<Map.Entry<K,V>,R> applyKeyVal(BiFunction<? super K,? super V,? extends R> func)

Apply key val.

Type Parameters:

K - the key type

V - the value type

R -

Parameters:

func -

Returns:

flatToMap

public static <K,
V>
Function<? super Map<K,? extends Collection<? extends V>>,List<Map<K,V>>> flatToMap()

{a=[1, 2, 3], b=[4, 5, 6], c=[7, 8]} -> [{a=1, b=4, c=7}, {a=2, b=5, c=8}, {a=3, b=6}].

Type Parameters:

K - the key type

V - the value type

Returns:

See Also:

• Maps.flatToMap(Map)

parseByte

public static Function<String,Byte> parseByte()

Parses the byte.

Returns:

parseShort

public static Function<String,Short> parseShort()

Parses the short.

Returns:

parseInt

public static Function<String,Integer> parseInt()

Parses the int.

Returns:

parseLong

public static Function<String,Long> parseLong()

Parses the long.

Returns:

parseFloat

public static Function<String,Float> parseFloat()

Parses the float.

Returns:

parseDouble

public static Function<String,Double> parseDouble()

Parses the double.

Returns:

createNumber

public static Function<String,Number> createNumber()

Creates the number.

Returns:

See Also:

• Numbers.createNumber(String)

numToInt

public static <T extends Number> ToIntFunction<T> numToInt()

Num to int.

Type Parameters:

T -

Returns:

numToLong

public static <T extends Number> ToLongFunction<T> numToLong()

Num to long.

Type Parameters:

T -

Returns:

numToDouble

public static <T extends Number>
ToDoubleFunction<T> numToDouble()

Num to double.

Type Parameters:

T -

Returns:

atMost

@Beta
@Stateful
public static <T> Predicate<T> atMost(int count)

Type Parameters:

T -

Parameters:

count -

Returns:

limitThenFilter

@Beta
@SequentialOnly
@Stateful
public static <T> Predicate<T> limitThenFilter(int limit,
 Predicate<T> predicate)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Parameters:

limit -

predicate -

Returns:

limitThenFilter

@Beta
@SequentialOnly
@Stateful
public static <T,
U> BiPredicate<T,U> limitThenFilter(int limit,
 BiPredicate<T,U> predicate)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

U -

Parameters:

limit -

predicate -

Returns:

filterThenLimit

@Beta
@SequentialOnly
@Stateful
public static <T> Predicate<T> filterThenLimit(Predicate<T> predicate,
 int limit)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Parameters:

predicate -

limit -

Returns:

filterThenLimit

@Beta
@SequentialOnly
@Stateful
public static <T,
U> BiPredicate<T,U> filterThenLimit(BiPredicate<T,U> predicate,
 int limit)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

U -

Parameters:

predicate -

limit -

Returns:

timeLimit

@Beta
@SequentialOnly
@Stateful
public static <T> Predicate<T> timeLimit(long timeInMillis)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Parameters:

timeInMillis -

Returns:

timeLimit

@Beta
@SequentialOnly
@Stateful
public static <T> Predicate<T> timeLimit(Duration duration)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Parameters:

duration -

Returns:

indexed

@Beta
@SequentialOnly
@Stateful
public static <T> Function<T,Indexed<T>> indexed()

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Returns:

indexed

@Beta
@SequentialOnly
@Stateful
public static <T> Predicate<T> indexed(IntObjPredicate<T> predicate)

Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Parameters:

predicate -

Returns:

selectFirst

public static <T> BinaryOperator<T> selectFirst()

Type Parameters:

T -

Returns:

selectSecond

public static <T> BinaryOperator<T> selectSecond()

Type Parameters:

T -

Returns:

min

public static <T extends Comparable<? super T>>
BinaryOperator<T> min()

Type Parameters:

T -

Returns:

min

public static <T> BinaryOperator<T> min(Comparator<? super T> comparator)

Type Parameters:

T -

Parameters:

comparator -

Returns:

minBy

public static <T> BinaryOperator<T> minBy(Function<? super T,? extends Comparable> keyMapper)

Type Parameters:

T -

Parameters:

keyMapper -

Returns:

minByKey

public static <K extends Comparable<? super K>,
V>
BinaryOperator<Map.Entry<K,V>> minByKey()

Type Parameters:

K -

V -

Returns:

minByValue

public static <K,
V extends Comparable<? super V>>
BinaryOperator<Map.Entry<K,V>> minByValue()

Type Parameters:

K -

V -

Returns:

max

public static <T extends Comparable<? super T>>
BinaryOperator<T> max()

Type Parameters:

T -

Returns:

max

public static <T> BinaryOperator<T> max(Comparator<? super T> comparator)

Type Parameters:

T -

Parameters:

comparator -

Returns:

maxBy

public static <T> BinaryOperator<T> maxBy(Function<? super T,? extends Comparable> keyMapper)

Type Parameters:

T -

Parameters:

keyMapper -

Returns:

maxByKey

public static <K extends Comparable<? super K>,
V>
BinaryOperator<Map.Entry<K,V>> maxByKey()

Type Parameters:

K -

V -

Returns:

maxByValue

public static <K,
V extends Comparable<? super V>>
BinaryOperator<Map.Entry<K,V>> maxByValue()

Type Parameters:

K -

V -

Returns:

compareTo

public static <T extends Comparable<? super T>>
Function<T,Integer> compareTo(T target)

Type Parameters:

T -

Parameters:

target -

Returns:

compareTo

public static <T> Function<T,Integer> compareTo(T target,
 Comparator<? super T> cmp)

Type Parameters:

T -

Parameters:

target -

cmp -

Returns:

compare

public static <T extends Comparable<? super T>>
BiFunction<T,T,Integer> compare()

Type Parameters:

T -

Returns:

compare

public static <T> BiFunction<T,T,Integer> compare(Comparator<? super T> cmp)

Type Parameters:

T -

Parameters:

cmp -

Returns:

futureGetOrDefaultOnError

@Beta
public static <T> Function<Future<T>,T> futureGetOrDefaultOnError(T defaultValue)

Type Parameters:

T -

Parameters:

defaultValue -

Returns:

futureGet

@Beta
public static <T> Function<Future<T>,T> futureGet()

Type Parameters:

T -

Returns:

from

@Beta
public static <T> Supplier<T> from(Supplier<T> supplier)

Type Parameters:

T -

Parameters:

supplier -

Returns:

from

@Beta
public static <T> IntFunction<T> from(IntFunction<? extends T> func)

Type Parameters:

T -

Parameters:

func -

Returns:

from

@Beta
public static <T> Predicate<T> from(Predicate<T> predicate)

Type Parameters:

T -

Parameters:

predicate -

Returns:

from

@Beta
public static <T,
U> BiPredicate<T,U> from(BiPredicate<T,U> predicate)

Type Parameters:

T -

U -

Parameters:

predicate -

Returns:

from

@Beta
public static <T> Consumer<T> from(Consumer<T> consumer)

Type Parameters:

T -

Parameters:

consumer -

Returns:

from

@Beta
public static <T,
U> BiConsumer<T,U> from(BiConsumer<T,U> consumer)

Type Parameters:

T -

U -

Parameters:

consumer -

Returns:

from

@Beta
public static <T,
R> Function<T,R> from(Function<T,? extends R> function)

Type Parameters:

T -

R -

Parameters:

function -

Returns:

from

@Beta
public static <T,
U,
R> BiFunction<T,U,R> from(BiFunction<T,U,? extends R> function)

Type Parameters:

T -

U -

R -

Parameters:

function -

Returns:

from

@Beta
public static <T> UnaryOperator<T> from(UnaryOperator<T> op)

Type Parameters:

T -

Parameters:

op -

Returns:

from

@Beta
public static <T> BinaryOperator<T> from(BinaryOperator<T> op)

Type Parameters:

T -

Parameters:

op -

Returns:

p

@Beta
public static <T> Predicate<T> p(Predicate<T> predicate)

Type Parameters:

T -

Parameters:

predicate -

Returns:

p

@Beta
public static <A,
T> Predicate<T> p(A a,
 BiPredicate<A,T> biPredicate)

Type Parameters:

A -

T -

Parameters:

a -

biPredicate -

Returns:

p

@Beta
public static <A,
B,
T> Predicate<T> p(A a,
 B b,
 TriPredicate<A,B,T> triPredicate)

Type Parameters:

A -

B -

T -

Parameters:

a -

b -

triPredicate -

Returns:

p

@Beta
public static <T,
U> BiPredicate<T,U> p(BiPredicate<T,U> biPredicate)

Type Parameters:

T -

U -

Parameters:

biPredicate -

Returns:

p

@Beta
public static <A,
T,
U> BiPredicate<T,U> p(A a,
 TriPredicate<A,T,U> triPredicate)

Type Parameters:

A -

T -

U -

Parameters:

a -

triPredicate -

Returns:

p

@Beta
public static <A,
B,
C> TriPredicate<A,B,C> p(TriPredicate<A,B,C> triPredicate)

Type Parameters:

A -

B -

C -

Parameters:

triPredicate -

Returns:

c

@Beta
public static <T> Consumer<T> c(Consumer<T> predicate)

Type Parameters:

T -

Parameters:

predicate -

Returns:

c

@Beta
public static <A,
T> Consumer<T> c(A a,
 BiConsumer<A,T> biConsumer)

Type Parameters:

A -

T -

Parameters:

a -

biConsumer -

Returns:

c

@Beta
public static <A,
B,
T> Consumer<T> c(A a,
 B b,
 TriConsumer<A,B,T> triConsumer)

Type Parameters:

A -

B -

T -

Parameters:

a -

b -

triConsumer -

Returns:

c

@Beta
public static <T,
U> BiConsumer<T,U> c(BiConsumer<T,U> biConsumer)

Type Parameters:

T -

U -

Parameters:

biConsumer -

Returns:

c

@Beta
public static <A,
T,
U> BiConsumer<T,U> c(A a,
 TriConsumer<A,T,U> triConsumer)

Type Parameters:

A -

T -

U -

Parameters:

a -

triConsumer -

Returns:

c

@Beta
public static <A,
B,
C> TriConsumer<A,B,C> c(TriConsumer<A,B,C> triConsumer)

Type Parameters:

A -

B -

C -

Parameters:

triConsumer -

Returns:

f

@Beta
public static <T,
R> Function<T,R> f(Function<T,R> predicate)

Type Parameters:

T -

R -

Parameters:

predicate -

Returns:

f

@Beta
public static <A,
T,
R> Function<T,R> f(A a,
 BiFunction<A,T,R> biFunction)

Type Parameters:

A -

T -

R -

Parameters:

a -

biFunction -

Returns:

f

@Beta
public static <A,
B,
T,
R> Function<T,R> f(A a,
 B b,
 TriFunction<A,B,T,R> triFunction)

Type Parameters:

A -

B -

T -

R -

Parameters:

a -

b -

triFunction -

Returns:

f

@Beta
public static <T,
U,
R> BiFunction<T,U,R> f(BiFunction<T,U,R> biFunction)

Type Parameters:

T -

U -

R -

Parameters:

biFunction -

Returns:

f

@Beta
public static <A,
T,
U,
R> BiFunction<T,U,R> f(A a,
 TriFunction<A,T,U,R> triFunction)

Type Parameters:

A -

T -

U -

R -

Parameters:

a -

triFunction -

Returns:

f

@Beta
public static <A,
B,
C,
R> TriFunction<A,B,C,R> f(TriFunction<A,B,C,R> triFunction)

Type Parameters:

A -

B -

C -

R -

Parameters:

triFunction -

Returns:

pp

@Beta
public static <T> Predicate<T> pp(Throwables.Predicate<T,? extends Exception> predicate)

Type Parameters:

T -

Parameters:

predicate -

Returns:

pp

@Beta
public static <A,
T> Predicate<T> pp(A a,
 Throwables.BiPredicate<A,T,? extends Exception> biPredicate)

Type Parameters:

A -

T -

Parameters:

a -

biPredicate -

Returns:

pp

@Beta
public static <A,
B,
T> Predicate<T> pp(A a,
 B b,
 Throwables.TriPredicate<A,B,T,? extends Exception> triPredicate)

Type Parameters:

A -

B -

T -

Parameters:

a -

b -

triPredicate -

Returns:

pp

@Beta
public static <T,
U> BiPredicate<T,U> pp(Throwables.BiPredicate<T,U,? extends Exception> biPredicate)

Type Parameters:

T -

U -

Parameters:

biPredicate -

Returns:

pp

@Beta
public static <A,
T,
U> BiPredicate<T,U> pp(A a,
 Throwables.TriPredicate<A,T,U,? extends Exception> triPredicate)

Type Parameters:

A -

T -

U -

Parameters:

a -

triPredicate -

Returns:

pp

@Beta
public static <A,
B,
C> TriPredicate<A,B,C> pp(Throwables.TriPredicate<A,B,C,? extends Exception> triPredicate)

Type Parameters:

A -

B -

C -

Parameters:

triPredicate -

Returns:

cc

@Beta
public static <T> Consumer<T> cc(Throwables.Consumer<T,? extends Exception> consumer)

Type Parameters:

T -

Parameters:

consumer -

Returns:

cc

@Beta
public static <A,
T> Consumer<T> cc(A a,
 Throwables.BiConsumer<A,T,? extends Exception> biConsumer)

Type Parameters:

A -

T -

Parameters:

a -

biConsumer -

Returns:

cc

@Beta
public static <A,
B,
T> Consumer<T> cc(A a,
 B b,
 Throwables.TriConsumer<A,B,T,? extends Exception> triConsumer)

Type Parameters:

A -

B -

T -

Parameters:

a -

b -

triConsumer -

Returns:

cc

@Beta
public static <T,
U> BiConsumer<T,U> cc(Throwables.BiConsumer<T,U,? extends Exception> biConsumer)

Type Parameters:

T -

U -

Parameters:

biConsumer -

Returns:

cc

@Beta
public static <A,
T,
U> BiConsumer<T,U> cc(A a,
 Throwables.TriConsumer<A,T,U,? extends Exception> triConsumer)

Type Parameters:

A -

T -

U -

Parameters:

a -

triConsumer -

Returns:

cc

@Beta
public static <A,
B,
C> TriConsumer<A,B,C> cc(Throwables.TriConsumer<A,B,C,? extends Exception> triConsumer)

Type Parameters:

A -

B -

C -

Parameters:

triConsumer -

Returns:

ff

@Beta
public static <T,
R> Function<T,R> ff(Throwables.Function<T,? extends R,? extends Exception> function)

Type Parameters:

T -

R -

Parameters:

function -

Returns:

ff

@Beta
public static <T,
R> Function<T,R> ff(Throwables.Function<T,? extends R,? extends Exception> function,
 R defaultOnError)

Type Parameters:

T -

R -

Parameters:

function -

defaultOnError -

Returns:

ff

@Beta
public static <A,
T,
R> Function<T,R> ff(A a,
 Throwables.BiFunction<A,T,R,? extends Exception> biFunction)

Type Parameters:

A -

T -

R -

Parameters:

a -

biFunction -

Returns:

ff

@Beta
public static <A,
B,
T,
R> Function<T,R> ff(A a,
 B b,
 Throwables.TriFunction<A,B,T,R,? extends Exception> triFunction)

Type Parameters:

A -

B -

T -

R -

Parameters:

a -

b -

triFunction -

Returns:

ff

@Beta
public static <T,
U,
R> BiFunction<T,U,R> ff(Throwables.BiFunction<T,U,R,? extends Exception> biFunction)

Type Parameters:

T -

U -

R -

Parameters:

biFunction -

Returns:

ff

@Beta
public static <T,
U,
R> BiFunction<T,U,R> ff(Throwables.BiFunction<T,U,R,? extends Exception> biFunction,
 R defaultOnError)

Type Parameters:

T -

U -

R -

Parameters:

biFunction -

defaultOnError -

Returns:

ff

@Beta
public static <A,
T,
U,
R> BiFunction<T,U,R> ff(A a,
 Throwables.TriFunction<A,T,U,R,? extends Exception> triFunction)

Type Parameters:

A -

T -

U -

R -

Parameters:

a -

triFunction -

Returns:

ff

@Beta
public static <A,
B,
C,
R> TriFunction<A,B,C,R> ff(Throwables.TriFunction<A,B,C,R,? extends Exception> triFunction)

Type Parameters:

A -

B -

C -

R -

Parameters:

triFunction -

Returns:

ff

@Beta
public static <A,
B,
C,
R> TriFunction<A,B,C,R> ff(Throwables.TriFunction<A,B,C,R,? extends Exception> triFunction,
 R defaultOnError)

Type Parameters:

A -

B -

C -

R -

Parameters:

triFunction -

defaultOnError -

Returns:

sp

@Beta
public static <T> Predicate<T> sp(Object mutex,
 Predicate<T> predicate)

Synchronized Predicate.

Type Parameters:

T -

Parameters:

mutex - to synchronized on

predicate -

Returns:

sp

@Beta
public static <A,
T> Predicate<T> sp(Object mutex,
 A a,
 BiPredicate<A,T> biPredicate)

Synchronized Predicate.

Type Parameters:

A -

T -

Parameters:

mutex - to synchronized on

a -

biPredicate -

Returns:

sp

@Beta
public static <A,
B,
T> Predicate<T> sp(Object mutex,
 A a,
 B b,
 TriPredicate<A,B,T> triPredicate)

Synchronized Predicate.

Type Parameters:

A -

B -

T -

Parameters:

mutex - to synchronized on

a -

b -

triPredicate -

Returns:

sp

@Beta
public static <T,
U> BiPredicate<T,U> sp(Object mutex,
 BiPredicate<T,U> biPredicate)

Synchronized BiPredicate.

Type Parameters:

T -

U -

Parameters:

mutex - to synchronized on

biPredicate -

Returns:

sc

@Beta
public static <T> Consumer<T> sc(Object mutex,
 Consumer<T> consumer)

Synchronized Consumer.

Type Parameters:

T -

Parameters:

mutex - to synchronized on

consumer -

Returns:

sc

@Beta
public static <A,
T> Consumer<T> sc(Object mutex,
 A a,
 BiConsumer<A,T> biConsumer)

Synchronized Consumer.

Type Parameters:

A -

T -

Parameters:

mutex - to synchronized on

a -

biConsumer -

Returns:

sc

@Beta
public static <T,
U> BiConsumer<T,U> sc(Object mutex,
 BiConsumer<T,U> biConsumer)

Synchronized BiConsumer.

Type Parameters:

T -

U -

Parameters:

mutex - to synchronized on

biConsumer -

Returns:

sf

@Beta
public static <T,
R> Function<T,R> sf(Object mutex,
 Function<T,? extends R> function)

Synchronized Function.

Type Parameters:

T -

R -

Parameters:

mutex - to synchronized on

function -

Returns:

sf

@Beta
public static <A,
T,
R> Function<T,R> sf(Object mutex,
 A a,
 BiFunction<A,T,R> biFunction)

Synchronized Function.

Type Parameters:

A -

T -

R -

Parameters:

mutex - to synchronized on

a -

biFunction -

Returns:

sf

@Beta
public static <T,
U,
R> BiFunction<T,U,R> sf(Object mutex,
 BiFunction<T,U,R> biFunction)

Synchronized BiFunction.

Type Parameters:

T -

U -

R -

Parameters:

mutex - to synchronized on

biFunction -

Returns:

c2f

public static <T> Function<T,Void> c2f(Consumer<? super T> action)

Type Parameters:

T -

Parameters:

action -

Returns:

c2f

public static <T,
R> Function<T,R> c2f(Consumer<? super T> action,
 R valueToReturn)

Type Parameters:

T -

R -

Parameters:

action -

valueToReturn -

Returns:

c2f

public static <T,
U> BiFunction<T,U,Void> c2f(BiConsumer<? super T,? super U> action)

Type Parameters:

T -

U -

Parameters:

action -

Returns:

c2f

public static <T,
U,
R> BiFunction<T,U,R> c2f(BiConsumer<? super T,? super U> action,
 R valueToReturn)

Type Parameters:

T -

U -

R -

Parameters:

action -

valueToReturn -

Returns:

c2f

public static <A,
B,
C> TriFunction<A,B,C,Void> c2f(TriConsumer<? super A,? super B,? super C> action)

Type Parameters:

A -

B -

C -

Parameters:

action -

Returns:

c2f

public static <A,
B,
C,
R> TriFunction<A,B,C,R> c2f(TriConsumer<? super A,? super B,? super C> action,
 R valueToReturn)

Type Parameters:

A -

B -

C -

R -

Parameters:

action -

valueToReturn -

Returns:

f2c

public static <T> Consumer<T> f2c(Function<? super T,?> func)

Returns a Consumer which calls the specified func.

Type Parameters:

T -

Parameters:

func -

Returns:

f2c

public static <T,
U> BiConsumer<T,U> f2c(BiFunction<? super T,? super U,?> func)

Type Parameters:

T -

U -

Parameters:

func -

Returns:

f2c

public static <A,
B,
C> TriConsumer<A,B,C> f2c(TriFunction<? super A,? super B,? super C,?> func)

Type Parameters:

A -

B -

C -

Parameters:

func -

Returns:

rr

public static Runnable rr(Throwables.Runnable<? extends Exception> runnbale)

Parameters:

runnbale -

Returns:

cc

public static <R> Callable<R> cc(Throwables.Callable<R,? extends Exception> callable)

Type Parameters:

R -

Parameters:

callable -

Returns:

r

public static Runnable r(Runnable runnable)

Parameters:

runnable -

Returns:

c

public static <R> Callable<R> c(Callable<R> callable)

Type Parameters:

R -

Parameters:

callable -

Returns:

jr

public static Runnable jr(Runnable runnable)

Parameters:

runnable -

Returns:

jc

public static <R> Callable<R> jc(Callable<R> callable)

Type Parameters:

R -

Parameters:

callable -

Returns:

r2c

public static Callable<Void> r2c(Runnable runnable)

Parameters:

runnable -

Returns:

r2c

public static <R> Callable<R> r2c(Runnable runnable,
 R valueToReturn)

Type Parameters:

R -

Parameters:

runnable -

valueToReturn -

Returns:

c2r

public static <R> Runnable c2r(Callable<R> callable)

Type Parameters:

R -

Parameters:

callable -

Returns:

jr2r

public static Runnable jr2r(Runnable runnable)

Parameters:

runnable -

Returns:

jc2c

public static <R> Callable<R> jc2c(Callable<R> callable)

Type Parameters:

R -

Parameters:

callable -

Returns:

jc2r

public static Runnable jc2r(Callable<?> callable)

Parameters:

callable -

Returns:

throwingMerger

public static <T> BinaryOperator<T> throwingMerger()

Type Parameters:

T -

Returns:

ignoringMerger

public static <T> BinaryOperator<T> ignoringMerger()

Type Parameters:

T -

Returns:

replacingMerger

public static <T> BinaryOperator<T> replacingMerger()

Type Parameters:

T -

Returns:

getIfPresentOrElseNull

public static <T>
Function<u.Optional<? extends T>,T> getIfPresentOrElseNull()

Type Parameters:

T -

Returns:

getIfPresentOrElseNullJdk

public static <T> Function<Optional<? extends T>,T> getIfPresentOrElseNullJdk()

Type Parameters:

T -

Returns:

isPresent

public static <T>
Predicate<u.Optional<? extends T>> isPresent()

Type Parameters:

T -

Returns:

isPresentJdk

public static <T> Predicate<Optional<? extends T>> isPresentJdk()

Type Parameters:

T -

Returns:

switchOnNext

@Beta
@SequentialOnly
@Stateful
public static <T> BiFunction<T,T,MergeResult> switchOnNext()

Returns a stateful BiFunction. Don't save or cache for reuse or use it in parallel stream.

Type Parameters:

T -

Returns: