| 限定符和类型 | 方法和说明 |
|---|---|
O |
Parser.parse(I input) |
| 限定符和类型 | 方法和说明 |
|---|---|
protected String |
PropertyPlaceholderHandler.parseStringValue(String value,
PlaceholderParser placeholderResolver,
Set<String> visitedPlaceholders) |
| 构造器和说明 |
|---|
PropertyPlaceholderHandler(String placeholderPrefix,
String placeholderSuffix,
String valueSeparator,
boolean ignoreUnresolvablePlaceholders)
Creates a new
PropertyPlaceholderHelper that uses the supplied prefix and suffix. |
| 限定符和类型 | 方法和说明 |
|---|---|
String |
StopWatch.currentTaskName()
Return the name of the currently running task, if any.
|
| 限定符和类型 | 方法和说明 |
|---|---|
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.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 <E> boolean |
Collects.allMatch(Iterable<E> collection,
Predicate<E> predicate)
whether all elements match the specified condition or not
|
static <K,V> boolean |
Collects.allMatch(Map<? extends K,? extends V> map,
Predicate2<K,V> predicate)
whether all elements match the specified condition or not
|
static <E> boolean |
Collects.anyMatch(Collection<E> collection,
Predicate<E> predicate)
has any element match the specified condition
|
static <K,V> boolean |
Collects.anyMatch(Map<? extends K,? extends V> 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> 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> Collection<E> |
Collects.concat(Collection<E> c1,
Collection<E> c2)
Concat two collection to one
|
static <E> Collection<E> |
Collects.concat(Collection<E> c1,
Collection<E> c2)
Concat two collection to one
|
static <E> Collection<E> |
Collects.concat(Collection<E> c1,
Collection<E> c2,
boolean newOne)
Concat two collection to one
|
static <E> Collection<E> |
Collects.concat(Collection<E> c1,
Collection<E> c2,
boolean newOne)
Concat two collection to one
|
static <E> int |
Collects.count(Collection<E> 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> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator,
KeyBuilder<String,E> keyBuilder) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator,
KeyBuilder<String,E> keyBuilder) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator,
KeyBuilder<String,E> keyBuilder) |
static <E> CollectionDiffResult<E> |
Collects.diff(Collection<E> oldCollection,
Collection<E> newCollection,
Comparator<E> elementComparator,
KeyBuilder<String,E> keyBuilder) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator,
Comparator<K> keyComparator) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator,
Comparator<K> keyComparator) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator,
Comparator<K> keyComparator) |
static <K,V> MapDiffResult<K,V> |
Collects.diff(Map<K,V> oldMap,
Map<K,V> newMap,
Comparator<V> valueComparator,
Comparator<K> keyComparator) |
static <E> Set<E> |
Collects.distinct(Collection<E> collection) |
static <E> E[] |
Collects.emptyArray(Class<E> componentType) |
static <K,V> Map<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> E |
Collects.findFirst(Collection<E> collection,
Predicate<E> predicate)
find the first matched element, null if not found
|
static <E> E |
Collects.findFirst(Collection<E> 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,R> Collection<R> |
Collects.flatMap(Collection<Collection<E>> collection,
Function<E,R> mapper)
map a collection to another, flat it
|
static <E> void |
Collects.forEach(E[] array,
Consumer2<Integer,E> consumer)
Iterate every element
|
static <K,V> void |
Collects.forEach(Map<? extends K,? extends V> map,
Consumer2<K,V> consumer)
Iterate every element
|
static <E> void |
Collects.forEach(Object anyObject,
Consumer<E> consumer)
Iterate every element
|
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 <E> void |
Arrs.initArray(E[] array,
E initValue) |
static boolean |
Arrs.isArray(Object o)
judge whether an object is an Array
|
static <E> List<E> |
Collects.limit(Collection<E> collection,
int maxSize)
truncate a collection using subList(0, maxSize)
|
static <K,V,R> List<R> |
Collects.map(Map<? extends K,? extends V> map,
Function2<K,V,R> mapper)
mapping aMap to a list
|
static <K,V,K1,V1> |
Collects.map(Map<? extends K,? extends V> 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> Map<K,V> |
Collects.map(Object anyObject,
Mapper<E,Pair<K,V>> mapper)
mapping an iterable to a map
|
static <E> Collection<E> |
Collects.merge(Collection<E> c1,
Collection<E> c2) |
static <E> Collection<E> |
Collects.merge(Collection<E> c1,
Collection<E> c2) |
static <E> Collection<E> |
Collects.merge(Collection<E> c1,
Collection<E> c2,
boolean newOne) |
static <E> Collection<E> |
Collects.merge(Collection<E> c1,
Collection<E> c2,
boolean newOne) |
static <K,V> Map<K,V> |
Collects.merge(Map<K,V> map1,
Map<K,V> map2) |
static <K,V> Map<K,V> |
Collects.merge(Map<K,V> map1,
Map<K,V> map2) |
static <K,V> Map<K,V> |
Collects.merge(Map<K,V> map1,
Map<K,V> map2,
boolean newOne) |
static <K,V> Map<K,V> |
Collects.merge(Map<K,V> map1,
Map<K,V> map2,
boolean newOne) |
static <E> E |
Collects.min(Object object,
Comparator<E> comparator) |
static <E> boolean |
Collects.noneMatch(Iterable<E> collection,
Predicate<E> predicate)
has no any element match the specified condition ?
|
static <K,V> boolean |
Collects.noneMatch(Map<? extends K,? extends V> map,
Predicate2<K,V> predicate)
has no any element match the specified condition ?
|
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) |
static <E> boolean |
Collects.removeIf(Collection<E> 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> List<E> |
Collects.skip(Collection<E> collection,
int n)
skip n elements, get a collection using subList(n, size)
|
static <E extends Comparable<E>> |
Collects.sort(Collection<E> 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> TreeSet<E> |
Collects.sort(Collection<E> 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> TreeSet<E> |
Collects.sort(Collection<E> 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> Map<K,V> |
Collects.sort(Map<K,V> 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> Object[] |
Collects.toArray(Collection<E> list) |
static <E> E[] |
Collects.toArray(Collection<E> list,
Class<E[]> clazz)
Convert a list to an array
|
static <E> E[] |
Collects.toArray(Collection<E> 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) |
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};
|
| 限定符和类型 | 方法和说明 |
|---|---|
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 |
CollectionDiffer.setComparator(Comparator<E> comparator) |
void |
CollectionDiffResult.setEquals(Collection<E> equals) |
void |
MapDiffer.setKeyComparator(Comparator<K> comparator) |
void |
CollectionDiffResult.setRemoves(Collection<E> removes) |
void |
CollectionDiffResult.setUpdates(Collection<E> updates) |
void |
MapDiffer.setValueComparator(Comparator<V> comparator) |
| 限定符和类型 | 方法和说明 |
|---|---|
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) |
void |
NullOutputStream.write(byte[] b,
int off,
int len)
Does nothing - output to
/dev/null. |
| 限定符和类型 | 方法和说明 |
|---|---|
static Manifest |
Manifests.loadManifest(String jarPath) |
| 限定符和类型 | 方法和说明 |
|---|---|
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 <E> E |
Reflects.newInstance(Class<E> clazz,
Class[] parameterTypes,
Object[] parameters) |
| 构造器和说明 |
|---|
FieldComparator(Class clazz,
String fieldName,
Comparator fieldComparator) |
FieldComparator(Field field,
Comparator fieldComparator) |
Copyright © 2019. All rights reserved.