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

使用Nullable的程序包

程序包	说明
com.jn.langx
com.jn.langx.cache
com.jn.langx.configuration
com.jn.langx.escape
com.jn.langx.io.resource
com.jn.langx.security
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.collection	many collection utility class
com.jn.langx.util.collection.diff	Differ APIs
com.jn.langx.util.collection.iter
com.jn.langx.util.concurrent
com.jn.langx.util.concurrent.threadlocal
com.jn.langx.util.io
com.jn.langx.util.jar
com.jn.langx.util.mime
com.jn.langx.util.net
com.jn.langx.util.reflect
com.jn.langx.util.timing

com.jn.langx中Nullable的使用

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

限定符和类型	方法和说明
O	Parser.parse(I input)

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

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

限定符和类型	方法和说明
V	Cache.get(K key, Supplier<K,V> loader)
V	AbstractCache.get(K key, Supplier<K,V> loader)
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中Nullable的使用

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

限定符和类型	字段和说明
protected Writer	AbstractConfigurationRepository.writer

com.jn.langx.escape中Nullable的使用

注释类型为Nullable的com.jn.langx.escape中的方法参数

限定符和类型	方法和说明
Escapers.Builder	Escapers.Builder.setUnsafeReplacement(String unsafeReplacement) Sets the replacement string for any characters outside the 'safe' range that have no explicit replacement.

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

构造器和说明
ArrayBasedUnicodeEscaper(ArrayBasedEscaperMap escaperMap, int safeMin, int safeMax, String unsafeReplacement) Creates a new ArrayBasedUnicodeEscaper instance with the given replacement map and specified safe range.
ArrayBasedUnicodeEscaper(Map<Character,String> replacementMap, int safeMin, int safeMax, String unsafeReplacement) Creates a new ArrayBasedUnicodeEscaper instance with the given replacement map and specified safe range.

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

注释类型为Nullable的com.jn.langx.io.resource中的方法

限定符和类型	方法和说明
ClassLoader	ResourceLoader.getClassLoader() Expose the ClassLoader used by this ResourceLoader.

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

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

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

构造器和说明
ByteArrayResource(byte[] byteArray, String description) Create a new ByteArrayResource with a description.
ClassPathResource(String path, Class<?> clazz) Create a new ClassPathResource for Class usage.
ClassPathResource(String path, ClassLoader classLoader) Create a new ClassPathResource for ClassLoader usage.
DefaultResourceLoader(ClassLoader classLoader) Create a new DefaultResourceLoader.
InputStreamResource(InputStream inputStream, String description) Create a new InputStreamResource.

com.jn.langx.security中Nullable的使用

注释类型为Nullable的com.jn.langx.security中的方法参数

限定符和类型	方法和说明
static List<byte[]>	FileDigestGenerator.getFileDigest(String filePath, FileDigestGenerator.FileReader reader, List<MessageDigest> messageDigests)
static List<byte[]>	FileDigestGenerator.getFileDigest(String filePath, FileDigestGenerator.FileReader reader, MessageDigest... messageDigests)
static List<byte[]>	FileDigestGenerator.getFileDigest(String filePath, FileDigestGenerator.FileReader reader, String... algorithms)
static String	FileDigestGenerator.getFileDigest(String filePath, String algorithm, FileDigestGenerator.FileReader reader)
static List<String>	FileDigestGenerator.getFileDigestStrings(String filePath, FileDigestGenerator.FileReader reader, MessageDigest... messageDigests)
static List<String>	FileDigestGenerator.getFileDigestStrings(String filePath, FileDigestGenerator.FileReader reader, String... algorithms)

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

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

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

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

构造器和说明
MapBasedStringFormatter(MapBasedStringFormatter.PatternStyle patternStyle)

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

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

限定符和类型	方法和说明
protected ResourceBundle	DefaultI18nMessageRegistry.getBundle(String bundleName)
protected ResourceBundle	DefaultI18nMessageRegistry.getBundle(String bundleName, Locale locale)
protected ResourceBundle	DefaultI18nMessageRegistry.getBundle(String bundleName, Locale locale)
protected ResourceBundle	DefaultI18nMessageRegistry.getBundle(String bundleName, String languageHeader)
protected ResourceBundle	DefaultI18nMessageRegistry.getBundle(String bundleName, String languageHeader)

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

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

限定符和类型	方法和说明
protected String	PropertyPlaceholderHandler.parseStringValue(String value, PlaceholderParser placeholderResolver, Set<String> visitedPlaceholders)
static Map<String,String>	Props.toStringMap(Properties properties)
static Map<String,String>	Props.toStringMap(Properties properties, boolean sort)
static Map<String,String>	Props.toStringMap(Properties properties, Comparator<String> keyComparator)
static Map<String,String>	Props.toStringMap(Properties properties, Comparator<String> keyComparator)

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

构造器和说明
PropertyPlaceholderHandler(String placeholderPrefix, String placeholderSuffix, String valueSeparator, boolean ignoreUnresolvablePlaceholders) Creates a new PropertyPlaceholderHelper that uses the supplied prefix and suffix.

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

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

限定符和类型	方法和说明
T	Equivalence.Wrapper.get() Returns the (possibly null) reference wrapped by this instance.

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

限定符和类型	方法和说明
static <T> T	Preconditions.checkNotEmpty(T obj)
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, 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)
boolean	Equivalence.Wrapper.equals(Object obj) Returns true if Equivalence.equivalent(Object, Object) applied to the wrapped references is true and both wrappers use the same equivalence.
boolean	Equivalence.equivalent(T a, T b) Returns true if the given objects are considered equivalent.
boolean	Equivalence.equivalent(T a, T b) Returns true if the given objects are considered equivalent.
Predicate<T>	Equivalence.equivalentTo(T target) Returns a predicate that evaluates to true if and only if the input is equivalent to target according to this equivalence relation.
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, String timeZoneId)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, String timeZoneId, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, String timeZoneId, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, TimeZone timeZone)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, TimeZone timeZone, Locale locale)
static SimpleDateFormat	Dates.getSimpleDateFormat(String pattern, TimeZone timeZone, Locale locale)
int	Equivalence.hash(T t) Returns a hash code for t.
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 <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 <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 <I,O> O	Throwables.ignoreThrowable(org.slf4j.Logger logger, O valueIfError, ThrowableFunction<I,O> func, I input)
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 <I1,I2,O> O	Throwables.ignoreThrowable(org.slf4j.Logger logger, O valueIfError, ThrowableFunction2<I1,I2,O> func, I1 input1, I2 input2)
static <I1,I2,O> O	Throwables.ignoreThrowable(org.slf4j.Logger logger, O valueIfError, ThrowableFunction2<I1,I2,O> func, I1 input1, I2 input2)
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.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, 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(org.slf4j.Logger logger, org.slf4j.event.Level level, String message, Throwable ex)
static void	Throwables.log(org.slf4j.Logger logger, org.slf4j.event.Level level, String message, Throwable ex)
static <T extends Number> T	Numbers.parseNumber(String text, Class<T> targetClass, NumberFormat numberFormat) Parse the given text into a Number instance of the given target class, using the supplied NumberFormat.
static String[]	Strings.split(String string, String separator) split a string, the returned array is not contains: whitespace, null.
static String[]	Strings.split(String string, String separator) split a string, the returned array is not contains: whitespace, null.
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)
<S extends T> Equivalence.Wrapper<S>	Equivalence.wrap(S reference) Returns a wrapper of reference that implements Object.equals() such that wrap(a).equals(wrap(b)) if and only if equivalent(a, b).

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

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

限定符和类型	方法和说明
V	LinkedCaseInsensitiveMap.get(Object key)
V	LinkedCaseInsensitiveMap.getOrDefault(Object key, V defaultValue)
V	LinkedCaseInsensitiveMap.put(String key, V value)
V	LinkedCaseInsensitiveMap.putIfAbsent(String key, V value)
V	LinkedCaseInsensitiveMap.remove(Object key)
V	LinkedCaseInsensitiveMap.supplyIfAbsent(String key, Supplier<? super String,? extends V> supplier)

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

限定符和类型	方法和说明
<C extends Collection<E>> Pipeline<E>	Pipeline.addAll(C 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)
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
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
static <E> Collection<E>	Collects.asCollection(Iterable<E> iterable)
static <E> Iterable<E>	Collects.asIterable(Object object) Convert any object to an immutable Iterable
static <E> Iterable<E>	Collects.asIterable(Object object, boolean mutable) Convert any object to Iterable
static <E> List<E>	Collects.asList(E... array) Convert an array to a ArrayList
static <E> List<E>	Collects.asList(E[] array, boolean mutable, Collects.ListType listType) Convert an array to a List, if the 'mutable' argument is true, will return an unmodifiable List
static <E> List<E>	Collects.asList(E[] array, boolean mutable, Collects.ListType listType) Convert an array to a List, if the 'mutable' argument is true, will return an unmodifiable List
static <E> List<E>	Collects.asList(E[] array, Collects.ListType listType) Convert an array to a ArrayList or a LinkedList
static <E> List<E>	Collects.asList(E[] array, Collects.ListType listType) Convert an array to a ArrayList or a LinkedList
static <E> List<E>	Collects.asList(Iterable<E> iterable)
static <E> List<E>	Collects.asList(Iterable<E> iterable, boolean mutable)
static <E> Set<E>	Collects.asSet(E... array) Convert an array to a ArrayList
static <E> Set<E>	Collects.asSet(E[] array, boolean mutable, Collects.SetType setType) Convert an array to a List, if the 'mutable' argument is true, will return an unmodifiable List
static <E> Set<E>	Collects.asSet(E[] array, boolean mutable, Collects.SetType setType) Convert an array to a List, if the 'mutable' argument is true, will return an unmodifiable List
static <E> Set<E>	Collects.asSet(E[] array, Collects.SetType setType) Convert an array to a ArrayList or a LinkedList
static <E> Set<E>	Collects.asSet(E[] array, Collects.SetType setType) Convert an array to a ArrayList or a LinkedList
static <E> Set<E>	Collects.asSet(Iterable<E> iterable)
static <E> Set<E>	Collects.asSet(Iterable<E> iterable, boolean mutable)
static <E,C extends Collection<E>> C	Collects.clearNulls(C collection)
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,C extends Collection<E>> C	Collects.concat(C c1, C c2) Concat two collection to one
static <E,C extends Collection<E>> C	Collects.concat(C c1, C c2) Concat two collection to one
static <E,C extends Collection<E>> C	Collects.concat(C c1, C c2, boolean newOne) Concat two collection to one
static <E,C extends Collection<E>> C	Collects.concat(C c1, C c2, boolean newOne) Concat two collection to one
static <E,C extends Collection<E>> int	Collects.count(C collection)
static <K,V> int	Collects.count(Map<K,V> map)
static int	Collects.count(Object anyObject)
static <E> E[]	Arrs.createArray(Class<E> componentType, int length) Create an array with the specified length
static <E> E[]	Arrs.createArray(Class<E> componentType, int length, E initValue) Create an array with the specified length and every element's value is the specified initValue
static <E> E[]	Arrs.createArray(Class<E> componentType, int length, E initValue) Create an array with the specified length and every element's value is the specified initValue
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 <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator, KeyBuilder<String,E> keyBuilder)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator, KeyBuilder<String,E> keyBuilder)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator, KeyBuilder<String,E> keyBuilder)
static <E,C extends Collection<E>> CollectionDiffResult<E>	Collects.diff(C oldCollection, C newCollection, Comparator<E> elementComparator, KeyBuilder<String,E> keyBuilder)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator, Comparator<K> keyComparator)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator, Comparator<K> keyComparator)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator, Comparator<K> keyComparator)
static <K,V,M extends Map<K,V>> MapDiffResult<K,V>	Collects.diff(M oldMap, M newMap, Comparator<V> valueComparator, Comparator<K> keyComparator)
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)
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 <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 <E,C extends Collection<E>> Set<E>	Collects.distinct(C collection)
static <E> E[]	Collects.emptyArray(Class<E> componentType)
static <K,V> TreeMap<K,V>	Collects.emptyTreeMap(Comparator<K> comparator) Get a empty, mutable java.util.TreeMap
static <E> TreeSet<E>	Collects.emptyTreeSet(Comparator<E> comparator)
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
static <E> Collection<E>	Collects.filter(Object anyObject, Predicate<E> predicate, Predicate<E> breakPredicate) Filter any object with the specified predicate
Pipeline<E>	Pipeline.filter(Predicate<E> predicate, Predicate<E> breakPredicate)
static <E,C extends Collection<E>> E	Collects.findFirst(C collection, Predicate<E> predicate) find the first matched element, null if not found
static <E,C extends Collection<E>> E	Collects.findFirst(C collection, Predicate<E> predicate) find the first matched element, null if not found
static <K,V> Map.Entry<? extends K,? extends V>	Collects.findFirst(Map<? extends K,? extends V> map, Predicate2<K,V> predicate) find the first matched element, null if not found
static <K,V> Map.Entry<? extends K,? extends V>	Collects.findFirst(Map<? extends K,? extends V> map, Predicate2<K,V> predicate) find the first matched element, null if not found
static <E,C extends Collection<E>> List<E>	Collects.findN(C collection, Predicate<E> predicate, int n) find the first matched element, null if not found
static <E,C extends Collection<E>> List<E>	Collects.findN(C collection, Predicate<E> predicate, int n) find the first matched element, null if not found
static <K,V> Map<? extends K,? extends V>	Collects.findN(Map<? extends K,? extends V> map, Predicate2<K,V> predicate, int n) find the first matched element, null if not found
static <K,V> Map<? extends K,? extends V>	Collects.findN(Map<? extends K,? extends V> map, Predicate2<K,V> predicate, int n) find the first matched element, null if not found
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, 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 Collection<E>> void	Collects.forEach(C collection, Consumer2<Integer,E> consumer)
static <E,C extends Iterable<E>> void	Collects.forEach(C collection, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate) 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, 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)
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, 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, 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) 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,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,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, 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, Predicate<E> consumePredicate, Consumer<E> consumer, Predicate<E> breakPredicate) consume every element that matched the consumePredicate
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) 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 <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 <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, 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) 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
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
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)
void	Pipeline.forEach(Predicate<E> consumePredicate, Consumer<E> consumer, Predicate<E> breakPredicate)
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)
void	Pipeline.forEach(Predicate2<Integer,E> consumePredicate, Consumer2<Integer,E> consumer, Predicate2<Integer,E> breakPredicate)
static <E> List<E>	Collects.getEmptyListIfNull(List<E> list) Avoid NPE, create an empty, new list when the specified list is null
static <E> List<E>	Collects.getEmptyListIfNull(List<E> list, Collects.ListType listType)
static <E> List<E>	Collects.getEmptyListIfNull(List<E> list, Collects.ListType listType)
static <K,V> Map<K,V>	Collects.getEmptyMapIfNull(Map<K,V> map) Create an empty map when the specified map is null.
static <K,V> Map<K,V>	Collects.getEmptyMapIfNull(Map<K,V> map, Collects.MapType mapType)
static <K,V> Map<K,V>	Collects.getEmptyMapIfNull(Map<K,V> map, Collects.MapType mapType)
static <E> Set<E>	Collects.getEmptySetIfNull(Set<E> set) Avoid NPE, create an empty, new set when the specified set is null
static <E> Set<E>	Collects.getEmptySetIfNull(Set<E> set, Collects.SetType setType)
static <E> Set<E>	Collects.getEmptySetIfNull(Set<E> set, Collects.SetType setType)
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> 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 <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> void	Arrs.initArray(E[] array, E initValue)
static boolean	Arrs.isArray(Object o) judge whether an object is an Array
static <E,C extends Collection<E>> List<E>	Collects.limit(C collection, int maxSize) truncate a collection using subList(0, maxSize)
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,C extends Collection<E>> C	Collects.merge(C c1, C c2)
static <E,C extends Collection<E>> C	Collects.merge(C c1, C c2)
static <E,C extends Collection<E>> C	Collects.merge(C c1, C c2, boolean newOne)
static <E,C extends Collection<E>> C	Collects.merge(C c1, C c2, boolean newOne)
static <K,V,M extends Map<K,V>> M	Collects.merge(M map1, M map2)
static <K,V,M extends Map<K,V>> M	Collects.merge(M map1, M map2)
static <K,V,M extends Map<K,V>> M	Collects.merge(M map1, M map2, boolean newOne)
static <K,V,M extends Map<K,V>> M	Collects.merge(M map1, M map2, boolean newOne)
static <E> E	Collects.min(Object object, Comparator<E> comparator)
static <E> ArrayList<E>	Collects.newArrayList(E... elements)
static <E> ArrayList<E>	Collects.newArrayList(Iterable<E> elements)
static <K,V> HashMap<K,V>	Collects.newHashMap(Map<K,V> map)
static <E> HashSet<E>	Collects.newHashSet(E... elements)
static <E> HashSet<E>	Collects.newHashSet(Iterable<E> elements)
static <E> LinkedHashSet<E>	Collects.newLinkedHashSet(E... elements)
static <E> LinkedHashSet<E>	Collects.newLinkedHashSet(Iterable<E> elements)
static <E> LinkedList<E>	Collects.newLinkedList(E... elements)
static <E> LinkedList<E>	Collects.newLinkedList(Iterable<E> elements)
static <E> TreeSet<E>	Collects.newTreeSet(E... elements)
static <E> TreeSet<E>	Collects.newTreeSet(Iterable<E> elements)
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 ?
static <T> Pipeline<T>	Pipeline.of(Iterable<T> iterable)
static <T> Pipeline<T>	Pipeline.of(Object anyObject)
static <T> Pipeline<T>	Pipeline.of(T... array)
static Collects.ListType	Collects.ListType.ofList(List list)
static Collects.MapType	Collects.MapType.ofMap(Map map)
static Collects.SetType	Collects.SetType.ofSet(Set set)
static Map<String,String>	Collects.propertiesToStringMap(Properties properties)
static Map<String,String>	Collects.propertiesToStringMap(Properties properties, boolean sort)
static Map<String,String>	Collects.propertiesToStringMap(Properties properties, Comparator<String> keyComparator)
static Map<String,String>	Collects.propertiesToStringMap(Properties properties, Comparator<String> keyComparator)
V	LinkedCaseInsensitiveMap.put(String key, V value)
V	LinkedCaseInsensitiveMap.putIfAbsent(String key, V value)
static <E> E	Collects.reduce(E[] iterable, Operator2<E> operator)
static <E,C extends Iterable<E>> E	Collects.reduce(Iterable<E> iterable, Operator2<E> operator)
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> List<E>	Collects.reverse(List<E> list, boolean newOne) Reverse a list, return an new list when the argument 'newOne' is true
static <E,C extends Collection<E>> List<E>	Collects.skip(C collection, int n) skip n elements, get a collection using subList(n, size)
static <E extends Comparable<E>,C extends Collection<E>> TreeSet<E>	Collects.sort(C collection, boolean reverse) 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) 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
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
static <E,C extends Collection<E>> Object[]	Collects.toArray(C collection)
static <E,C extends Collection<E>> E[]	Collects.toArray(C list, Class<E[]> clazz) Convert a list to an array
static <E,C extends Collection<E>> E[]	Collects.toArray(C list, Class<E[]> clazz) Convert a list to an array
static <E,K,V> Collector<E,Map<K,V>>	Collects.toTreeMap(Function<E,K> keyMapper, Function<E,V> valueMapper, Comparator<K> comparator)
static <E> Collector<E,TreeSet<E>>	Collects.toTreeSet(Comparator<E> comparator) Collector Factory:
static boolean[]	PrimitiveArrays.unwrap(Boolean[] values, boolean resultNullable) convert a Boolean[] to a boolean[]
static byte[]	PrimitiveArrays.unwrap(Byte[] values, boolean resultNullable) convert a Byte[] to a byte[]
static char[]	PrimitiveArrays.unwrap(Character[] values, boolean resultNullable) convert a Character[] to a char[]
static double[]	PrimitiveArrays.unwrap(Double[] values, boolean resultNullable) convert a Double[] to a double[]
static float[]	PrimitiveArrays.unwrap(Float[] values, boolean resultNullable) convert a Float[] to a float[]
static int[]	PrimitiveArrays.unwrap(Integer[] values, boolean resultNullable) convert a Integer[] to a int[]
static long[]	PrimitiveArrays.unwrap(Long[] values, boolean resultNullable) convert a Long[] to a long[]
static short[]	PrimitiveArrays.unwrap(Short[] values, boolean resultNullable) convert a Short[] to a short[]
static Boolean[]	PrimitiveArrays.wrap(boolean[] values, boolean resultNullable) convert a boolean[] to a Boolean[]
static Byte[]	PrimitiveArrays.wrap(byte[] values, boolean resultNullable) convert a byte[] to a Byte[]
static Character[]	PrimitiveArrays.wrap(char[] values, boolean resultNullable) convert a char[] to a Character[]
static Double[]	PrimitiveArrays.wrap(double[] values, boolean resultNullable) convert a double[] to a Double[]
static Float[]	PrimitiveArrays.wrap(float[] values, boolean resultNullable) convert a float[] to a Float[]
static Integer[]	PrimitiveArrays.wrap(int[] values, boolean resultNullable) convert a int[] to a Integer[]
static Long[]	PrimitiveArrays.wrap(long[] values, boolean resultNullable) convert a long[] to a Long[]
static Short[]	PrimitiveArrays.wrap(short[] values, boolean resultNullable) convert a short[] to a Short[]
static <E> E[]	Arrs.wrapAsArray(E o) Wrap any object using new Object[]{object};

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

构造器和说明
LinkedCaseInsensitiveMap(int initialCapacity, Locale locale) Create a new LinkedCaseInsensitiveMap that wraps a LinkedHashMap with the given initial capacity and stores case-insensitive keys according to the given Locale (by default in lower case).
LinkedCaseInsensitiveMap(Locale locale) Create a new LinkedCaseInsensitiveMap that stores case-insensitive keys according to the given Locale (by default in lower case).

com.jn.langx.util.collection.diff中Nullable的使用

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

限定符和类型	方法和说明
CollectionDiffResult<E>	CollectionDiffer.diff(Collection<E> oldCollection, Collection<E> newCollection)
CollectionDiffResult<E>	CollectionDiffer.diff(Collection<E> oldCollection, Collection<E> newCollection)
MapDiffResult<K,V>	MapDiffer.diff(Map<K,V> oldMap, Map<K,V> newMap)
MapDiffResult<K,V>	MapDiffer.diff(Map<K,V> oldMap, Map<K,V> newMap)
void	CollectionDiffer.diffUsingMap(KeyBuilder<String,E> keyBuilder)
void	CollectionDiffResult.setAdds(Collection<E> adds)
void	MapDiffResult.setAdds(Map<K,V> adds)
void	CollectionDiffer.setComparator(Comparator<E> comparator)
void	CollectionDiffResult.setEquals(Collection<E> equals)
void	MapDiffResult.setEquals(Map<K,V> equals)
void	MapDiffer.setKeyComparator(Comparator<K> comparator)
void	CollectionDiffResult.setRemoves(Collection<E> removes)
void	MapDiffResult.setRemoves(Map<K,V> removes)
void	CollectionDiffResult.setUpdates(Collection<E> updates)
void	MapDiffResult.setUpdates(Map<K,V> updates)
void	MapDiffer.setValueComparator(Comparator<V> comparator)

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

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

构造器和说明
EnumerationIterable(Enumeration<E> enumeration)
EnumerationIterable(EnumerationIterator<E> iterator)
EnumerationIterator(Enumeration<E> enumeration)
IterableEnumeration(Iterable<E> iterable)
IterableEnumeration(IteratorEnumeration<E> delegate)
IteratorEnumeration(Iterator<E> iterator)

com.jn.langx.util.concurrent中Nullable的使用

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

限定符和类型	方法和说明
static <R> AtomicReference<R>	Atomics.newReference(R initialValue)

com.jn.langx.util.concurrent.threadlocal中Nullable的使用

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

限定符和类型	方法和说明
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, Locale locale)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, String timeZoneId)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, String timeZoneId, Locale locale)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, String timeZoneId, Locale locale)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, TimeZone timeZone)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, TimeZone timeZone, Locale locale)
static SimpleDateFormat	GlobalThreadLocalMap.getSimpleDateFormat(String pattern, TimeZone timeZone, Locale locale)

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

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

限定符和类型	方法和说明
Writer	StringBuilderWriter.append(CharSequence value) Appends a character sequence to this Writer.
Writer	StringBuilderWriter.append(CharSequence value, int start, int end) Appends a portion of a character sequence to the StringBuilder.
static Charset	Charsets.getCharset(Charset charset)
static Charset	Charsets.getCharset(String name)
static Charset	Charsets.getCharset(String name, String defaultName)
static Charset	Charsets.getCharset(String name, String defaultName)
static void	Channels.readLines(InputStream inputStream, Charset charset, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate)
static void	Channels.readLines(InputStream inputStream, Charset charset, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate)
static void	Channels.readLines(InputStream inputStream, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate)
static void	Channels.readLines(InputStream inputStream, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate)
static void	Channels.readLines(ReadableByteChannel channel, Charset charset, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate)
static void	Channels.readLines(ReadableByteChannel channel, Charset charset, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Predicate2<Integer,byte[]> consumePredicate, Consumer2<Integer,byte[]> consumer, Predicate2<Integer,byte[]> breakPredicate)
static void	Channels.readUsingDelimiter(InputStream inputStream, String delimiter, Predicate2<Integer,byte[]> consumePredicate, Consumer2<Integer,byte[]> consumer, Predicate2<Integer,byte[]> breakPredicate)
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Charset charset, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate) 在消费之前，把 byte[] 转为 String
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Charset charset, Predicate2<Integer,String> consumePredicate, Consumer2<Integer,String> consumer, Predicate2<Integer,String> breakPredicate) 在消费之前，把 byte[] 转为 String
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Predicate2<Integer,byte[]> consumePredicate, Consumer2<Integer,byte[]> consumer, Predicate2<Integer,byte[]> breakPredicate) 所有方法最终都是走这个
static void	Channels.readUsingDelimiter(ReadableByteChannel channel, String delimiter, Predicate2<Integer,byte[]> consumePredicate, Consumer2<Integer,byte[]> consumer, Predicate2<Integer,byte[]> breakPredicate) 所有方法最终都是走这个
void	NullOutputStream.write(byte[] b, int off, int len) Does nothing - output to /dev/null.

com.jn.langx.util.jar中Nullable的使用

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

限定符和类型	方法和说明
static Manifest	Manifests.loadManifest(String jarPath)

com.jn.langx.util.mime中Nullable的使用

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

限定符和类型	方法和说明
Charset	MimeType.getCharset() Return the character set, as indicated by a charset parameter, if any.
String	MimeType.getParameter(String name) Return a generic parameter value, given a parameter name.

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

限定符和类型	方法和说明
boolean	MimeType.equals(Object other)
boolean	MimeType.equalsTypeAndSubtype(MimeType other) Similar to MimeType.equals(Object) but based on the type and subtype only, i.e. ignoring parameters.
boolean	MimeType.includes(MimeType other) Indicate whether this MIME Type includes the given MIME Type.
boolean	MimeType.isCompatibleWith(MimeType other) Indicate whether this MIME Type is compatible with the given MIME Type.

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

构造器和说明
MimeType(MimeType other, Map<String,String> parameters) Copy-constructor that copies the type and subtype of the given MimeType, and allows for different parameter.
MimeType(String type, String subtype, Map<String,String> parameters) Create a new MimeType for the given type, subtype, and parameters.

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

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

限定符和类型	方法和说明
static String	Nets.getMac(NetworkInterface networkInterface)

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

限定符和类型	方法和说明
static Map<String,Set<InetAddress>>	Nets.getNetworkInterfaceAddresses(Predicate<NetworkInterface> networkInterfacePredicate, Predicate<InetAddress> inetAddressPredicate)
static Map<String,Set<InetAddress>>	Nets.getNetworkInterfaceAddresses(Predicate<NetworkInterface> networkInterfacePredicate, Predicate<InetAddress> inetAddressPredicate)

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

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

限定符和类型	方法和说明
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.getMethodString(String clazzFQN, String methodName, Class returnType, Class[] parameterTypes)
static String	Reflects.getMethodString(String clazzFQN, String methodName, Class returnType, Class[] parameterTypes)
static <V> V	Reflects.invoke(Method method, Object object, Object[] parameters, boolean force, boolean throwException)
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.isEqualsMethod(Method method) Determine whether the given method is an "equals" method.
static boolean	Reflects.isHashCodeMethod(Method method) Determine whether the given method is a "hashCode" method.
static boolean	Reflects.isObjectMethod(Method method) Determine whether the given method is originally declared by Object.
static boolean	Reflects.isToStringMethod(Method method) Determine whether the given method is a "toString" method.
static <E> E	Reflects.newInstance(Class<E> clazz, Class[] parameterTypes, Object[] parameters)

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

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

com.jn.langx.util.timing中Nullable的使用

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

限定符和类型	方法和说明
String	StopWatch.currentTaskName() Return the name of the currently running task, if any.