类的使用
com.jn.langx.annotation.NonNull

使用NonNull的程序包

程序包	说明
com.jn.langx.cache
com.jn.langx.configuration
com.jn.langx.io.resource
com.jn.langx.text
com.jn.langx.text.i18n
com.jn.langx.text.properties
com.jn.langx.util	This package contain all most utility classes for java coding
com.jn.langx.util.bloom	Bloom Filter
com.jn.langx.util.collection	many collection utility class
com.jn.langx.util.collection.iter
com.jn.langx.util.enums
com.jn.langx.util.function
com.jn.langx.util.io
com.jn.langx.util.io.file
com.jn.langx.util.io.file.filter
com.jn.langx.util.jodatime	Provides support for dates, times, time zones, durations, intervals, and partials.
com.jn.langx.util.net
com.jn.langx.util.reflect
com.jn.langx.util.reflect.type

com.jn.langx.cache中NonNull的使用

注释类型为NonNull的com.jn.langx.cache中的方法参数

限定符和类型	方法和说明
V	Cache.get(K key)
V	AbstractCache.get(K key)
V	Cache.get(K key, Supplier<K,V> loader)
V	AbstractCache.get(K key, Supplier<K,V> loader)
Map<K,V>	Cache.getAll(Iterable<K> keys)
Map<K,V>	Cache.getAllIfPresent(Iterable<K> keys)
V	Cache.getIfPresent(K key)
V	AbstractCache.getIfPresent(K key)
void	Cache.refresh(K key)
void	AbstractCache.refresh(K key)
V	Cache.remove(K key)
V	AbstractCache.remove(K key)
protected V	AbstractCache.remove(K key, RemoveCause cause)
protected V	AbstractCache.remove(K key, RemoveCause cause)
void	Cache.set(K key, V value)
void	AbstractCache.set(K key, V value)
void	Cache.set(K key, V value, long expire)
void	AbstractCache.set(K key, V value, long expire)
void	Cache.set(K key, V value, long expire, TimeUnit timeUnit)
void	AbstractCache.set(K key, V value, long duration, TimeUnit timeUnit)

com.jn.langx.configuration中NonNull的使用

注释类型为NonNull的com.jn.langx.configuration中的字段

限定符和类型	字段和说明
protected Loader	AbstractConfigurationRepository.loader
protected String	AbstractConfigurationRepository.name

com.jn.langx.io.resource中NonNull的使用

注释类型为NonNull的com.jn.langx.io.resource中的方法参数

限定符和类型	方法和说明
static ByteArrayResource	Resources.asByteArrayResource(byte[] byteArray)
static ByteArrayResource	Resources.asByteArrayResource(byte[] byteArray, String description)
static InputStreamResource	Resources.asInputStreamResource(InputStream inputStream)
static InputStreamResource	Resources.asInputStreamResource(InputStream inputStream, String description)
static ClassPathResource	Resources.loadClassPathResource(String location)
static ClassPathResource	Resources.loadClassPathResource(String location, Class clazz)
static ClassPathResource	Resources.loadClassPathResource(String location, ClassLoader classLoader)
static FileResource	Resources.loadFileResource(String location)
static FileResource	Resources.loadFileResource(String location, ClassLoader classLoader)
static <V extends Resource> V	Resources.loadResource(String location)
static <V extends Resource> V	Resources.loadResource(String location, ClassLoader classLoader)
static UrlResource	Resources.loadUrlResource(String location)
static UrlResource	Resources.loadUrlResource(String location, ClassLoader classLoader)
static UrlResource	Resources.loadUrlResource(URL url)
static void	Resources.readLines(String location, Charset charset, Consumer<String> consumer)
static void	Resources.readLines(String location, Charset charset, Consumer<String> consumer)
static void	Resources.readLines(String location, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(byte[] byteArray, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(byte[] byteArray, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(byte[] byteArray, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(byte[] byteArray, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(Resource resource, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(Resource resource, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(Resource resource, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(Resource resource, String delimiter, Consumer<byte[]> consumer)
static void	Resources.readUsingDelimiter(Resource resource, String delimiter, Consumer<byte[]> consumer)
static void	Resources.readUsingDelimiter(String location, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(String location, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(String location, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(String location, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(URL url, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(URL url, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(URL url, String delimiter, Charset charset, Consumer<String> consumer)
static void	Resources.readUsingDelimiter(URL url, String delimiter, Charset charset, Consumer<String> consumer)

注释类型为NonNull的com.jn.langx.io.resource中的构造器参数

构造器和说明
FileResource(String path)

com.jn.langx.text中NonNull的使用

注释类型为NonNull的com.jn.langx.text中的方法参数

限定符和类型	方法和说明
static Supplier<Object[],String>	StringTemplates.mapStyleSupplier(String template)
static Supplier<Object[],String>	StringTemplates.mapStyleSupplier(String template, MapBasedStringFormatter.PatternStyle patternStyle)

注释类型为NonNull的com.jn.langx.text中的构造器参数

构造器和说明
HttpQueryStringAccessor(String url)

com.jn.langx.text.i18n中NonNull的使用

注释类型为NonNull的com.jn.langx.text.i18n中的方法

限定符和类型	方法和说明
Locale	I18nMessageRegistry.getLocale()
Locale	DefaultI18nMessageRegistry.getLocale()

注释类型为NonNull的com.jn.langx.text.i18n中的方法参数

限定符和类型	方法和说明
void	I18nMessageRegistry.setLocal(Locale locale)
void	DefaultI18nMessageRegistry.setLocale(Locale locale)

com.jn.langx.text.properties中NonNull的使用

注释类型为NonNull的com.jn.langx.text.properties中的构造器参数

构造器和说明
PropertiesAccessor(Properties properties)

com.jn.langx.util中NonNull的使用

注释类型为NonNull的com.jn.langx.util中的方法

限定符和类型	方法和说明
static DataSize	DataSize.bytes(long bytes)
static DataSize	DataSize.gb(long gb)
static DataSize	DataSize.kb(long kb)
static DataSize	DataSize.mb(long mb)
static DataSize	DataSize.of(long bytes)
static DataSize	DataSize.tb(long tb)
String	DataSize.toString()
static DataSize	DataSize.valueOf(String string)

注释类型为NonNull的com.jn.langx.util中的方法参数

限定符和类型	方法和说明
static void	Calendars.addField(Calendar calendar, Calendars.DateField field, int value) add specified field, may be change other fields
static void	Calendars.addField(Calendar calendar, Calendars.DateField field, int value) add specified field, may be change other fields
static <T> T	Preconditions.checkNotEmpty(T obj, String errorMessage)
static <T> T	Preconditions.checkNotEmpty(T obj, Supplier<Object[],String> errorMessageSupplier, Object... params)
static <T> T	Preconditions.checkNotNull(T obj)
static <T> T	Preconditions.checkNotNull(T obj, String errorMessage)
static <T> T	Preconditions.checkNotNull(T obj, Supplier<Object[],String> errorMessageSupplier, Object... params)
static <I,O> O	ClassLoaders.doAction(ClassLoader threadContextClassLoader, Function<I,O> action, I input)
static <I,O> O	ClassLoaders.doAction(ClassLoader threadContextClassLoader, Function<I,O> action, I input)
static String	Dates.format(Date date, String pattern)
static String	Dates.format(Date date, String pattern)
static String	Dates.format(long millis, String pattern)
static int	Dates.get(Date date, Calendars.DateField field)
static int	Calendars.getDays(Calendar calendar)
static int	Dates.getDays(Date date)
static int	Calendars.getField(Calendar calendar, Calendars.DateField field)
static int	Calendars.getField(Calendar calendar, Calendars.DateField field)
static int	Calendars.getHours(Calendar calendar)
static int	Dates.getHours(Date date)
static int	Calendars.getMillis(Calendar calendar)
static int	Dates.getMillis(Date date)
static int	Calendars.getMinutes(Calendar calendar)
static int	Dates.getMinutes(Date date)
static int	Calendars.getMonths(Calendar calendar)
static int	Calendars.getMonths(Calendar calendar, boolean actual)
static int	Dates.getMonths(Date date)
static int	Dates.getMonths(Date date, boolean getActualMonth)
static int	Calendars.getSeconds(Calendar calendar)
static int	Dates.getSeconds(Date date)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, Locale locale)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, String timeZoneId)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, String timeZoneId)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, String timeZoneId, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, String timeZoneId, Locale locale)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, TimeZone timeZone)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, TimeZone timeZone)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, TimeZone timeZone, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, TimeZone timeZone, Locale locale)
static int	Calendars.getYears(Calendar calendar)
static int	Dates.getYears(Date date)
static <I,O> O	Throwables.ignoreExceptions(org.slf4j.Logger logger, O valueIfError, List<Class<Throwable>> throwables, ThrowableFunction<I,O> func, I input)
static <I,O> O	Throwables.ignoreExceptions(org.slf4j.Logger logger, O valueIfError, List<Class<Throwable>> throwables, ThrowableFunction<I,O> func, I input)
static <I1,I2,O> O	Throwables.ignoreExceptions(org.slf4j.Logger logger, O valueIfError, List<Class<Throwable>> throwables, ThrowableFunction2<I1,I2,O> func, I1 input1, I2 input2)
static <I1,I2,O> O	Throwables.ignoreExceptions(org.slf4j.Logger logger, O valueIfError, List<Class<Throwable>> throwables, ThrowableFunction2<I1,I2,O> func, I1 input1, I2 input2)
static <I,O> O	Throwables.ignoreThrowable(org.slf4j.Logger logger, O valueIfError, ThrowableFunction<I,O> func, I input)
static <I1,I2,O> O	Throwables.ignoreThrowable(org.slf4j.Logger logger, O valueIfError, ThrowableFunction2<I1,I2,O> func, I1 input1, I2 input2)
static String	Strings.insert(String string, List<Integer> slotIndexes, String insertment)
static String	Strings.insert(String string, List<Integer> slotIndexes, String insertment)
static String	Strings.join(String separator, Byte[] objects)
static String	Strings.join(String separator, Character[] objects)
static String	Strings.join(String separator, Double[] objects)
static String	Strings.join(String separator, Float[] objects)
static String	Strings.join(String separator, Integer[] objects)
static String	Strings.join(String separator, Iterable objects)
static String	Strings.join(String separator, Iterator objects) append all objects with the specified separator
static String	Strings.join(String separator, Long[] objects)
static String	Strings.join(String separator, Object[] objects)
static String	Strings.join(String separator, Short[] objects)
static String	Strings.join(String separator, String[] objects)
static Class	ClassLoaders.loadClass(String className)
static Class	ClassLoaders.loadClass(String className, Class basedClass)
static Class	ClassLoaders.loadClass(String className, ClassLoader classLoader)
static Class	ClassLoaders.loadImplClass(String className, ClassLoader classLoader, Class superClass)
static void	Throwables.log(org.slf4j.Logger logger, org.slf4j.event.Level level, String message, Throwable ex)
static void	Throwables.log(Throwable ex)
static void	Calendars.rollField(Calendar calendar, Calendars.DateField field, int value) Just roll specified field, will not change other fields
static void	Calendars.rollField(Calendar calendar, Calendars.DateField field, int value) Just roll specified field, will not change other fields
static void	Calendars.setDays(Calendar calendar, int year)
static void	Calendars.setField(Calendar calendar, Calendars.DateField field, int value)
static void	Calendars.setField(Calendar calendar, Calendars.DateField field, int value)
static void	Calendars.setHours(Calendar calendar, int year)
static void	Calendars.setMillis(Calendar calendar, int millis)
static void	Calendars.setMinutes(Calendar calendar, int year)
static void	Calendars.setMonths(Calendar calendar, int month)
static void	Calendars.setMonths(Calendar calendar, int month, boolean valueIsActual)
static void	Calendars.setSeconds(Calendar calendar, int year)
void	BasedStringAccessor.setTarget(T target)
static void	Calendars.setYears(Calendar calendar, int year)
static <T> T	Preconditions.test(Predicate<T> predicate, T argument)
static <T> T	Preconditions.test(Predicate<T> predicate, T argument, String message)
static <T> T	Preconditions.test(Predicate<T> predicate, T argument, Supplier<Object[],String> messageSupplier, Object... params)
static DataSize	DataSize.valueOf(String string)

com.jn.langx.util.bloom中NonNull的使用

注释类型为NonNull的com.jn.langx.util.bloom中的方法参数

限定符和类型	方法和说明
void	RetouchedBloomFilter.add(Key key)
void	DynamicBloomFilter.add(Key key)
void	RetouchedBloomFilter.addFalsePositive(Collection<Key> coll) Adds a collection of false positive information to this retouched Bloom filter.
void	RetouchedBloomFilter.addFalsePositive(Key key) Adds a false positive information to this retouched Bloom filter.
void	RetouchedBloomFilter.addFalsePositive(Key[] keys) Adds an array of false positive information to this retouched Bloom filter.
void	RetouchedBloomFilter.addFalsePositive(List<Key> keys) Adds a list of false positive information to this retouched Bloom filter.
boolean	BloomFilter.membershipTest(Key key)
void	RetouchedBloomFilter.selectiveClearing(Key k, short scheme) Performs the selective clearing for a given key.

com.jn.langx.util.collection中NonNull的使用

注释类型为NonNull的com.jn.langx.util.collection中的方法参数

限定符和类型	方法和说明
static <E,C extends Collection<E>> void	Collects.addAll(C collection, E... iterator)
static <E,C extends Collection<E>> void	Collects.addAll(C collection, Iterable<E> iterable)
static <E,C extends Collection<E>> void	Collects.addAll(C collection, Iterator<E> iterator)
<C extends Collection<E>> void	Pipeline.addTo(C collection)
static <E,C extends Collection<E>> boolean	Collects.allMatch(C collection, Predicate<E> predicate) whether all elements match the specified condition or not
static <K,V,M extends Map<? extends K,? extends V>> boolean	Collects.allMatch(M map, Predicate2<K,V> predicate) whether all elements match the specified condition or not
boolean	Pipeline.allMatch(Predicate<E> predicate)
static <E,C extends Collection<E>> boolean	Collects.anyMatch(C collection, Predicate<E> predicate) has any element match the specified condition
static <K,V,M extends Map<? extends K,? extends V>> boolean	Collects.anyMatch(M map, Predicate2<K,V> predicate) has any element match the specified condition
boolean	Pipeline.anyMatch(Predicate<E> predicate)
static <E> Collection<E>	Collects.collect(Object anyObject, Collection<E> container)
static <E,R> R	Collects.collect(Object anyObject, Collector<E,R> collector)
static <E,R> R	Collects.collect(Object anyObject, Supplier0<R> containerFactory, Consumer2<R,E> consumer)
static <E,R> R	Collects.collect(Object anyObject, Supplier0<R> containerFactory, Consumer2<R,E> consumer)
static <E> E[]	Arrs.createArray(Class<E> componentType, int length, Supplier<Integer,E> initSupplier) Create an array with the specified length and every element's value is supplied by the specified initSupplier
static <X,Y,E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(X oldObject, Function<X,E> oldMapper, Y newObject, Function<Y,E> newMapper)
static <X,Y,E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(X oldObject, Function<X,E> oldMapper, Y newObject, Function<Y,E> newMapper)
static <X,Y,E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(X oldObject, Function<X,E> oldMapper, Y newObject, Function<Y,E> newMapper, Comparator<E> elementComparator)
static <X,Y,E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(X oldObject, Function<X,E> oldMapper, Y newObject, Function<Y,E> newMapper, Comparator<E> elementComparator)
static <X,Y,E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(X oldObject, Function<X,E> oldMapper, Y newObject, Function<Y,E> newMapper, Comparator<E> elementComparator, KeyBuilder<String,E> keyBuilder)
static <X,Y,E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(X oldObject, Function<X,E> oldMapper, Y newObject, Function<Y,E> newMapper, Comparator<E> elementComparator, KeyBuilder<String,E> keyBuilder)
static <K,V> NonAbsentHashMap<K,V>	Collects.emptyNonAbsentHashMap(Supplier<K,V> supplier)
static <K,V> Map<K,V>	Collects.filter(Map<K,V> map, Predicate2<K,V> predicate) Filter a map with the specified predicate
static <E> Collection<E>	Collects.filter(Object anyObject, Predicate<E> predicate) Filter any object with the specified predicate
static <E> Collection<E>	Collects.filter(Object anyObject, Predicate<E> predicate, Predicate<E> breakPredicate) Filter any object with the specified predicate
E	Pipeline.findFirst(Predicate<E> predicate)
Pipeline<E>	Pipeline.findN(Predicate<E> predicate, int n)
static <E,R,C extends Collection<? extends Iterable<E>>> Collection<R>	Collects.flatMap(C collection, Function<E,R> mapper) map a collection to another, flat it
static <E,R> Collection<R>	Collects.flatMap(Function<E,R> mapper, Collection<E[]> collection) map a collection to another, flat it
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Consumer<E> consumer)
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Consumer<E> consumer, Predicate<E> breakPredicate)
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Consumer2<Integer,E> consumer) Iterate every element
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate) Iterate every element
void	Pipeline.forEach(Consumer<E> consumer)
void	Pipeline.forEach(Consumer<E> consumer, Predicate<E> breakPredicate)
void	Pipeline.forEach(Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate)
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Predicate<E> consumePredicate, Consumer<E> consumer)
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Predicate<E> consumePredicate, Consumer<E> consumer, Predicate<E> breakPredicate) Consume every element what matched the consumePredicate
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer) Consume every element what matched the consumePredicate
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate) Consume every element what matched the consumePredicate
static <E> void	Collects.forEach(E[] array, Consumer<E> consumer)
static <E> void	Collects.forEach(E[] array, Consumer2<Integer,E> consumer) Iterate every element
static <E> void	Collects.forEach(E[] array, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate) Iterate every element
static <E> void	Collects.forEach(E[] array, Predicate<E> consumePredicate, Consumer<E> consumer, Predicate<E> breakPredicate) consume every element that matched the consumePredicate
static <E> void	Collects.forEach(E[] array, Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer) consume every element that matched the consumePredicate
static <E> void	Collects.forEach(E[] array, Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate) consume every element that matched the consumePredicate
static <K,V,M extends Map<? extends K,? extends V>> void	Collects.forEach(M map, Consumer2<K,V> consumer) Iterate every element
static <K,V,M extends Map<? extends K,? extends V>> void	Collects.forEach(M map, Consumer2<K,V> consumer, Predicate2<K,V> breakPredicate) Iterate every element
static <K,V,M extends Map<? extends K,? extends V>> void	Collects.forEach(M map, Predicate2<K,V> consumePredicate, Consumer2<K,V> consumer) consume every element what matched the consumePredicate
static <K,V,M extends Map<? extends K,? extends V>> void	Collects.forEach(M map, Predicate2<K,V> consumePredicate, Consumer2<K,V> consumer, Predicate2<K,V> breakPredicate) consume every element what matched the consumePredicate
void	Pipeline.forEach(Predicate<E> consumePredicate, Consumer<E> consumer, Predicate<E> breakPredicate)
void	Pipeline.forEach(Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer)
void	Pipeline.forEach(Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate)
static <K,E,C extends Collection<E>> Map<K,List<E>>	Collects.groupBy(C iterable, Function<E,K> classifier)
static <K,E> Map<K,List<E>>	Collects.groupBy(E[] iterable, Function<E,K> classifier)
static <K,E> Map<K,List<E>>	Collects.groupBy(E[] iterable, Function<E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
static <K,E,C extends Collection<E>> Map<K,List<E>>	Collects.groupBy(Iterable<E> iterable, Function<E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
static <E,K> Collector<E,Map<K,List<E>>>	Collects.groupingBy(Function<E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
static <E,K> Collector<E,Map<K,List<E>>>	Collects.groupingBy(Function<E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
static <E,K> Collector<E,Map<K,List<E>>>	Collects.groupingBy(Function2<Integer,E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
static <E,K> Collector<E,Map<K,List<E>>>	Collects.groupingBy(Function2<Integer,E,K> classifier, Supplier0<Map<K,List<E>>> mapFactory)
static <E> void	Arrs.initArray(E[] array, E initValue)
static <E> void	Arrs.initArray(E[] array, Supplier<Integer,E> initSupplier)
static <E> void	Arrs.initArray(E[] array, Supplier<Integer,E> initSupplier)
static <K,V,R,M extends Map<K,V>> List<R>	Collects.map(M map, Function2<K,V,R> mapper) mapping aMap to a list
static <K,V,K1,V1,M extends Map<K,V>> Map<K1,V1>	Collects.map(M map, Mapper2<K,V,Pair<K1,V1>> mapper) mapping aMap to bMap
static <E,R> Collection<R>	Collects.map(Object anyObject, Function<E,R> mapper) mapping an iterable to a list
static <E,K,V,M extends Map<K,V>> M	Collects.map(Object anyObject, Mapper<E,Pair<K,V>> mapper) mapping an iterable to a map
static <E> E	Collects.max(Object object, Comparator<E> comparator)
static <E> E	Collects.max(Object object, Comparator<E> comparator)
static <E> E	Collects.min(Object object, Comparator<E> comparator)
static <E,C extends Collection<E>> boolean	Collects.noneMatch(C collection, Predicate<E> predicate) has no any element match the specified condition ?
static <K,V,M extends Map<? extends K,? extends V>> boolean	Collects.noneMatch(M map, Predicate2<K,V> predicate) has no any element match the specified condition ?
boolean	Pipeline.noneMatch(Predicate<E> predicate)
static <E,K> Collector<E,Map<K,List<E>>>	Collects.partioningBy(Function<E,K> classifier)
static <E,K> Collector<E,Map<K,List<E>>>	Collects.partioningBy(Function2<Integer,E,K> classifier)
static <E,C extends Collection<E>> boolean	Collects.removeIf(C collection, Predicate<E> predicate) remove all elements that match the condition
static <E> boolean	Collects.removeIf(Iterator<E> iterator, Predicate<E> predicate)
static <K,V> boolean	Collects.removeIf(Map<K,V> map, Predicate2<K,V> predicate) remove all elements that match the map
static <E> void	Collects.shuffle(List<E> list) Randomly permutes the specified list using a default source of randomness.
static <E> void	Collects.shuffle(List<E> list, Random rnd) Randomly permute the specified list using the specified source of randomness.
static <E> void	Collects.shuffle(List<E> list, Random rnd) Randomly permute the specified list using the specified source of randomness.
static <E,C extends Collection<E>> TreeSet<E>	Collects.sort(C collection, Comparator<E> comparator) sort a collection, return an new list. it is different to Collections.sort(list) is that : Collections.sort() return void
static <E,C extends Collection<E>> TreeSet<E>	Collects.sort(C collection, Comparator<E> comparator, boolean reverse) sort a collection, return an new list. it is different to Collections.sort(list) is that : Collections.sort() return void
Pipeline<E>	Pipeline.sort(Comparator<E> comparator)
static <K,V,M extends Map<K,V>> M	Collects.sort(M map, Comparator<K> comparator) sort a collection, return an new list. it is different to Collections.sort(list) is that : Collections.sort() return void
Pipeline<E>	Pipeline.sorted(Comparator<E> comparator)
V	LinkedCaseInsensitiveMap.supplyIfAbsent(String key, Supplier<? super String,? extends V> supplier)
static <E> void	Collects.swap(E[] arr, int i, int j) Swaps the two specified elements in the specified array.
static <E> void	Arrs.swap(E[] arr, int i, int j) Swaps the two specified elements in the specified array.
static <E> void	Collects.swap(List<E> list, int i, int j) Swaps the elements at the specified positions in the specified list.
static <E,K,V> Collector<E,Map<K,V>>	Collects.toHashMap(Function<E,K> keyMapper, Function<E,V> valueMapper, boolean sequential)
static <E,K,V> Collector<E,Map<K,V>>	Collects.toHashMap(Function<E,K> keyMapper, Function<E,V> valueMapper, boolean sequential)
static <E,K,V> Collector<E,Map<K,V>>	Collects.toMap(Supplier0<Map<K,V>> mapFactory, Function<E,K> keyMapper, Function<E,V> valueMapper)
static <E,K,V> Collector<E,Map<K,V>>	Collects.toMap(Supplier0<Map<K,V>> mapFactory, Function<E,K> keyMapper, Function<E,V> valueMapper)
static <E,K,V> Collector<E,Map<K,V>>	Collects.toMap(Supplier0<Map<K,V>> mapFactory, Function<E,K> keyMapper, Function<E,V> valueMapper)
static <E,K,V> Collector<E,Map<K,V>>	Collects.toTreeMap(Function<E,K> keyMapper, Function<E,V> valueMapper, Comparator<K> comparator)
static <E,K,V> Collector<E,Map<K,V>>	Collects.toTreeMap(Function<E,K> keyMapper, Function<E,V> valueMapper, Comparator<K> comparator)
static <K,V> WrappedNonAbsentMap<K,V>	Collects.wrapAsNonAbsentMap(Map<K,V> map, Supplier<K,V> supplier)
static <K,V> WrappedNonAbsentMap<K,V>	Collects.wrapAsNonAbsentMap(Map<K,V> map, Supplier<K,V> supplier)

注释类型为NonNull的com.jn.langx.util.collection中的构造器参数

构造器和说明
NonAbsentHashMap(int initialCapacity, float loadFactor, Supplier<K,V> supplier)
NonAbsentHashMap(Supplier<K,V> supplier)
NonAbsentTreeMap(Comparator<? super K> comparator, Supplier<K,V> supplier)
NonAbsentTreeMap(Map<? extends K,? extends V> m, Supplier<K,V> supplier)
NonAbsentTreeMap(SortedMap<K,? extends V> m, Supplier<K,V> supplier)
NonAbsentTreeMap(Supplier<K,V> supplier)
StringMapAccessor(StringMap target)
WrappedNonAbsentMap(Map<K,V> map, Supplier<K,V> supplier)
WrappedNonAbsentMap(Map<K,V> map, Supplier<K,V> supplier)

com.jn.langx.util.collection.iter中NonNull的使用

注释类型为NonNull的com.jn.langx.util.collection.iter中的构造器参数

构造器和说明
IteratorIterable(Iterator<E> iterator)
IteratorIterable(Iterator<E> iterator, boolean removable)
WrappedIterable(Iterable<E> delegate, boolean mutable)
WrappedIterator(Iterator<E> delegate, boolean mutable)

com.jn.langx.util.enums中NonNull的使用

注释类型为NonNull的com.jn.langx.util.enums中的方法参数

限定符和类型	方法和说明
static <T extends Enum<T>> T	Enums.ofCode(Class<T> tClass, int code)
static <T extends Enum<T>> T	Enums.ofDisplayText(Class<T> tClass, String displayText)
static <T extends Enum<T>> T	Enums.ofName(Class<T> tClass, String name)

com.jn.langx.util.function中NonNull的使用

注释类型为NonNull的com.jn.langx.util.function中的方法参数

限定符和类型	方法和说明
static <E> Predicate<E>	Functions.allPredicate(Predicate<E>... predicates)
static <E> Predicate<E>	Functions.andPredicate(Predicate<E>... predicates)
static <E> Predicate<E>	Functions.anyPredicate(Predicate<E>... predicates)
static <E> Predicate<E>	Functions.orPredicate(Predicate<E>... predicates)

com.jn.langx.util.io中NonNull的使用

注释类型为NonNull的com.jn.langx.util.io中的方法参数

限定符和类型	方法和说明
static CharsetDecoder	Charsets.decoder(Charset charset) Returns a cached thread-local CharsetDecoder for the specified Charset.
static CharsetDecoder	Charsets.decoder(Charset charset, CodingErrorAction codingErrorAction) Returns a new CharsetDecoder for the Charset with the specified error action.
static CharsetDecoder	Charsets.decoder(Charset charset, CodingErrorAction codingErrorAction) Returns a new CharsetDecoder for the Charset with the specified error action.
static CharsetDecoder	Charsets.decoder(Charset charset, CodingErrorAction malformedInputAction, CodingErrorAction unmappableCharacterAction) Returns a new CharsetDecoder for the Charset with specified error actions.
static CharsetDecoder	Charsets.decoder(Charset charset, CodingErrorAction malformedInputAction, CodingErrorAction unmappableCharacterAction) Returns a new CharsetDecoder for the Charset with specified error actions.
static CharsetDecoder	Charsets.decoder(Charset charset, CodingErrorAction malformedInputAction, CodingErrorAction unmappableCharacterAction) Returns a new CharsetDecoder for the Charset with specified error actions.
static CharsetEncoder	Charsets.encoder(Charset charset) Returns a cached thread-local CharsetEncoder for the specified Charset.
static CharsetEncoder	Charsets.encoder(Charset charset, CodingErrorAction codingErrorAction) Returns a new CharsetEncoder for the Charset with the specified error action.
static CharsetEncoder	Charsets.encoder(Charset charset, CodingErrorAction codingErrorAction) Returns a new CharsetEncoder for the Charset with the specified error action.
static CharsetEncoder	Charsets.encoder(Charset charset, CodingErrorAction malformedInputAction, CodingErrorAction unmappableCharacterAction) Returns a new CharsetEncoder for the Charset with specified error actions.
static CharsetEncoder	Charsets.encoder(Charset charset, CodingErrorAction malformedInputAction, CodingErrorAction unmappableCharacterAction) Returns a new CharsetEncoder for the Charset with specified error actions.
static CharsetEncoder	Charsets.encoder(Charset charset, CodingErrorAction malformedInputAction, CodingErrorAction unmappableCharacterAction) Returns a new CharsetEncoder for the Charset with specified error actions.
static void	Channels.readLines(InputStream inputStream, Charset charset, Consumer<String> consumer)
static void	Channels.readLines(InputStream inputStream, Charset charset, Consumer<String> consumer)
static void	Channels.readLines(InputStream inputStream, Charset charset, Consumer<String> consumer)
static void	Channels.readLines(InputStream inputStream, Consumer<String> consumer)
static void	Channels.readLines(InputStream inputStream, Consumer<String> consumer)
static void	Channels.readLines(ReadableByteChannel channel, Charset charset, Consumer<String> consumer)
static void	Channels.readLines(ReadableByteChannel channel, Charset charset, Consumer<String> consumer)
static void	Channels.readLines(ReadableByteChannel channel, Charset charset, Consumer<String> consumer)
static void	Channels.readLines(ReadableByteChannel channel, Consumer<String> consumer)
static void	Channels.readLines(ReadableByteChannel channel, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Consumer<byte[]> consumer)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Consumer<byte[]> consumer)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Consumer<byte[]> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Charset charset, Consumer<String> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Consumer<byte[]> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Consumer<byte[]> consumer)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Consumer<byte[]> consumer)

注释类型为NonNull的com.jn.langx.util.io中的构造器参数

构造器和说明
LineDelimiter(String delimiter)
LineIterator(Reader reader) Constructs an iterator of the lines for a Reader.

com.jn.langx.util.io.file中NonNull的使用

注释类型为NonNull的com.jn.langx.util.io.file中的方法参数

限定符和类型	方法和说明
static FileFilter	FileFilters.allFileFilter(List<? extends FileFilter> predicates)
static FileFilter	FileFilters.anyFileFilter(List<? extends FileFilter> predicates)

com.jn.langx.util.io.file.filter中NonNull的使用

注释类型为NonNull的com.jn.langx.util.io.file.filter中的构造器参数

构造器和说明
PatternFilenameFilter(Pattern pattern)
PatternFilenameFilter(String pattern)

com.jn.langx.util.jodatime中NonNull的使用

注释类型为NonNull的com.jn.langx.util.jodatime中的方法参数

限定符和类型	方法和说明
static YearMonth	YearMonth.now(Chronology chronology) Obtains a YearMonth set to the current system millisecond time using the specified chronology.
static LocalDateTime	LocalDateTime.now(Chronology chronology) Obtains a LocalDateTime set to the current system millisecond time using the specified chronology.
static YearMonth	YearMonth.now(DateTimeZone zone) Obtains a YearMonth set to the current system millisecond time using ISOChronology in the specified time zone.

com.jn.langx.util.net中NonNull的使用

注释类型为NonNull的com.jn.langx.util.net中的方法参数

限定符和类型	方法和说明
static URL	URLs.newURL(String url)

com.jn.langx.util.reflect中NonNull的使用

注释类型为NonNull的com.jn.langx.util.reflect中的方法参数

限定符和类型	方法和说明
static Collection<Field>	Reflects.filterFields(Field[] fields, int... excludedModifiers)
static Collection<Field>	Reflects.getAllDeclaredFields(Class clazz)
static Collection<Field>	Reflects.getAllDeclaredFields(Class clazz, boolean containsStatic)
static Collection<Field>	Reflects.getAllPublicFields(Class clazz, boolean containsStatic)
static Collection<Field>	Reflects.getAllPublicInstanceFields(Class clazz)
static <E extends Annotation> E	Reflects.getAnnotation(AnnotatedElement annotatedElement, Class<E> annotationClass) Returns this element's annotation for the specified type if such an annotation is present, else null.
static <E extends Annotation> E	Reflects.getAnnotation(AnnotatedElement annotatedElement, Class<E> annotationClass) Returns this element's annotation for the specified type if such an annotation is present, else null.
static Annotation[]	Reflects.getAnnotations(AnnotatedElement annotatedElement) Returns all annotations present on this element.
static Field	Reflects.getAnyField(Class clazz, String fieldName)
static Field	Reflects.getAnyField(Class clazz, String fieldName)
static <V> V	Reflects.getAnyFieldValue(Object object, String fieldName, boolean force, boolean throwException)
static <V> V	Reflects.getAnyFieldValue(Object object, String fieldName, boolean force, boolean throwException)
static <V> V	Reflects.getAnyFieldValueForcedIfPresent(Object object, String fieldName)
static <V> V	Reflects.getAnyFieldValueForcedIfPresent(Object object, String fieldName)
static Method	Reflects.getAnyMethod(Class clazz, String methodName, Class... parameterTypes)
static Method	Reflects.getAnyMethod(Class clazz, String methodName, Class... parameterTypes)
static URL	Reflects.getCodeLocation(Class clazz)
static <E> Constructor<E>	Reflects.getConstructor(Class<E> clazz, Class... parameterTypes)
static <E extends Annotation> E	Reflects.getDeclaredAnnotation(AnnotatedElement annotatedElement, Class<E> annotationClass)
static <E extends Annotation> E	Reflects.getDeclaredAnnotation(AnnotatedElement annotatedElement, Class<E> annotationClass)
static List<Annotation>	Reflects.getDeclaredAnnotations(AnnotatedElement annotatedElement) Returns all annotations that are directly present on this element.
static Field	Reflects.getDeclaredField(Class clazz, String fieldName)
static Field	Reflects.getDeclaredField(Class clazz, String fieldName)
static <V> V	Reflects.getDeclaredFieldValue(Object object, String fieldName, boolean force, boolean throwException)
static <V> V	Reflects.getDeclaredFieldValueForcedIfPresent(Object object, String fieldName)
static <V> V	Reflects.getDeclaredFieldValueForcedIfPresent(Object object, String fieldName)
static Method	Reflects.getDeclaredMethod(Class clazz, String methodName, Class... parameterTypes)
static Method	Reflects.getDeclaredMethod(Class clazz, String methodName, Class... parameterTypes)
static <V> V	Reflects.getFieldValue(Field field, Object object, boolean force, boolean throwException)
static <V> V	Reflects.getFieldValue(Field field, Object object, boolean force, boolean throwException)
static String	Reflects.getFQNClassName(Class clazz)
static String	Reflects.getJvmSignature(Class clazz)
static String	Reflects.getMethodString(Class clazz, String methodName, Class[] parameterTypes)
static String	Reflects.getMethodString(Class clazz, String methodName, Class[] parameterTypes)
static String	Reflects.getMethodString(String clazzFQN, String methodName, Class returnType, Class[] parameterTypes)
static String	Reflects.getPackageName(Class clazz)
static Field	Reflects.getPublicField(Class clazz, String fieldName)
static Field	Reflects.getPublicField(Class clazz, String fieldName)
static <V> V	Reflects.getPublicFieldValue(Object object, String fieldName, boolean throwException)
static <V> V	Reflects.getPublicFieldValue(Object object, String fieldName, boolean throwException)
static <V> V	Reflects.getPublicFieldValueForcedIfPresent(Object object, String fieldName)
static <V> V	Reflects.getPublicFieldValueForcedIfPresent(Object object, String fieldName)
static Method	Reflects.getPublicMethod(Class clazz, String methodName, Class... parameterTypes)
static Method	Reflects.getPublicMethod(Class clazz, String methodName, Class... parameterTypes)
static String	Reflects.getSimpleClassName(Class clazz)
static String	Reflects.getSimpleClassName(Object obj)
static Field	Reflects.getStaticField(Class clazz, String fieldName)
static Field	Reflects.getStaticField(Class clazz, String fieldName)
static String	Reflects.getTypeName(Class type)
static Iterable<Class<?>>	Reflects.hierarchy(Class<?> type) Get an Iterable that can iterate over a class hierarchy in ascending (subclass to superclass) order, excluding interfaces.
static Iterable<Class<?>>	Reflects.hierarchy(Class<?> type, boolean excludeInterfaces) Get an Iterable that can iterate over a class hierarchy in ascending (subclass to superclass) order.
static <V> V	Reflects.invoke(Method method, Object object, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokeAnyMethod(Object object, String methodName, Class[] parameterTypes, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokeAnyMethod(Object object, String methodName, Class[] parameterTypes, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokeAnyMethodForcedIfPresent(Object object, String methodName, Class[] parameterTypes, Object[] parameters)
static <V> V	Reflects.invokeAnyMethodForcedIfPresent(Object object, String methodName, Class[] parameterTypes, Object[] parameters)
static <V> V	Reflects.invokeDeclaredMethod(Object object, String methodName, Class[] parameterTypes, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokeDeclaredMethod(Object object, String methodName, Class[] parameterTypes, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokeDeclaredMethodForcedIfPresent(Object object, String methodName, Class[] parameterTypes, Object[] parameters)
static <V> V	Reflects.invokeDeclaredMethodForcedIfPresent(Object object, String methodName, Class[] parameterTypes, Object[] parameters)
static <V> V	Reflects.invokePublicMethod(Object object, String methodName, Class[] parameterTypes, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokePublicMethod(Object object, String methodName, Class[] parameterTypes, Object[] parameters, boolean force, boolean throwException)
static <V> V	Reflects.invokePublicMethodForcedIfPresent(Object object, String methodName, Class[] parameterTypes, Object[] parameters)
static <V> V	Reflects.invokePublicMethodForcedIfPresent(Object object, String methodName, Class[] parameterTypes, Object[] parameters)
static boolean	Reflects.isAnnotationPresent(AnnotatedElement annotatedElement, Class<? extends Annotation> annotationClass) Returns true if an annotation for the specified type is present on this element, else false.
static boolean	Reflects.isAnnotationPresent(AnnotatedElement annotatedElement, Class<? extends Annotation> annotationClass) Returns true if an annotation for the specified type is present on this element, else false.
static boolean	Reflects.isAnonymous(Class clazz)
static boolean	Reflects.isAnonymousOrLocal(Class<?> clazz)
static boolean	Reflects.isConcrete(Class clazz)
static boolean	Reflects.isImplementsInterface(Class clazz, Class intf) Determine if the given class implements the given interface.
static boolean	Reflects.isImplementsInterface(Class clazz, Class intf) Determine if the given class implements the given interface.
static boolean	Reflects.isInnerClass(Class<?> clazz)
static boolean	Reflects.isLambda(Class<?> clazz)
static boolean	Reflects.isLocal(Class clazz)
static boolean	Reflects.isStatic(Class<?> clazz)
static boolean	Reflects.isSubClass(Class parent, Class child)
static boolean	Reflects.isSubClass(Class parent, Class child)
static boolean	Reflects.isSubClassOrEquals(Class parent, Class child)
static boolean	Reflects.isSubClassOrEquals(Class parent, Class child)
static boolean	Reflects.makeAccessible(Field field)
static <E> E	Reflects.newInstance(Class<E> clazz)
static <E> E	Reflects.newInstance(Class<E> clazz, Class[] parameterTypes, Object[] parameters)
static <E> E	Reflects.newInstance(Class<E> clazz, Class[] parameterTypes, Object[] parameters)
static void	Reflects.setAnyFieldValue(Object object, String fieldName, Object value, boolean force, boolean throwException)
static void	Reflects.setAnyFieldValue(Object object, String fieldName, Object value, boolean force, boolean throwException)
static void	Reflects.setDeclaredFieldValue(Object object, String fieldName, Object value, boolean force, boolean throwException)
static void	Reflects.setDeclaredFieldValue(Object object, String fieldName, Object value, boolean force, boolean throwException)
void	FieldComparator.setDelegate(Comparator delegate)
static void	Reflects.setFieldValue(Field field, Object target, Object value, boolean force, boolean throwException)
static void	Reflects.setFieldValue(Field field, Object target, Object value, boolean force, boolean throwException)
static void	Reflects.setPublicFieldValue(Object object, String fieldName, Object value, boolean force, boolean throwException)
static void	Reflects.setPublicFieldValue(Object object, String fieldName, Object value, boolean force, boolean throwException)
void	ArrayAccessor.setTarget(E target)

注释类型为NonNull的com.jn.langx.util.reflect中的构造器参数

构造器和说明
FieldAccessor(Object target)
FieldComparator(Class clazz, String fieldName, Comparator fieldComparator)
FieldComparator(Class clazz, String fieldName, Comparator fieldComparator)
FieldComparator(Field field, Comparator fieldComparator)

com.jn.langx.util.reflect.type中NonNull的使用

注释类型为NonNull的com.jn.langx.util.reflect.type中的方法参数

限定符和类型	方法和说明
static String	Types.getTypeSignature(String typeString) get the type's signature in jvm runtime