All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.landawn.abacus.util.CommonUtil Maven / Gradle / Ivy

Go to download

A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.

There is a newer version: 2.1.12
Show newest version
/*
 * Copyright (c) 2015, Haiyang Li.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.landawn.abacus.util;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.nio.charset.Charset;
import java.security.SecureRandom;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.SQLException;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.RandomAccess;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;

import com.landawn.abacus.DataSet;
import com.landawn.abacus.DirtyMarker;
import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.Immutable;
import com.landawn.abacus.annotation.Internal;
import com.landawn.abacus.annotation.NullSafe;
import com.landawn.abacus.core.DirtyMarkerUtil;
import com.landawn.abacus.core.MapEntity;
import com.landawn.abacus.core.RowDataSet;
import com.landawn.abacus.exception.UncheckedSQLException;
import com.landawn.abacus.parser.ParserUtil;
import com.landawn.abacus.parser.ParserUtil.EntityInfo;
import com.landawn.abacus.parser.ParserUtil.PropInfo;
import com.landawn.abacus.type.Type;
import com.landawn.abacus.type.TypeFactory;
import com.landawn.abacus.util.Iterables.Slice;
import com.landawn.abacus.util.u.Nullable;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.u.OptionalInt;
import com.landawn.abacus.util.function.BiPredicate;
import com.landawn.abacus.util.function.BinaryOperator;
import com.landawn.abacus.util.function.Function;
import com.landawn.abacus.util.function.IntFunction;
import com.landawn.abacus.util.function.Supplier;
import com.landawn.abacus.util.function.ToDoubleFunction;
import com.landawn.abacus.util.function.ToIntFunction;
import com.landawn.abacus.util.function.ToLongFunction;

/**
 * 

* Note: This class includes codes copied from Apache Commons Lang, Google Guava and other open source projects under the Apache License 2.0. * The methods copied from other libraries/frameworks/projects may be modified in this class. *

* Class N is a general java utility class. It provides the most daily used operations for Object/primitive types/String/Array/Collection/Map/Entity...: * * When to throw exception? It's designed to avoid throwing any unnecessary * exception if the contract defined by method is not broken. for example, if * user tries to reverse a null or empty String. the input String will be * returned. But exception will be thrown if trying to repeat/swap a null or * empty string or operate Array/Collection by adding/removing...
* * @author Haiyang Li * * @version $Revision: 0.8 $ 07/03/10 * * @see com.landawn.abacus.util.IOUtil * @see com.landawn.abacus.util.StringUtil * @see com.landawn.abacus.util.Iterables * @see com.landawn.abacus.util.Iterators * @see com.landawn.abacus.util.Maps * @see com.landawn.abacus.util.Primitives * @see com.landawn.abacus.util.Array * @see com.landawn.abacus.util.Seq */ class CommonUtil { // ... it has to be big enough to make it's safety to add element to // ArrayBlockingQueue. static final int POOL_SIZE = Internals.POOL_SIZE; /** * An empty immutable {@code Boolean} array. */ static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0]; /** * An empty immutable {@code Character} array. */ static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0]; /** * An empty immutable {@code Byte} array. */ static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0]; /** * An empty immutable {@code Short} array. */ static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0]; /** * An empty immutable {@code Integer} array. */ static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0]; /** * An empty immutable {@code Long} array. */ static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0]; /** * An empty immutable {@code Float} array. */ static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0]; /** * An empty immutable {@code Double} array. */ static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0]; /** * An empty immutable {@code Class} array. */ static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; static final String NULL_STRING = "null".intern(); static final char[] NULL_CHAR_ARRAY = NULL_STRING.toCharArray(); static final String TRUE = Boolean.TRUE.toString().intern(); static final char[] TRUE_CHAR_ARRAY = TRUE.toCharArray(); static final String FALSE = Boolean.FALSE.toString().intern(); static final char[] FALSE_CHAR_ARRAY = FALSE.toCharArray(); // ... static final char CHAR_0 = WD.CHAR_0; /** * The Constant CHAR_LF. * * @see JLF: * Escape Sequences for Character and String Literals * @since 2.2 */ static final char CHAR_LF = WD.CHAR_LF; /** * The Constant CHAR_CR. * * @see JLF: * Escape Sequences for Character and String Literals * @since 2.2 */ static final char CHAR_CR = WD.CHAR_CR; public static final String ELEMENT_SEPARATOR = ", ".intern(); public static final char[] ELEMENT_SEPARATOR_CHAR_ARRAY = ELEMENT_SEPARATOR.toCharArray(); // ... /** * The index value when an element is not found in a list or array: * {@code -1}. This value is returned by methods in this class and can also * be used in comparisons with values returned by various method from * {@link java.util.List} . */ public static final int INDEX_NOT_FOUND = -1; // ... public static final String EMPTY_STRING = "".intern(); /** * An empty immutable {@code boolean} array. */ public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0]; /** * An empty immutable {@code char} array. */ public static final char[] EMPTY_CHAR_ARRAY = new char[0]; /** * An empty immutable {@code byte} array. */ public static final byte[] EMPTY_BYTE_ARRAY = new byte[0]; /** * An empty immutable {@code short} array. */ public static final short[] EMPTY_SHORT_ARRAY = new short[0]; /** * An empty immutable {@code int} array. */ public static final int[] EMPTY_INT_ARRAY = new int[0]; /** * An empty immutable {@code long} array. */ public static final long[] EMPTY_LONG_ARRAY = new long[0]; /** * An empty immutable {@code float} array. */ public static final float[] EMPTY_FLOAT_ARRAY = new float[0]; /** * An empty immutable {@code double} array. */ public static final double[] EMPTY_DOUBLE_ARRAY = new double[0]; /** * An empty immutable {@code Boolean} array. */ public static final Boolean[] EMPTY_BOOLEAN_OBJ_ARRAY = new Boolean[0]; /** * An empty immutable {@code Character} array. */ public static final Character[] EMPTY_CHAR_OBJ_ARRAY = new Character[0]; /** * An empty immutable {@code Byte} array. */ public static final Byte[] EMPTY_BYTE_OBJ_ARRAY = new Byte[0]; /** * An empty immutable {@code Short} array. */ public static final Short[] EMPTY_SHORT_OBJ_ARRAY = new Short[0]; /** * An empty immutable {@code Integer} array. */ public static final Integer[] EMPTY_INT_OBJ_ARRAY = new Integer[0]; /** * An empty immutable {@code Long} array. */ public static final Long[] EMPTY_LONG_OBJ_ARRAY = new Long[0]; /** * An empty immutable {@code Float} array. */ public static final Float[] EMPTY_FLOAT_OBJ_ARRAY = new Float[0]; /** * An empty immutable {@code Double} array. */ public static final Double[] EMPTY_DOUBLE_OBJ_ARRAY = new Double[0]; /** * An empty immutable {@code String} array. */ public static final String[] EMPTY_STRING_ARRAY = new String[0]; /** * An empty immutable {@code Object} array. */ public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0]; @SuppressWarnings("rawtypes") static final List EMPTY_LIST = Collections.emptyList(); @SuppressWarnings("rawtypes") static final Set EMPTY_SET = Collections.emptySet(); @SuppressWarnings("rawtypes") static final Map EMPTY_MAP = Collections.emptyMap(); @SuppressWarnings("rawtypes") static final Iterator EMPTY_ITERATOR = Collections.emptyIterator(); @SuppressWarnings("rawtypes") static final ListIterator EMPTY_LIST_ITERATOR = Collections.emptyListIterator(); // ... static final Object NULL_MASK = new NullMask(); static final String BACKSLASH_ASTERISK = "*"; // ... static final int REVERSE_THRESHOLD = 18; static final int FILL_THRESHOLD = 25; static final int REPLACEALL_THRESHOLD = 11; // ... static final Random RAND = new SecureRandom(); @SuppressWarnings("rawtypes") static final Comparator NULL_MIN_COMPARATOR = Comparators.nullsFirst(); @SuppressWarnings("rawtypes") static final Comparator NULL_MAX_COMPARATOR = Comparators.nullsLast(); @SuppressWarnings("rawtypes") static final Comparator NATURAL_ORDER = Comparators.naturalOrder(); // ... static final Map, Object> CLASS_EMPTY_ARRAY = new ConcurrentHashMap<>(); static { CLASS_EMPTY_ARRAY.put(boolean.class, CommonUtil.EMPTY_BOOLEAN_ARRAY); CLASS_EMPTY_ARRAY.put(Boolean.class, CommonUtil.EMPTY_BOOLEAN_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(char.class, CommonUtil.EMPTY_CHAR_ARRAY); CLASS_EMPTY_ARRAY.put(Character.class, CommonUtil.EMPTY_CHARACTER_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(byte.class, CommonUtil.EMPTY_BYTE_ARRAY); CLASS_EMPTY_ARRAY.put(Byte.class, CommonUtil.EMPTY_BYTE_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(short.class, CommonUtil.EMPTY_SHORT_ARRAY); CLASS_EMPTY_ARRAY.put(Short.class, CommonUtil.EMPTY_SHORT_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(int.class, CommonUtil.EMPTY_INT_ARRAY); CLASS_EMPTY_ARRAY.put(Integer.class, CommonUtil.EMPTY_INTEGER_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(long.class, CommonUtil.EMPTY_LONG_ARRAY); CLASS_EMPTY_ARRAY.put(Long.class, CommonUtil.EMPTY_LONG_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(float.class, CommonUtil.EMPTY_FLOAT_ARRAY); CLASS_EMPTY_ARRAY.put(Float.class, CommonUtil.EMPTY_FLOAT_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(double.class, CommonUtil.EMPTY_DOUBLE_ARRAY); CLASS_EMPTY_ARRAY.put(Double.class, CommonUtil.EMPTY_DOUBLE_OBJECT_ARRAY); CLASS_EMPTY_ARRAY.put(String.class, CommonUtil.EMPTY_STRING_ARRAY); CLASS_EMPTY_ARRAY.put(Object.class, CommonUtil.EMPTY_OBJECT_ARRAY); } // ... static final Map, Integer> CLASS_TYPE_ENUM = new HashMap<>(); static { CLASS_TYPE_ENUM.put(boolean.class, 1); CLASS_TYPE_ENUM.put(char.class, 2); CLASS_TYPE_ENUM.put(byte.class, 3); CLASS_TYPE_ENUM.put(short.class, 4); CLASS_TYPE_ENUM.put(int.class, 5); CLASS_TYPE_ENUM.put(long.class, 6); CLASS_TYPE_ENUM.put(float.class, 7); CLASS_TYPE_ENUM.put(double.class, 8); CLASS_TYPE_ENUM.put(String.class, 9); CLASS_TYPE_ENUM.put(boolean[].class, 11); CLASS_TYPE_ENUM.put(char[].class, 12); CLASS_TYPE_ENUM.put(byte[].class, 13); CLASS_TYPE_ENUM.put(short[].class, 14); CLASS_TYPE_ENUM.put(int[].class, 15); CLASS_TYPE_ENUM.put(long[].class, 16); CLASS_TYPE_ENUM.put(float[].class, 17); CLASS_TYPE_ENUM.put(double[].class, 18); CLASS_TYPE_ENUM.put(String[].class, 19); CLASS_TYPE_ENUM.put(Boolean.class, 21); CLASS_TYPE_ENUM.put(Character.class, 22); CLASS_TYPE_ENUM.put(Byte.class, 23); CLASS_TYPE_ENUM.put(Short.class, 24); CLASS_TYPE_ENUM.put(Integer.class, 25); CLASS_TYPE_ENUM.put(Long.class, 26); CLASS_TYPE_ENUM.put(Float.class, 27); CLASS_TYPE_ENUM.put(Double.class, 28); } // ... private static final Map>, ImmutableList>> enumListPool = new ObjectPool<>(POOL_SIZE); private static final Map>, ImmutableSet>> enumSetPool = new ObjectPool<>(POOL_SIZE); private static final Map>, ImmutableBiMap, String>> enumMapPool = new ObjectPool<>(POOL_SIZE); private static final Map> nameTypePool = new ObjectPool<>(POOL_SIZE); private static final Map, Type> clsTypePool = new ObjectPool<>(POOL_SIZE); static final String[] charStringCache = new String[128]; static final int intStringCacheLow = -1001; static final int intStringCacheHigh = 10001; static final String[] intStringCache = new String[intStringCacheHigh - intStringCacheLow]; static final Map stringIntCache = new HashMap<>((int) (intStringCache.length * 1.5)); static { for (int i = 0, j = intStringCacheLow, len = intStringCache.length; i < len; i++, j++) { intStringCache[i] = Integer.valueOf(j).toString(); stringIntCache.put(intStringCache[i], j); } for (int i = 0; i < charStringCache.length; i++) { charStringCache[i] = String.valueOf((char) i); } } private static final int MIN_SIZE_FOR_COPY_ALL = 9; CommonUtil() { // Utility class. } /** * * @param * @param typeName * @return * @throws IllegalArgumentException if the specified typeName is null. */ @SuppressWarnings("unchecked") public static Type typeOf(final String typeName) throws IllegalArgumentException { N.checkArgNotNull(typeName, "typeName"); Type type = nameTypePool.get(typeName); if (type == null) { type = TypeFactory.getType(typeName); nameTypePool.put(typeName, type); } return (Type) type; } /** * * @param * @param cls * @return * @throws IllegalArgumentException if the specified {@code Class} is null. */ @SuppressWarnings("unchecked") public static Type typeOf(final Class cls) throws IllegalArgumentException { N.checkArgNotNull(cls, "cls"); Type type = clsTypePool.get(cls); if (type == null) { type = TypeFactory.getType(cls); clsTypePool.put(cls, type); } return (Type) type; } /** * * @param * @param targetClass * @param str * @return */ @SuppressWarnings("unchecked") public static T valueOf(final Class targetClass, final String str) { return (str == null) ? defaultValueOf(targetClass) : (T) CommonUtil.typeOf(targetClass).valueOf(str); } /** * Default value of. * * @param * @param cls * @return */ @SuppressWarnings("unchecked") public static T defaultValueOf(final Class cls) { return (T) CommonUtil.typeOf(cls).defaultValue(); } /** * Default if null. * * @param b * @return true, if successful */ public static boolean defaultIfNull(Boolean b) { if (b == null) { return false; } return b.booleanValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return true, if successful */ public static boolean defaultIfNull(Boolean b, boolean defaultForNull) { if (b == null) { return defaultForNull; } return b.booleanValue(); } /** * Default if null. * * @param c * @return */ public static char defaultIfNull(Character c) { if (c == null) { return CommonUtil.CHAR_0; } return c.charValue(); } /** * Default if null. * * @param c * @param defaultForNull * @return */ public static char defaultIfNull(Character c, char defaultForNull) { if (c == null) { return defaultForNull; } return c.charValue(); } /** * Default if null. * * @param b * @return */ public static byte defaultIfNull(Byte b) { if (b == null) { return (byte) 0; } return b.byteValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return */ public static byte defaultIfNull(Byte b, byte defaultForNull) { if (b == null) { return defaultForNull; } return b.byteValue(); } /** * Default if null. * * @param b * @return */ public static short defaultIfNull(Short b) { if (b == null) { return (short) 0; } return b.shortValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return */ public static short defaultIfNull(Short b, short defaultForNull) { if (b == null) { return defaultForNull; } return b.shortValue(); } /** * Default if null. * * @param b * @return */ public static int defaultIfNull(Integer b) { if (b == null) { return 0; } return b.intValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return */ public static int defaultIfNull(Integer b, int defaultForNull) { if (b == null) { return defaultForNull; } return b.intValue(); } /** * Default if null. * * @param b * @return */ public static long defaultIfNull(Long b) { if (b == null) { return 0; } return b.longValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return */ public static long defaultIfNull(Long b, long defaultForNull) { if (b == null) { return defaultForNull; } return b.longValue(); } /** * Default if null. * * @param b * @return */ public static float defaultIfNull(Float b) { if (b == null) { return 0; } return b.floatValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return */ public static float defaultIfNull(Float b, float defaultForNull) { if (b == null) { return defaultForNull; } return b.floatValue(); } /** * Default if null. * * @param b * @return */ public static double defaultIfNull(Double b) { if (b == null) { return 0; } return b.doubleValue(); } /** * Default if null. * * @param b * @param defaultForNull * @return */ public static double defaultIfNull(Double b, double defaultForNull) { if (b == null) { return defaultForNull; } return b.doubleValue(); } /** * Default if null. * * @param * @param obj * @param defaultForNull * @return */ public static T defaultIfNull(final T obj, final T defaultForNull) { return obj == null ? defaultForNull : obj; } /** * * @param val * @return */ public static String stringOf(final boolean val) { return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final char val) { if (val < 128) { return charStringCache[val]; } return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final byte val) { if (val > intStringCacheLow && val < intStringCacheHigh) { return intStringCache[val - intStringCacheLow]; } return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final short val) { if (val > intStringCacheLow && val < intStringCacheHigh) { return intStringCache[val - intStringCacheLow]; } return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final int val) { if (val > intStringCacheLow && val < intStringCacheHigh) { return intStringCache[val - intStringCacheLow]; } return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final long val) { if (val > intStringCacheLow && val < intStringCacheHigh) { return intStringCache[(int) (val - intStringCacheLow)]; } return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final float val) { return String.valueOf(val); } /** * * @param val * @return */ public static String stringOf(final double val) { return String.valueOf(val); } /** * * @param obj * @return null if the specified object is null. */ public static String stringOf(final Object obj) { return (obj == null) ? null : CommonUtil.typeOf(obj.getClass()).stringOf(obj); } /** * Enum list of. * * @param * @param enumClass * @return */ public static > ImmutableList enumListOf(final Class enumClass) { ImmutableList enumList = (ImmutableList) enumListPool.get(enumClass); if (enumList == null) { enumList = ImmutableList.of(CommonUtil.asList(enumClass.getEnumConstants())); enumListPool.put(enumClass, enumList); } return enumList; } /** * Enum set of. * * @param * @param enumClass * @return */ public static > ImmutableSet enumSetOf(final Class enumClass) { ImmutableSet enumSet = (ImmutableSet) enumSetPool.get(enumClass); if (enumSet == null) { enumSet = ImmutableSet.of(EnumSet.allOf(enumClass)); enumSetPool.put(enumClass, enumSet); } return enumSet; } /** * Enum map of. * * @param * @param enumClass * @return */ public static > ImmutableBiMap enumMapOf(final Class enumClass) { ImmutableBiMap enumMap = (ImmutableBiMap) enumMapPool.get(enumClass); if (enumMap == null) { final EnumMap keyMap = new EnumMap<>(enumClass); final Map valueMap = new HashMap<>(); for (final E e : enumClass.getEnumConstants()) { keyMap.put(e, e.name()); valueMap.put(e.name(), e); } enumMap = ImmutableBiMap.of(new BiMap<>(keyMap, valueMap)); enumMapPool.put(enumClass, enumMap); } return enumMap; } /** * * @param * @param cls * @return T */ public static T newInstance(final Class cls) { if (Modifier.isAbstract(cls.getModifiers())) { if (cls.equals(Map.class)) { return (T) new HashMap<>(); } else if (cls.equals(List.class)) { return (T) new ArrayList<>(); } else if (cls.equals(Set.class)) { return (T) new HashSet<>(); } else if (cls.equals(Queue.class) || cls.equals(Deque.class)) { return (T) new ArrayDeque<>(); } else if (cls.equals(SortedMap.class) || cls.equals(NavigableMap.class)) { return (T) new TreeMap<>(); } else if (cls.equals(SortedSet.class) || cls.equals(NavigableSet.class)) { return (T) new TreeSet<>(); } else if (cls.equals(BlockingQueue.class)) { return (T) new LinkedBlockingQueue<>(); } else if (cls.equals(BlockingDeque.class)) { return (T) new LinkedBlockingDeque<>(); } } try { if (Modifier.isStatic(cls.getModifiers()) == false && (cls.isAnonymousClass() || cls.isMemberClass())) { // http://stackoverflow.com/questions/2097982/is-it-possible-to-create-an-instance-of-nested-class-using-java-reflection final List> toInstantiate = new ArrayList<>(); Class parent = cls.getEnclosingClass(); do { toInstantiate.add(parent); parent = parent.getEnclosingClass(); } while (parent != null && Modifier.isStatic(parent.getModifiers()) == false && (parent.isAnonymousClass() || parent.isMemberClass())); if (parent != null) { toInstantiate.add(parent); } CommonUtil.reverse(toInstantiate); Object instance = null; for (Class current : toInstantiate) { instance = instance == null ? invoke(ClassUtil.getDeclaredConstructor(current)) : invoke(ClassUtil.getDeclaredConstructor(current, instance.getClass()), instance); } return invoke(ClassUtil.getDeclaredConstructor(cls, instance.getClass()), instance); } else { final Constructor constructor = ClassUtil.getDeclaredConstructor(cls); if (constructor == null) { throw new IllegalArgumentException("No default constructor found in class: " + ClassUtil.getCanonicalClassName(cls)); } return invoke(constructor); } } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw N.toRuntimeException(e); } } /** * * @param * @param c * @param args * @return * @throws InstantiationException the instantiation exception * @throws IllegalAccessException the illegal access exception * @throws IllegalArgumentException the illegal argument exception * @throws InvocationTargetException the invocation target exception */ @SuppressWarnings("unchecked") private static T invoke(final Constructor c, final Object... args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { if (c.isAccessible() == false) { ClassUtil.setAccessible(c, true); } return c.newInstance(args); } /** * New proxy instance. * * @param * @param interfaceClass * @param h * @return */ public static T newProxyInstance(final Class interfaceClass, final InvocationHandler h) { return newProxyInstance(CommonUtil.asArray(interfaceClass), h); } /** * Refer to {@code java.lang.reflect} * * @param * @param interfaceClasses * @param h * @return */ public static T newProxyInstance(final Class[] interfaceClasses, final InvocationHandler h) { return (T) Proxy.newProxyInstance(CommonUtil.class.getClassLoader(), interfaceClasses, h); } /** * * @param * @param componentType * @param length * @return T[] */ @SuppressWarnings("unchecked") public static T newArray(final Class componentType, final int length) { return (T) Array.newInstance(componentType, length); } /** * * @param * @param cls * @return */ @SuppressWarnings("unchecked") public static T newEntity(final Class cls) { return newEntity(cls, null); } /** * * @param * @param cls * @param entityName * @return */ public static T newEntity(final Class cls, final String entityName) { if (MapEntity.class.isAssignableFrom(cls)) { return (T) new MapEntity(entityName); } final Class enclosingClass = ClassUtil.getEnclosingClass(cls); if (enclosingClass == null || Modifier.isStatic(cls.getModifiers())) { return newInstance(cls); } else { return ClassUtil.invokeConstructor(ClassUtil.getDeclaredConstructor(cls, enclosingClass), newInstance(enclosingClass)); } } /** * Returns a set backed by the specified map. * * @param * @param map the backing map * @return * @see Collections#newSetFromMap(Map) */ public static Set newSetFromMap(final Map map) { return Collections.newSetFromMap(map); } /** * Inits the hash capacity. * * @param size * @return */ public static int initHashCapacity(final int size) { CommonUtil.checkArgNotNegative(size, "size"); if (size == 0) { return 0; } int res = size < MAX_HASH_LENGTH ? (int) (size * 1.25) + 1 : MAX_ARRAY_SIZE; switch (res / 64) { case 0: case 1: return res; case 2: case 3: case 4: return 128; default: return 256; } } /** * New array list. * * @param * @return */ public static ArrayList newArrayList() { return new ArrayList<>(); } /** * New array list. * * @param * @param initialCapacity * @return */ public static ArrayList newArrayList(int initialCapacity) { return new ArrayList<>(initialCapacity); } /** * New array list. * * @param * @param c * @return */ public static ArrayList newArrayList(Collection c) { return CommonUtil.isNullOrEmpty(c) ? new ArrayList() : new ArrayList<>(c); } /** * New linked list. * * @param * @return */ public static LinkedList newLinkedList() { return new LinkedList<>(); } /** * New linked list. * * @param * @param c * @return */ public static LinkedList newLinkedList(Collection c) { return CommonUtil.isNullOrEmpty(c) ? new LinkedList() : new LinkedList<>(c); } /** * New hash set. * * @param * @return */ public static Set newHashSet() { return new HashSet<>(); } /** * New hash set. * * @param * @param initialCapacity * @return */ public static Set newHashSet(int initialCapacity) { return new HashSet<>(initialCapacity); } /** * New hash set. * * @param * @param c * @return */ public static Set newHashSet(Collection c) { return CommonUtil.isNullOrEmpty(c) ? new HashSet() : new HashSet<>(c); } /** * New linked hash set. * * @param * @return */ public static Set newLinkedHashSet() { return new LinkedHashSet<>(); } /** * New linked hash set. * * @param * @param initialCapacity * @return */ public static Set newLinkedHashSet(int initialCapacity) { return new LinkedHashSet<>(initialCapacity); } /** * New linked hash set. * * @param * @param c * @return */ public static Set newLinkedHashSet(Collection c) { return CommonUtil.isNullOrEmpty(c) ? new LinkedHashSet() : new LinkedHashSet<>(c); } /** * New tree set. * * @param * @return */ public static > TreeSet newTreeSet() { return new TreeSet<>(); } /** * New tree set. * * @param * @param comparator * @return */ public static TreeSet newTreeSet(Comparator comparator) { return new TreeSet<>(comparator); } /** * New tree set. * * @param * @param c * @return */ public static > TreeSet newTreeSet(Collection c) { return CommonUtil.isNullOrEmpty(c) ? new TreeSet() : new TreeSet<>(c); } /** * New tree set. * * @param * @param c * @return */ public static TreeSet newTreeSet(SortedSet c) { return CommonUtil.isNullOrEmpty(c) ? new TreeSet() : new TreeSet<>(c); } /** * * @param * @return */ public static Multiset newMultiset() { return new Multiset<>(); } /** * * @param * @param initialCapacity * @return */ public static Multiset newMultiset(final int initialCapacity) { return new Multiset<>(initialCapacity); } /** * * @param * @param valueMapType * @return */ @SuppressWarnings("rawtypes") public static Multiset newMultiset(final Class valueMapType) { return new Multiset<>(valueMapType); } /** * * @param * @param mapSupplier * @return */ public static Multiset newMultiset(final Supplier> mapSupplier) { return new Multiset<>(mapSupplier); } /** * * @param * @param c * @return */ public static Multiset newMultiset(final Collection c) { return new Multiset<>(c); } /** * New array deque. * * @param * @return */ public static ArrayDeque newArrayDeque() { return new ArrayDeque<>(); } /** * Constructs an empty array deque with an initial capacity sufficient to hold the specified number of elements. * * @param * @param numElements lower bound on initial capacity of the deque. * @return */ public static ArrayDeque newArrayDeque(int numElements) { return new ArrayDeque<>(numElements); } /** * Constructs a deque containing the elements of the specified collection, in the order they are returned by the collection's iterator. * * @param * @param c * @return */ public static ArrayDeque newArrayDeque(Collection c) { return new ArrayDeque<>(c); } /** * * @param the key type * @param the value type * @param key * @param value * @return */ public static Map.Entry newEntry(K key, V value) { return new AbstractMap.SimpleEntry<>(key, value); } /** * New immutable entry. * * @param the key type * @param the value type * @param key * @param value * @return */ public static ImmutableEntry newImmutableEntry(K key, V value) { return new ImmutableEntry<>(key, value); } /** * New hash map. * * @param the key type * @param the value type * @return */ public static Map newHashMap() { return new HashMap<>(); } /** * New hash map. * * @param the key type * @param the value type * @param initialCapacity * @return */ public static Map newHashMap(int initialCapacity) { return new HashMap<>(initialCapacity); } /** * New hash map. * * @param the key type * @param the value type * @param m * @return */ public static Map newHashMap(Map m) { return CommonUtil.isNullOrEmpty(m) ? new HashMap() : new HashMap<>(m); } /** * New hash map. * * @param the key type * @param the value type * @param * @param c * @param keyMapper * @return * @throws E the e */ public static Map newHashMap(final Collection c, final Throwables.Function keyMapper) throws E { CommonUtil.checkArgNotNull(keyMapper); if (isNullOrEmpty(c)) { return new HashMap<>(); } final HashMap result = new HashMap<>(CommonUtil.initHashCapacity(c.size())); for (V v : c) { result.put(keyMapper.apply(v), v); } return result; } /** * New linked hash map. * * @param the key type * @param the value type * @return */ public static Map newLinkedHashMap() { return new LinkedHashMap<>(); } /** * New linked hash map. * * @param the key type * @param the value type * @param initialCapacity * @return */ public static Map newLinkedHashMap(int initialCapacity) { return new LinkedHashMap<>(initialCapacity); } /** * New linked hash map. * * @param the key type * @param the value type * @param m * @return */ public static Map newLinkedHashMap(Map m) { return CommonUtil.isNullOrEmpty(m) ? new LinkedHashMap() : new LinkedHashMap<>(m); } /** * New linked hash map. * * @param the key type * @param the value type * @param * @param c * @param keyMapper * @return * @throws E the e */ public static Map newLinkedHashMap(final Collection c, final Throwables.Function keyMapper) throws E { CommonUtil.checkArgNotNull(keyMapper); if (isNullOrEmpty(c)) { return new LinkedHashMap<>(); } final Map result = new LinkedHashMap<>(CommonUtil.initHashCapacity(c.size())); for (V v : c) { result.put(keyMapper.apply(v), v); } return result; } /** * New tree map. * * @param the key type * @param the value type * @return */ public static , V> TreeMap newTreeMap() { return new TreeMap<>(); } /** * New tree map. * * @param * @param the key type * @param the value type * @param comparator * @return */ public static TreeMap newTreeMap(Comparator comparator) { return new TreeMap<>(comparator); } /** * New tree map. * * @param the key type * @param the value type * @param m * @return */ public static , V> TreeMap newTreeMap(Map m) { return CommonUtil.isNullOrEmpty(m) ? new TreeMap() : new TreeMap<>(m); } /** * New tree map. * * @param the key type * @param the value type * @param m * @return */ public static TreeMap newTreeMap(SortedMap m) { return CommonUtil.isNullOrEmpty(m) ? new TreeMap() : new TreeMap<>(m); } /** * New identity hash map. * * @param the key type * @param the value type * @return */ public static IdentityHashMap newIdentityHashMap() { return new IdentityHashMap<>(); } /** * New identity hash map. * * @param the key type * @param the value type * @param initialCapacity * @return */ public static IdentityHashMap newIdentityHashMap(int initialCapacity) { return new IdentityHashMap<>(initialCapacity); } /** * New identity hash map. * * @param the key type * @param the value type * @param m * @return */ public static IdentityHashMap newIdentityHashMap(Map m) { return CommonUtil.isNullOrEmpty(m) ? new IdentityHashMap() : new IdentityHashMap<>(m); } /** * New concurrent hash map. * * @param the key type * @param the value type * @return */ public static ConcurrentHashMap newConcurrentHashMap() { return new ConcurrentHashMap<>(); } /** * New concurrent hash map. * * @param the key type * @param the value type * @param initialCapacity * @return */ public static ConcurrentHashMap newConcurrentHashMap(int initialCapacity) { return new ConcurrentHashMap<>(initialCapacity); } /** * New concurrent hash map. * * @param the key type * @param the value type * @param m * @return */ public static ConcurrentHashMap newConcurrentHashMap(Map m) { return CommonUtil.isNullOrEmpty(m) ? new ConcurrentHashMap() : new ConcurrentHashMap<>(m); } /** * New bi map. * * @param the key type * @param the value type * @return */ public static BiMap newBiMap() { return new BiMap<>(); } /** * New bi map. * * @param the key type * @param the value type * @param initialCapacity * @return */ public static BiMap newBiMap(int initialCapacity) { return new BiMap<>(initialCapacity); } /** * New bi map. * * @param the key type * @param the value type * @param initialCapacity * @param loadFactor * @return */ public static BiMap newBiMap(int initialCapacity, float loadFactor) { return new BiMap<>(initialCapacity, loadFactor); } /** * New bi map. * * @param the key type * @param the value type * @param keyMapType * @param valueMapType * @return */ @SuppressWarnings("rawtypes") public static BiMap newBiMap(final Class keyMapType, final Class valueMapType) { return new BiMap<>(keyMapType, valueMapType); } /** * New bi map. * * @param the key type * @param the value type * @param keyMapSupplier * @param valueMapSupplier * @return */ public static BiMap newBiMap(final Supplier> keyMapSupplier, final Supplier> valueMapSupplier) { return new BiMap<>(keyMapSupplier, valueMapSupplier); } /** * * @param the key type * @param * @param the value type * @param mapSupplier * @param valueSupplier * @return */ public static > Multimap newMultimap(final Supplier> mapSupplier, final Supplier valueSupplier) { return new Multimap<>(mapSupplier, valueSupplier); } /** * New list multimap. * * @param the key type * @param * @return */ public static ListMultimap newListMultimap() { return new ListMultimap<>(); } /** * New list multimap. * * @param the key type * @param * @param initialCapacity * @return */ public static ListMultimap newListMultimap(final int initialCapacity) { return new ListMultimap<>(initialCapacity); } /** * New list multimap. * * @param the key type * @param * @param m * @return */ public static ListMultimap newListMultimap(final Map m) { final ListMultimap multiMap = newListMultimap(); multiMap.putAll(m); return multiMap; } /** * New list multimap. * * @param the key type * @param * @param mapType * @return */ @SuppressWarnings("rawtypes") public static ListMultimap newListMultimap(final Class mapType) { return new ListMultimap<>(mapType, ArrayList.class); } /** * New list multimap. * * @param the key type * @param * @param mapType * @param valueType * @return */ @SuppressWarnings("rawtypes") public static ListMultimap newListMultimap(final Class mapType, final Class valueType) { return new ListMultimap<>(mapType, valueType); } /** * New list multimap. * * @param the key type * @param * @param mapSupplier * @param valueSupplier * @return */ public static ListMultimap newListMultimap(final Supplier>> mapSupplier, final Supplier> valueSupplier) { return new ListMultimap<>(mapSupplier, valueSupplier); } /** * Return a {@code ListMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value. * * @param the key type * @param * @return */ public static ListMultimap newLinkedListMultimap() { return new ListMultimap<>(LinkedHashMap.class, ArrayList.class); } /** * Return a {@code ListMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value. * * @param the key type * @param * @param initialCapacity * @return */ public static ListMultimap newLinkedListMultimap(final int initialCapacity) { return new ListMultimap<>(new LinkedHashMap>(initialCapacity), ArrayList.class); } /** * Return a {@code ListMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value. * * @param the key type * @param * @param m * @return */ public static ListMultimap newLinkedListMultimap(final Map m) { final ListMultimap multiMap = new ListMultimap<>(new LinkedHashMap>(), ArrayList.class); multiMap.putAll(m); return multiMap; } /** * Return a {@code ListMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value. * * @param the key type * @param * @return */ public static , E> ListMultimap newSortedListMultimap() { return new ListMultimap<>(new TreeMap>(), ArrayList.class); } /** * Return a {@code ListMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value. * * @param the key type * @param * @param m * @return */ public static , E> ListMultimap newSortedListMultimap(final Map m) { final ListMultimap multiMap = new ListMultimap<>(new TreeMap>(), ArrayList.class); multiMap.putAll(m); return multiMap; } /** * New set multimap. * * @param the key type * @param * @return */ public static SetMultimap newSetMultimap() { return new SetMultimap<>(); } /** * New set multimap. * * @param the key type * @param * @param initialCapacity * @return */ public static SetMultimap newSetMultimap(final int initialCapacity) { return new SetMultimap<>(initialCapacity); } /** * New set multimap. * * @param the key type * @param * @param m * @return */ public static SetMultimap newSetMultimap(final Map m) { final SetMultimap multiMap = newSetMultimap(); multiMap.putAll(m); return multiMap; } /** * New set multimap. * * @param the key type * @param * @param mapType * @return */ @SuppressWarnings("rawtypes") public static SetMultimap newSetMultimap(final Class mapType) { return new SetMultimap<>(mapType, HashSet.class); } /** * New set multimap. * * @param the key type * @param * @param mapType * @param valueType * @return */ @SuppressWarnings("rawtypes") public static SetMultimap newSetMultimap(final Class mapType, final Class valueType) { return new SetMultimap<>(mapType, valueType); } /** * New set multimap. * * @param the key type * @param * @param mapSupplier * @param valueSupplier * @return */ public static SetMultimap newSetMultimap(final Supplier>> mapSupplier, final Supplier> valueSupplier) { return new SetMultimap<>(mapSupplier, valueSupplier); } /** * Return a {@code SetMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value. * * @param the key type * @param * @return */ public static SetMultimap newLinkedSetMultimap() { return new SetMultimap<>(LinkedHashMap.class, HashSet.class); } /** * Return a {@code SetMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value. * * @param the key type * @param * @param initialCapacity * @return */ public static SetMultimap newLinkedSetMultimap(final int initialCapacity) { return new SetMultimap<>(new LinkedHashMap>(initialCapacity), HashSet.class); } /** * Return a {@code SetMultimap} backed by {@code LinkedHashMap}. {@code 'Linked'} is about the map, not the value. * * @param the key type * @param * @param m * @return */ public static SetMultimap newLinkedSetMultimap(final Map m) { final SetMultimap multiMap = new SetMultimap<>(new LinkedHashMap>(), HashSet.class); multiMap.putAll(m); return multiMap; } /** * Return a {@code SetMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value. * * * @param the key type * @param * @return */ public static , E> SetMultimap newSortedSetMultimap() { return new SetMultimap<>(new TreeMap>(), HashSet.class); } /** * Return a {@code SetMultimap} backed by {@code SortedMap}. {@code 'Sorted'} is about the map, not the value. * * @param the key type * @param * @param m * @return */ public static , E> SetMultimap newSortedSetMultimap(final Map m) { final SetMultimap multiMap = new SetMultimap<>(new TreeMap>(), HashSet.class); multiMap.putAll(m); return multiMap; } static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; static final int MAX_HASH_LENGTH = (int) (MAX_ARRAY_SIZE / 1.25) - 1; /** * New empty data set. * * @return */ public static DataSet newEmptyDataSet() { return new RowDataSet(new ArrayList(), new ArrayList>()); } /** * New empty data set. * * @param columnNames * @return */ public static DataSet newEmptyDataSet(final Collection columnNames) { if (CommonUtil.isNullOrEmpty(columnNames)) { return newEmptyDataSet(); } final List> columnList = new ArrayList<>(columnNames.size()); for (int i = 0, size = columnNames.size(); i < size; i++) { columnList.add(new ArrayList<>(0)); } return new RowDataSet(new ArrayList<>(columnNames), columnList); } /** * Convert the specified Map to a two columns DataSet: one column is for keys and one column is for values. * * @param keyColumnName * @param valueColumnName * @param m * @return */ public static DataSet newDataSet(final String keyColumnName, final String valueColumnName, final Map m) { final List keyColumn = new ArrayList<>(m.size()); final List valueColumn = new ArrayList<>(m.size()); for (Map.Entry entry : m.entrySet()) { keyColumn.add(entry.getKey()); valueColumn.add(entry.getValue()); } final List columnNameList = CommonUtil.asList(keyColumnName, valueColumnName); final List> columnList = CommonUtil.asList(keyColumn, valueColumn); return newDataSet(columnNameList, columnList); } /** * The first row will be used as column names if its type is array or list, * or obtain the column names from first row if its type is entity or map. * * @param * @param rows list of row which can be: Map/Entity/Array/List * @return */ public static DataSet newDataSet(final Collection rows) { return newDataSet(null, rows); } /** * If the specified {@code columnNames} is null or empty, the first row will be used as column names if its type is array or list, * or obtain the column names from first row if its type is entity or map. * * @param * @param columnNames * @param rows list of row which can be: Map/Entity/Array/List * @return */ public static DataSet newDataSet(Collection columnNames, Collection rowList) { if (CommonUtil.isNullOrEmpty(columnNames) && CommonUtil.isNullOrEmpty(rowList)) { // throw new IllegalArgumentException("Column name list and row list can not be both null or empty"); return CommonUtil.newEmptyDataSet(); } else if (CommonUtil.isNullOrEmpty(rowList)) { return CommonUtil.newEmptyDataSet(columnNames); } int startRowIndex = 0; if (CommonUtil.isNullOrEmpty(columnNames)) { final T firstNonNullRow = N.firstNonNull(rowList).orElse(null); if (firstNonNullRow == null) { return CommonUtil.newEmptyDataSet(); } final Class cls = firstNonNullRow.getClass(); final Type type = CommonUtil.typeOf(cls); if (type.isMap()) { columnNames = new ArrayList<>(((Map) firstNonNullRow).keySet()); } else if (type.isEntity()) { if (N.isDirtyMarker(cls)) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) firstNonNullRow); columnNames = new ArrayList<>(signedPropNames.size()); Method method = null; for (String signedPropName : signedPropNames) { method = ClassUtil.getPropGetMethod(cls, signedPropName); if (method != null) { columnNames.add(ClassUtil.getPropNameByMethod(method)); } } } else { columnNames = new ArrayList<>(ClassUtil.getPropNameList(cls)); } } else if (type.isArray()) { final Object[] a = (Object[]) firstNonNullRow; columnNames = new ArrayList<>(a.length); for (Object e : a) { columnNames.add(N.stringOf(e)); } startRowIndex = 1; } else if (type.isCollection()) { final Collection c = (Collection) firstNonNullRow; columnNames = new ArrayList<>(c.size()); for (Object e : c) { columnNames.add(N.stringOf(e)); } startRowIndex = 1; } else { throw new IllegalArgumentException("Unsupported header type: " + type.name() + " when specified 'columnNames' is null or empty"); } if (CommonUtil.isNullOrEmpty(columnNames)) { throw new IllegalArgumentException("Column name list can not be obtained from row list because it's empty or null"); } } final int rowCount = rowList.size() - startRowIndex; final int columnCount = columnNames.size(); final List columnNameList = new ArrayList<>(columnNames); final List> columnList = new ArrayList<>(columnCount); for (int i = 0; i < columnCount; i++) { columnList.add(new ArrayList<>(rowCount)); } Type type = null; for (Object row : rowList) { if (startRowIndex-- > 0) { // skip continue; } if (row == null) { for (int i = 0; i < columnCount; i++) { columnList.get(i).add(null); } continue; } type = CommonUtil.typeOf(row.getClass()); if (type.isMap()) { Map props = (Map) row; for (int i = 0; i < columnCount; i++) { columnList.get(i).add(props.get(columnNameList.get(i))); } } else if (type.isEntity()) { final Class cls = row.getClass(); final EntityInfo entityInfo = ParserUtil.getEntityInfo(cls); PropInfo propInfo = null; for (int i = 0; i < columnCount; i++) { propInfo = entityInfo.getPropInfo(columnNameList.get(i)); if (propInfo == null) { columnList.get(i).add(null); } else { columnList.get(i).add(propInfo.getPropValue(row)); } } } else if (type.isArray()) { if (type.isPrimitiveArray()) { for (int i = 0; i < columnCount; i++) { columnList.get(i).add(Array.get(row, i)); } } else { Object[] array = (Object[]) row; for (int i = 0; i < columnCount; i++) { columnList.get(i).add(array[i]); } } } else if (type.isCollection()) { final Iterator it = ((Collection) row).iterator(); for (int i = 0; i < columnCount; i++) { columnList.get(i).add(it.next()); } } else { throw new IllegalArgumentException( "Unsupported row type: " + ClassUtil.getCanonicalClassName(row.getClass()) + ". Only array, collection, map and entity are supported"); } } return new RowDataSet(columnNameList, columnList); } public static DataSet newDataSet(Collection columnNames, final Object[][] rowList) { if (CommonUtil.isNullOrEmpty(columnNames) && CommonUtil.isNullOrEmpty(rowList)) { // throw new IllegalArgumentException("Column name list and row list can not be both null or empty"); return CommonUtil.newEmptyDataSet(); } else if (CommonUtil.isNullOrEmpty(rowList)) { return CommonUtil.newEmptyDataSet(columnNames); } N.checkArgument(N.size(columnNames) == N.len(rowList[0]), "length of 'columnNames' is not equals to length of 'rowList[0]'"); return newDataSet(columnNames, N.asList(rowList)); } /** * New data set. * * @param * @param map keys are column names, values are columns * @return */ public static > DataSet newDataSet(final Map map) { if (CommonUtil.isNullOrEmpty(map)) { return CommonUtil.newEmptyDataSet(); } int maxColumnLen = 0; for (C v : map.values()) { maxColumnLen = N.max(maxColumnLen, size(v)); } final List columnNameList = new ArrayList<>(map.keySet()); final List> columnList = new ArrayList<>(columnNameList.size()); List column = null; for (C v : map.values()) { column = new ArrayList<>(maxColumnLen); if (CommonUtil.notNullOrEmpty(v)) { column.addAll(v); } if (column.size() < maxColumnLen) { CommonUtil.fill(column, column.size(), maxColumnLen, null); } columnList.add(column); } return new RowDataSet(columnNameList, columnList); } public static DataSet merge(final DataSet a, final DataSet b) { N.checkArgNotNull(a); N.checkArgNotNull(b); return a.merge(b); } public static DataSet merge(final DataSet a, final DataSet b, final DataSet c) { N.checkArgNotNull(a); N.checkArgNotNull(b); N.checkArgNotNull(c); return merge(N.asList(a, b, c)); } public static DataSet merge(final Collection dss) { if (N.isNullOrEmpty(dss)) { return N.newEmptyDataSet(); } else if (dss.size() == 1) { return N.newEmptyDataSet().merge(dss.iterator().next()); } else if (dss.size() == 2) { final Iterator iter = dss.iterator(); return iter.next().merge(iter.next()); } else { final Set columnNameSet = N.newLinkedHashSet(); final Properties props = new Properties<>(); int totalSize = 0; for (DataSet ds : dss) { columnNameSet.addAll(ds.columnNameList()); totalSize += ds.size(); if (N.notNullOrEmpty(ds.properties())) { props.putAll(ds.properties()); } } final int newColumnCount = columnNameSet.size(); final List newColumnNameList = new ArrayList<>(columnNameSet); final List> newColumnList = new ArrayList<>(newColumnCount); for (int i = 0; i < newColumnCount; i++) { newColumnList.add(new ArrayList<>(totalSize)); } for (DataSet ds : dss) { if (ds.size() == 0) { continue; } List column = null; for (int i = 0; i < newColumnCount; i++) { column = newColumnList.get(i); if (ds.containsColumn(newColumnNameList.get(i))) { column.addAll(ds.getColumn(newColumnNameList.get(i))); } else { N.fill(column, column.size(), column.size() + ds.size(), null); } } } return new RowDataSet(newColumnNameList, newColumnList, props); } } /** * Returns an empty array if the specified collection is null or empty. * * @param c * @return */ @SuppressWarnings("unchecked") public static Object[] toArray(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return CommonUtil.EMPTY_OBJECT_ARRAY; } return c.toArray(new Object[c.size()]); } /** * * @param c * @param fromIndex * @param toIndex * @return */ @SuppressWarnings("rawtypes") public static Object[] toArray(final Collection c, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (CommonUtil.isNullOrEmpty(c)) { return CommonUtil.EMPTY_OBJECT_ARRAY; } else if (fromIndex == 0 || toIndex == c.size()) { return c.toArray(new Object[c.size()]); } else if (c instanceof List) { return ((List) c).subList(fromIndex, toIndex).toArray(new Object[toIndex - fromIndex]); } else { final Object[] res = new Object[toIndex - fromIndex]; final Iterator iter = c.iterator(); int idx = 0; while (idx < fromIndex && iter.hasNext()) { iter.next(); idx++; } while (idx < toIndex && iter.hasNext()) { res[idx - fromIndex] = iter.next(); idx++; } return res; } } /** * * @param * @param * @param c * @param a * @return * @throws IllegalArgumentException if the specified {@code Array} is null. */ public static A[] toArray(final Collection c, final A[] a) throws IllegalArgumentException { CommonUtil.checkArgNotNull(a); if (CommonUtil.isNullOrEmpty(c)) { return a; } return c.toArray(a); } /** * * @param * @param * @param c * @param fromIndex * @param toIndex * @param a * @return * @throws IllegalArgumentException if the specified {@code Array} is null. */ public static A[] toArray(final Collection c, final int fromIndex, final int toIndex, final A[] a) throws IllegalArgumentException { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); CommonUtil.checkArgNotNull(a); if (CommonUtil.isNullOrEmpty(c)) { return a; } else if (fromIndex == 0 || toIndex == c.size()) { return c.toArray(a); } else if (c instanceof List) { return ((List) c).subList(fromIndex, toIndex).toArray(a); } else { final A[] res = a.length >= toIndex - fromIndex ? a : (A[]) CommonUtil.newArray(a.getClass().getComponentType(), toIndex - fromIndex); final Iterator iter = c.iterator(); int idx = 0; while (idx < fromIndex && iter.hasNext()) { iter.next(); idx++; } while (idx < toIndex && iter.hasNext()) { res[idx - fromIndex] = iter.next(); idx++; } return res; } } /** * * @param * @param * @param c * @param arraySupplier * @return */ public static A[] toArray(final Collection c, final IntFunction arraySupplier) { CommonUtil.checkArgNotNull(arraySupplier); if (CommonUtil.isNullOrEmpty(c)) { return arraySupplier.apply(0); } return toArray(c, arraySupplier); } /** * * @param * @param * @param c * @param fromIndex * @param toIndex * @param arraySupplier * @return */ public static A[] toArray(final Collection c, final int fromIndex, final int toIndex, final IntFunction arraySupplier) { CommonUtil.checkArgNotNull(arraySupplier); CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (CommonUtil.isNullOrEmpty(c)) { return arraySupplier.apply(0); } else if (fromIndex == 0 || toIndex == c.size()) { return c.toArray(arraySupplier.apply(c.size())); } else if (c instanceof List) { return ((List) c).subList(fromIndex, toIndex).toArray(arraySupplier.apply(toIndex - fromIndex)); } else { final A[] res = arraySupplier.apply(toIndex - fromIndex); final Iterator iter = c.iterator(); int idx = 0; while (idx < fromIndex && iter.hasNext()) { iter.next(); idx++; } while (idx < toIndex && iter.hasNext()) { res[idx - fromIndex] = iter.next(); idx++; } return res; } } /** * * @param * @param * @param targetClass * @param c * @return * @throws IllegalArgumentException if the specified {@code Class} is null. */ public static A[] toArray(final Class targetClass, final Collection c) throws IllegalArgumentException { CommonUtil.checkArgNotNull(targetClass); if (CommonUtil.isNullOrEmpty(c)) { return CommonUtil.newArray(targetClass.getComponentType(), 0); } return c.toArray((A[]) CommonUtil.newArray(targetClass.getComponentType(), c.size())); } /** * * @param * @param * @param targetClass * @param c * @param fromIndex * @param toIndex * @return * @throws IllegalArgumentException if the specified {@code Class} is null. */ public static A[] toArray(final Class targetClass, final Collection c, final int fromIndex, final int toIndex) throws IllegalArgumentException { CommonUtil.checkArgNotNull(targetClass); CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); final A[] res = CommonUtil.newArray(targetClass.getComponentType(), toIndex - fromIndex); if (CommonUtil.isNullOrEmpty(c)) { return res; } else if (fromIndex == 0 || toIndex == c.size()) { return c.toArray(res); } else if (c instanceof List) { return ((List) c).subList(fromIndex, toIndex).toArray(res); } else { final Iterator iter = c.iterator(); int idx = 0; while (idx < fromIndex && iter.hasNext()) { iter.next(); idx++; } while (idx < toIndex && iter.hasNext()) { res[idx - fromIndex] = iter.next(); idx++; } return res; } } /** * To boolean array. * * @param c * @return */ public static boolean[] toBooleanArray(final Collection c) { return toBooleanArray(c, false); } /** * To boolean array. * * @param c * @param fromIndex * @param toIndex * @return */ public static boolean[] toBooleanArray(final Collection c, final int fromIndex, final int toIndex) { return toBooleanArray(c, fromIndex, toIndex, false); } /** * To boolean array. * * @param c * @param defaultForNull * @return */ public static boolean[] toBooleanArray(final Collection c, final boolean defaultForNull) { return toBooleanArray(c, 0, size(c), defaultForNull); } /** * To boolean array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static boolean[] toBooleanArray(final Collection c, final int fromIndex, final int toIndex, final boolean defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_BOOLEAN_ARRAY; } final int len = toIndex - fromIndex; boolean[] result = new boolean[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Boolean val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val; } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Boolean val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val; } } } return result; } /** * To char array. * * @param c * @return */ public static char[] toCharArray(final Collection c) { return toCharArray(c, (char) 0); } /** * To char array. * * @param c * @param fromIndex * @param toIndex * @return */ public static char[] toCharArray(final Collection c, final int fromIndex, final int toIndex) { return toCharArray(c, fromIndex, toIndex, (char) 0); } /** * To char array. * * @param c * @param defaultForNull * @return */ public static char[] toCharArray(final Collection c, final char defaultForNull) { return toCharArray(c, 0, size(c), defaultForNull); } /** * To char array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static char[] toCharArray(final Collection c, final int fromIndex, final int toIndex, final char defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_CHAR_ARRAY; } final int len = toIndex - fromIndex; char[] result = new char[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Character val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val; } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Character val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val; } } } return result; } /** * To byte array. * * @param c * @return */ public static byte[] toByteArray(final Collection c) { return toByteArray(c, (byte) 0); } /** * To byte array. * * @param c * @param fromIndex * @param toIndex * @return */ public static byte[] toByteArray(final Collection c, final int fromIndex, final int toIndex) { return toByteArray(c, fromIndex, toIndex, (byte) 0); } /** * To byte array. * * @param c * @param defaultForNull * @return */ public static byte[] toByteArray(final Collection c, final byte defaultForNull) { return toByteArray(c, 0, size(c), defaultForNull); } /** * To byte array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static byte[] toByteArray(final Collection c, final int fromIndex, final int toIndex, final byte defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_BYTE_ARRAY; } final int len = toIndex - fromIndex; byte[] result = new byte[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Number val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val.byteValue(); } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Number val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val.byteValue(); } } } return result; } /** * To short array. * * @param c * @return */ public static short[] toShortArray(final Collection c) { return toShortArray(c, (short) 0); } /** * To short array. * * @param c * @param fromIndex * @param toIndex * @return */ public static short[] toShortArray(final Collection c, final int fromIndex, final int toIndex) { return toShortArray(c, fromIndex, toIndex, (short) 0); } /** * To short array. * * @param c * @param defaultForNull * @return */ public static short[] toShortArray(final Collection c, final short defaultForNull) { return toShortArray(c, 0, size(c), defaultForNull); } /** * To short array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static short[] toShortArray(final Collection c, final int fromIndex, final int toIndex, final short defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_SHORT_ARRAY; } final int len = toIndex - fromIndex; short[] result = new short[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Number val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val.shortValue(); } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Number val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val.shortValue(); } } } return result; } /** * To int array. * * @param c * @return */ public static int[] toIntArray(final Collection c) { return toIntArray(c, 0); } /** * To int array. * * @param c * @param fromIndex * @param toIndex * @return */ public static int[] toIntArray(final Collection c, final int fromIndex, final int toIndex) { return toIntArray(c, fromIndex, toIndex, 0); } /** * To int array. * * @param c * @param defaultForNull * @return */ public static int[] toIntArray(final Collection c, final int defaultForNull) { return toIntArray(c, 0, size(c), defaultForNull); } /** * To int array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static int[] toIntArray(final Collection c, final int fromIndex, final int toIndex, final int defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_INT_ARRAY; } final int len = toIndex - fromIndex; int[] result = new int[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Number val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val.intValue(); } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Number val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val.intValue(); } } } return result; } /** * To long array. * * @param c * @return */ public static long[] toLongArray(final Collection c) { return toLongArray(c, 0); } /** * To long array. * * @param c * @param fromIndex * @param toIndex * @return */ public static long[] toLongArray(final Collection c, final int fromIndex, final int toIndex) { return toLongArray(c, fromIndex, toIndex, 0); } /** * To long array. * * @param c * @param defaultForNull * @return */ public static long[] toLongArray(final Collection c, final long defaultForNull) { return toLongArray(c, 0, size(c), defaultForNull); } /** * To long array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static long[] toLongArray(final Collection c, final int fromIndex, final int toIndex, final long defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_LONG_ARRAY; } final int len = toIndex - fromIndex; long[] result = new long[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Number val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val.longValue(); } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Number val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val.longValue(); } } } return result; } /** * To float array. * * @param c * @return */ public static float[] toFloatArray(final Collection c) { return toFloatArray(c, 0); } /** * To float array. * * @param c * @param fromIndex * @param toIndex * @return */ public static float[] toFloatArray(final Collection c, final int fromIndex, final int toIndex) { return toFloatArray(c, fromIndex, toIndex, 0); } /** * To float array. * * @param c * @param defaultForNull * @return */ public static float[] toFloatArray(final Collection c, final float defaultForNull) { return toFloatArray(c, 0, size(c), defaultForNull); } /** * To float array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static float[] toFloatArray(final Collection c, final int fromIndex, final int toIndex, final float defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_FLOAT_ARRAY; } final int len = toIndex - fromIndex; float[] result = new float[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Number val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val.floatValue(); } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Number val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val.floatValue(); } } } return result; } /** * To double array. * * @param c * @return */ public static double[] toDoubleArray(final Collection c) { return toDoubleArray(c, 0); } /** * To double array. * * @param c * @param fromIndex * @param toIndex * @return */ public static double[] toDoubleArray(final Collection c, final int fromIndex, final int toIndex) { return toDoubleArray(c, fromIndex, toIndex, 0); } /** * To double array. * * @param c * @param defaultForNull * @return */ public static double[] toDoubleArray(final Collection c, final double defaultForNull) { return toDoubleArray(c, 0, size(c), defaultForNull); } /** * To double array. * * @param c * @param fromIndex * @param toIndex * @param defaultForNull * @return */ public static double[] toDoubleArray(final Collection c, final int fromIndex, final int toIndex, final double defaultForNull) { CommonUtil.checkFromToIndex(fromIndex, toIndex, size(c)); if (fromIndex == toIndex) { return EMPTY_DOUBLE_ARRAY; } final int len = toIndex - fromIndex; double[] result = new double[len]; if (c instanceof List && c instanceof RandomAccess) { final List list = (List) c; Number val = null; for (int i = 0; i < len; i++) { if ((val = list.get(i + fromIndex)) == null) { result[i] = defaultForNull; } else { result[i] = val.doubleValue(); } } } else { final Iterator iter = c.iterator(); if (fromIndex > 0) { int offset = 0; while (offset++ < fromIndex) { iter.next(); } } Number val = null; for (int i = 0; i < len; i++) { if ((val = iter.next()) == null) { result[i] = defaultForNull; } else { result[i] = val.doubleValue(); } } } return result; } /** * * @param a * @return */ public static List toList(final boolean[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final boolean[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final char[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final char[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final byte[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final byte[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final short[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final short[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final int[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final int[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final long[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final long[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final float[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final float[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static List toList(final double[] a) { return toList(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final double[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @return */ public static List toList(final T[] a) { if (CommonUtil.isNullOrEmpty(a)) { return new ArrayList<>(); } return CommonUtil.asList(a); } /** * * @param * @param a * @param fromIndex * @param toIndex * @return */ public static List toList(final T[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return new ArrayList<>(); } else if (fromIndex == 0 && toIndex == a.length) { return CommonUtil.asList(a); } final List result = new ArrayList<>(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final boolean[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final boolean[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final char[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final char[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final byte[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final byte[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final short[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final short[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final int[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final int[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final long[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final long[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final float[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final float[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param a * @return */ public static Set toSet(final double[] a) { return toSet(a, 0, len(a)); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final double[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @return */ public static Set toSet(final T[] a) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.newHashSet(); } return CommonUtil.asSet(a); } /** * * @param * @param a * @param fromIndex * @param toIndex * @return */ public static Set toSet(final T[] a, final int fromIndex, final int toIndex) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return CommonUtil.newHashSet(); } final Set result = CommonUtil.newHashSet(CommonUtil.initHashCapacity(toIndex - fromIndex)); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final boolean[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final boolean[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final char[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final char[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final byte[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final byte[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final short[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final short[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final int[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final int[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final long[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final long[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final float[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final float[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param a * @param supplier * @return */ public static > C toCollection(final double[] a, final IntFunction supplier) { return toCollection(a, 0, len(a), supplier); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final double[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } /** * * @param * @param * @param a * @param supplier * @return */ public static > C toCollection(final T[] a, final IntFunction supplier) { if (CommonUtil.isNullOrEmpty(a)) { return supplier.apply(0); } return toCollection(a, 0, a.length, supplier); } /** * * @param * @param * @param a * @param fromIndex * @param toIndex * @param supplier * @return */ public static > C toCollection(final T[] a, final int fromIndex, final int toIndex, final IntFunction supplier) { CommonUtil.checkFromToIndex(fromIndex, toIndex, len(a)); if (fromIndex == toIndex) { return supplier.apply(0); } else if (fromIndex == 0 && toIndex == a.length && a.length >= MIN_SIZE_FOR_COPY_ALL) { final C result = supplier.apply(a.length); result.addAll(Arrays.asList(a)); return result; } else { final C result = supplier.apply(toIndex - fromIndex); for (int i = fromIndex; i < toIndex; i++) { result.add(a[i]); } return result; } } /** * The input array is returned. * * @param * @param a * @return */ @SafeVarargs public static T[] asArray(final T... a) { return a; } /** * * @param the key type * @param the value type * @param * @param m * @param a * @return */ @SuppressWarnings("unchecked") static > T newMap(final T m, final Object... a) { if (isNullOrEmpty(a)) { return m; } if (a.length == 1) { if (a[0] instanceof Map) { m.putAll((Map) a[0]); } else if (ClassUtil.isEntity(a[0].getClass())) { Maps.entity2Map((Map) m, a[0]); } else { throw new IllegalArgumentException( "The parameters must be the pairs of property name and value, or Map, or an entity class with getter/setter methods."); } } else { if (0 != (a.length % 2)) { throw new IllegalArgumentException( "The parameters must be the pairs of property name and value, or Map, or an entity class with getter/setter methods."); } for (int i = 0; i < a.length; i++) { m.put((K) a[i], (V) a[++i]); } } return m; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @return */ public static Map asMap(final K k1, final V v1) { final Map map = new HashMap<>(1); map.put(k1, v1); return map; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @return */ public static Map asMap(final K k1, final V v1, final K k2, final V v2) { final Map map = new HashMap<>(2); map.put(k1, v1); map.put(k2, v2); return map; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @return */ public static Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3) { final Map map = new HashMap<>(3); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); return map; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @return */ public static Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4) { final Map map = new HashMap<>(4); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); return map; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @param k5 * @param v5 * @return */ public static Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5) { final Map map = new HashMap<>(5); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); map.put(k5, v5); return map; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @param k5 * @param v5 * @param k6 * @param v6 * @return */ public static Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5, final K k6, final V v6) { final Map map = new HashMap<>(6); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); map.put(k5, v5); map.put(k6, v6); return map; } /** * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @param k5 * @param v5 * @param k6 * @param v6 * @param k7 * @param v7 * @return */ public static Map asMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5, final K k6, final V v6, final K k7, final V v7) { final Map map = new HashMap<>(7); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); map.put(k5, v5); map.put(k6, v6); map.put(k7, v7); return map; } /** * * @param the key type * @param the value type * @param a * @return * @deprecated */ @Deprecated @SafeVarargs @NullSafe public static Map asMap(final Object... a) { if (CommonUtil.isNullOrEmpty(a)) { return new HashMap<>(); } return newMap(new HashMap(CommonUtil.initHashCapacity(a.length / 2)), a); } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @return */ public static Map asLinkedHashMap(final K k1, final V v1) { final Map map = new LinkedHashMap<>(1); map.put(k1, v1); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @return */ public static Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2) { final Map map = new LinkedHashMap<>(2); map.put(k1, v1); map.put(k2, v2); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @return */ public static Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3) { final Map map = new LinkedHashMap<>(3); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @return */ public static Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4) { final Map map = new LinkedHashMap<>(4); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @param k5 * @param v5 * @return */ public static Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5) { final Map map = new LinkedHashMap<>(5); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); map.put(k5, v5); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @param k5 * @param v5 * @param k6 * @param v6 * @return */ public static Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5, final K k6, final V v6) { final Map map = new LinkedHashMap<>(6); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); map.put(k5, v5); map.put(k6, v6); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param * @param * @param k1 * @param v1 * @param k2 * @param v2 * @param k3 * @param v3 * @param k4 * @param v4 * @param k5 * @param v5 * @param k6 * @param v6 * @param k7 * @param v7 * @return */ public static Map asLinkedHashMap(final K k1, final V v1, final K k2, final V v2, final K k3, final V v3, final K k4, final V v4, final K k5, final V v5, final K k6, final V v6, final K k7, final V v7) { final Map map = new LinkedHashMap<>(7); map.put(k1, v1); map.put(k2, v2); map.put(k3, v3); map.put(k4, v4); map.put(k5, v5); map.put(k6, v6); map.put(k7, v7); return map; } /** * As linked hash map. * * @param the key type * @param the value type * @param a * @return * @deprecated */ @Deprecated @SafeVarargs public static Map asLinkedHashMap(final Object... a) { if (CommonUtil.isNullOrEmpty(a)) { return new LinkedHashMap<>(); } return newMap(new LinkedHashMap(CommonUtil.initHashCapacity(a.length / 2)), a); } public static Map asProps(final String propName, final Object propValue) { final Map props = new LinkedHashMap<>(1); props.put(propName, propValue); return props; } public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2) { final Map props = new LinkedHashMap<>(2); props.put(propName1, propValue1); props.put(propName2, propValue2); return props; } public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2, final String propName3, final Object propValue3) { final Map props = new LinkedHashMap<>(3); props.put(propName1, propValue1); props.put(propName2, propValue2); props.put(propName3, propValue3); return props; } public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2, final String propName3, final Object propValue3, final String propName4, final Object propValue4) { final Map props = new LinkedHashMap<>(4); props.put(propName1, propValue1); props.put(propName2, propValue2); props.put(propName3, propValue3); props.put(propName4, propValue4); return props; } public static Map asProps(final String propName1, final Object propValue1, final String propName2, final Object propValue2, final String propName3, final Object propValue3, final String propName4, final Object propValue4, final String propName5, final Object propValue5) { final Map props = new LinkedHashMap<>(5); props.put(propName1, propValue1); props.put(propName2, propValue2); props.put(propName3, propValue3); props.put(propName4, propValue4); props.put(propName5, propValue5); return props; } /** * * @param a pairs of property name and value or a Java Entity Object what * allows access to properties using getter and setter methods. * @return * @deprecated */ @Deprecated @SafeVarargs public static Map asProps(final Object... a) { if (CommonUtil.isNullOrEmpty(a)) { return new LinkedHashMap<>(); } return newMap(new LinkedHashMap(CommonUtil.initHashCapacity(a.length / 2)), a); } /** * * @param * @param e * @return */ public static List asList(final T e) { final List list = new ArrayList<>(1); list.add(e); return list; } /** * * @param * @param e1 * @param e2 * @return */ public static List asList(final T e1, final T e2) { final List list = new ArrayList<>(2); list.add(e1); list.add(e2); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @return */ public static List asList(final T e1, final T e2, final T e3) { final List list = new ArrayList<>(3); list.add(e1); list.add(e2); list.add(e3); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @return */ public static List asList(final T e1, final T e2, final T e3, final T e4) { final List list = new ArrayList<>(4); list.add(e1); list.add(e2); list.add(e3); list.add(e4); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @return */ public static List asList(final T e1, final T e2, final T e3, final T e4, final T e5) { final List list = new ArrayList<>(5); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @return */ public static List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) { final List list = new ArrayList<>(6); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); list.add(e6); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @return */ public static List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) { final List list = new ArrayList<>(7); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); list.add(e6); list.add(e7); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @param e8 * @return */ public static List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8) { final List list = new ArrayList<>(8); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); list.add(e6); list.add(e7); list.add(e8); return list; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @param e8 * @param e9 * @return */ public static List asList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8, final T e9) { final List list = new ArrayList<>(9); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); list.add(e6); list.add(e7); list.add(e8); list.add(e9); return list; } /** * * @param * @param a * @return */ @SafeVarargs @NullSafe public static List asList(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new ArrayList<>(); } final List list = new ArrayList<>(a.length); if (a.length < MIN_SIZE_FOR_COPY_ALL) { for (T e : a) { list.add(e); } } else { list.addAll(Arrays.asList(a)); } return list; } /** * As linked list. * * @param * @param e * @return */ public static LinkedList asLinkedList(final T e) { final LinkedList list = new LinkedList<>(); list.add(e); return list; } /** * As linked list. * * @param * @param e1 * @param e2 * @return */ public static LinkedList asLinkedList(final T e1, final T e2) { final LinkedList list = new LinkedList<>(); list.add(e1); list.add(e2); return list; } /** * As linked list. * * @param * @param e1 * @param e2 * @param e3 * @return */ public static LinkedList asLinkedList(final T e1, final T e2, final T e3) { final LinkedList list = new LinkedList<>(); list.add(e1); list.add(e2); list.add(e3); return list; } /** * As linked list. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @return */ public static LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4) { final LinkedList list = new LinkedList<>(); list.add(e1); list.add(e2); list.add(e3); list.add(e4); return list; } /** * As linked list. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @return */ public static LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4, final T e5) { final LinkedList list = new LinkedList<>(); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); return list; } /** * As linked list. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @return */ public static LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) { final LinkedList list = new LinkedList<>(); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); list.add(e6); return list; } /** * As linked list. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @return */ public static LinkedList asLinkedList(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) { final LinkedList list = new LinkedList<>(); list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); list.add(e6); list.add(e7); return list; } /** * As linked list. * * @param * @param a * @return */ @SafeVarargs @NullSafe public static LinkedList asLinkedList(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new LinkedList<>(); } final LinkedList list = new LinkedList<>(); for (T e : a) { list.add(e); } return list; } /** * * @param * @param e * @return */ public static Set asSet(final T e) { final Set set = CommonUtil.newHashSet(1); set.add(e); return set; } /** * * @param * @param e1 * @param e2 * @return */ public static Set asSet(final T e1, final T e2) { final Set set = CommonUtil.newHashSet(2); set.add(e1); set.add(e2); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @return */ public static Set asSet(final T e1, final T e2, final T e3) { final Set set = CommonUtil.newHashSet(3); set.add(e1); set.add(e2); set.add(e3); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @return */ public static Set asSet(final T e1, final T e2, final T e3, final T e4) { final Set set = CommonUtil.newHashSet(4); set.add(e1); set.add(e2); set.add(e3); set.add(e4); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @return */ public static Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5) { final Set set = CommonUtil.newHashSet(5); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @return */ public static Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) { final Set set = CommonUtil.newHashSet(6); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); set.add(e6); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @return */ public static Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) { final Set set = CommonUtil.newHashSet(7); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); set.add(e6); set.add(e7); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @param e8 * @return */ public static Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8) { final Set set = CommonUtil.newHashSet(8); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); set.add(e6); set.add(e7); set.add(e8); return set; } /** * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @param e8 * @param e9 * @return */ public static Set asSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7, final T e8, final T e9) { final Set set = CommonUtil.newHashSet(9); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); set.add(e6); set.add(e7); set.add(e8); set.add(e9); return set; } /** * * @param * @param a * @return */ @SafeVarargs @NullSafe public static Set asSet(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.newHashSet(); } final Set set = CommonUtil.newHashSet(CommonUtil.initHashCapacity(a.length)); for (T e : a) { set.add(e); } return set; } /** * As linked linked hash set. * * @param * @param e * @return */ public static Set asLinkedHashSet(final T e) { final Set set = CommonUtil.newLinkedHashSet(1); set.add(e); return set; } /** * As linked linked hash set. * * @param * @param e1 * @param e2 * @return */ public static Set asLinkedHashSet(final T e1, final T e2) { final Set set = CommonUtil.newLinkedHashSet(2); set.add(e1); set.add(e2); return set; } /** * As linked linked hash set. * * @param * @param e1 * @param e2 * @param e3 * @return */ public static Set asLinkedHashSet(final T e1, final T e2, final T e3) { final Set set = CommonUtil.newLinkedHashSet(3); set.add(e1); set.add(e2); set.add(e3); return set; } /** * As linked linked hash set. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @return */ public static Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4) { final Set set = CommonUtil.newLinkedHashSet(4); set.add(e1); set.add(e2); set.add(e3); set.add(e4); return set; } /** * As linked linked hash set. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @return */ public static Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4, final T e5) { final Set set = CommonUtil.newLinkedHashSet(5); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); return set; } /** * As linked linked hash set. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @return */ public static Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6) { final Set set = CommonUtil.newLinkedHashSet(6); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); set.add(e6); return set; } /** * As linked linked hash set. * * @param * @param e1 * @param e2 * @param e3 * @param e4 * @param e5 * @param e6 * @param e7 * @return */ public static Set asLinkedHashSet(final T e1, final T e2, final T e3, final T e4, final T e5, final T e6, final T e7) { final Set set = CommonUtil.newLinkedHashSet(7); set.add(e1); set.add(e2); set.add(e3); set.add(e4); set.add(e5); set.add(e6); set.add(e7); return set; } /** * As linked hash set. * * @param * @param a * @return */ @SafeVarargs @NullSafe public static Set asLinkedHashSet(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.newLinkedHashSet(); } final Set set = CommonUtil.newLinkedHashSet(CommonUtil.initHashCapacity(a.length)); for (T e : a) { set.add(e); } return set; } /** * As sorted set. * * @param * @param a * @return */ @SafeVarargs @NullSafe public static SortedSet asSortedSet(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new TreeSet<>(); } final SortedSet set = new TreeSet<>(); for (T e : a) { set.add(e); } return set; } /** * As navigable set. * * @param * @param a * @return */ @SafeVarargs public static NavigableSet asNavigableSet(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new TreeSet<>(); } final NavigableSet set = new TreeSet<>(); for (T e : a) { set.add(e); } return set; } /** * * @param * @param a * @return */ @SafeVarargs public static Queue asQueue(final T... a) { return asArrayDeque(a); } /** * As array blocking queue. * * @param * @param a * @return */ @SafeVarargs public static ArrayBlockingQueue asArrayBlockingQueue(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new ArrayBlockingQueue<>(0); } final ArrayBlockingQueue queue = new ArrayBlockingQueue<>(a.length); for (T e : a) { queue.add(e); } return queue; } /** * As linked blocking queue. * * @param * @param a * @return */ @SafeVarargs public static LinkedBlockingQueue asLinkedBlockingQueue(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new LinkedBlockingQueue<>(); } final LinkedBlockingQueue queue = new LinkedBlockingQueue<>(a.length); for (T e : a) { queue.add(e); } return queue; } /** * As concurrent linked queue. * * @param * @param a * @return */ @SafeVarargs public static ConcurrentLinkedQueue asConcurrentLinkedQueue(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new ConcurrentLinkedQueue<>(); } final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue<>(); for (T e : a) { queue.add(e); } return queue; } /** * As delay queue. * * @param * @param a * @return */ @SafeVarargs public static DelayQueue asDelayQueue(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new DelayQueue<>(); } final DelayQueue queue = new DelayQueue<>(); for (T e : a) { queue.add(e); } return queue; } /** * As priority queue. * * @param * @param a * @return */ @SafeVarargs public static PriorityQueue asPriorityQueue(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new PriorityQueue<>(); } final PriorityQueue queue = new PriorityQueue<>(a.length); for (T e : a) { queue.add(e); } return queue; } /** * * @param * @param a * @return */ @SafeVarargs public static Deque asDeque(final T... a) { return asArrayDeque(a); } /** * As array deque. * * @param * @param a * @return */ @SafeVarargs public static ArrayDeque asArrayDeque(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new ArrayDeque<>(); } final ArrayDeque arrayDeque = new ArrayDeque<>(a.length); for (T e : a) { arrayDeque.add(e); } return arrayDeque; } /** * As linked blocking deque. * * @param * @param a * @return */ @SafeVarargs public static LinkedBlockingDeque asLinkedBlockingDeque(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new LinkedBlockingDeque<>(); } final LinkedBlockingDeque deque = new LinkedBlockingDeque<>(a.length); for (T e : a) { deque.add(e); } return deque; } /** * As concurrent linked deque. * * @param * @param a * @return */ @SafeVarargs public static ConcurrentLinkedDeque asConcurrentLinkedDeque(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return new ConcurrentLinkedDeque<>(); } final ConcurrentLinkedDeque deque = new ConcurrentLinkedDeque<>(); for (T e : a) { deque.add(e); } return deque; } /** * * @param * @param a * @return */ @SafeVarargs public static Multiset asMultiset(final T... a) { return Multiset.of(a); } /** * Wrap the specified value with a singleton list. * * @param * @param o * @return an immutable list * @see java.util.Collections#singletonList(Object) */ @Immutable public static List asSingletonList(final T o) { return Collections.singletonList(o); } /** * Wrap the specified value with a singleton set. * * @param * @param o * @return an immutable set * @see java.util.Collections#singleton(Object) */ @Immutable public static Set asSingletonSet(final T o) { return Collections.singleton(o); } /** * Wrap the specified key/value with a singleton map. * * @param the key type * @param the value type * @param key * @param value * @return an immutable Map * @see java.util.Collections#singletonMap(Object, Object) */ @Immutable public static Map asSingletonMap(final K key, final V value) { return Collections.singletonMap(key, value); } /** * Try to convert the specified {@code obj} to the specified * {@code targetClass}. Default value of {@code targetClass} is returned if * {@code sourceObject} is null. An instance of {@code targetClass} is returned if * convert successfully * * @param * @param obj * @param targetClass * @return */ public static T convert(final Object obj, final Class targetClass) { if (obj == null) { return CommonUtil.defaultValueOf(targetClass); } final Type type = typeOf(targetClass); return convert(obj, type); } /** * * @param * @param obj * @param targetType * @return */ @SuppressWarnings({ "unchecked", "rawtypes" }) public static T convert(final Object obj, final Type targetType) { if (obj == null) { return targetType.defaultValue(); } final Class srcPropClass = obj.getClass(); if (targetType.clazz().isAssignableFrom(srcPropClass)) { return (T) obj; } final Type srcPropType = typeOf(srcPropClass); if (targetType.isBoolean() && srcPropType.isNumber()) { return (T) ((Boolean) (((Number) obj).longValue() > 0)); } if (targetType.isEntity()) { if (srcPropType.isEntity()) { return copy(targetType.clazz(), obj); } else if (srcPropType.isMap()) { return Maps.map2Entity(targetType.clazz(), (Map) obj); } } else if (targetType.isMap()) { if (srcPropType.isEntity() && targetType.getParameterTypes()[0].clazz().isAssignableFrom(String.class) && Object.class.equals(targetType.getParameterTypes()[1].clazz())) { try { return (T) Maps.entity2Map((Map) CommonUtil.newInstance(targetType.clazz()), obj); } catch (Exception e) { // ignore. } } else if (srcPropType.isMap() && Object.class.equals(targetType.getParameterTypes()[0].clazz()) && Object.class.equals(targetType.getParameterTypes()[1].clazz())) { final Map result = (Map) CommonUtil.newInstance(targetType.clazz()); result.putAll((Map) obj); return (T) result; } } if (targetType.isCollection()) { if (srcPropType.isCollection() && Object.class.equals(targetType.getParameterTypes()[0].clazz())) { final Collection result = (Collection) CommonUtil.newInstance(targetType.clazz()); result.addAll((Collection) obj); return (T) result; } } if (targetType.isNumber() && srcPropType.isNumber() && CLASS_TYPE_ENUM.containsKey(targetType.clazz())) { switch (CLASS_TYPE_ENUM.get(targetType.clazz())) { case 3: case 23: return (T) (Byte) ((Number) obj).byteValue(); case 4: case 24: return (T) (Short) ((Number) obj).shortValue(); case 5: case 25: return (T) (Integer) ((Number) obj).intValue(); case 6: case 26: return (T) (Long) ((Number) obj).longValue(); case 7: case 27: return (T) (Float) ((Number) obj).floatValue(); case 8: case 28: return (T) (Double) ((Number) obj).doubleValue(); } } else if ((targetType.clazz().equals(int.class) || targetType.clazz().equals(Integer.class)) && srcPropType.clazz().equals(Character.class)) { return (T) (Integer.valueOf(((Character) obj).charValue())); } else if ((targetType.clazz().equals(char.class) || targetType.clazz().equals(Character.class)) && srcPropType.clazz().equals(Integer.class)) { return (T) (Character.valueOf((char) ((Integer) obj).intValue())); } else if (targetType.clazz().equals(byte[].class) && srcPropType.clazz().equals(Blob.class)) { final Blob blob = (Blob) obj; try { return (T) blob.getBytes(1, (int) blob.length()); } catch (SQLException e) { throw new UncheckedSQLException(e); } finally { try { blob.free(); } catch (SQLException e) { throw new UncheckedSQLException(e); } } } else if (targetType.clazz().equals(char[].class) && srcPropType.clazz().equals(Clob.class)) { final Clob clob = (Clob) obj; try { return (T) clob.getSubString(1, (int) clob.length()).toCharArray(); } catch (SQLException e) { throw new UncheckedSQLException(e); } finally { try { clob.free(); } catch (SQLException e) { throw new UncheckedSQLException(e); } } } else if (targetType.clazz().equals(String.class) && srcPropType.clazz().equals(Clob.class)) { final Clob clob = (Clob) obj; try { return (T) clob.getSubString(1, (int) clob.length()); } catch (SQLException e) { throw new UncheckedSQLException(e); } finally { try { clob.free(); } catch (SQLException e) { throw new UncheckedSQLException(e); } } } return targetType.valueOf(obj); } /** * Returns a Boolean with a value represented by the specified * string. The Boolean returned represents a true value if the * string argument is not null and is equal, ignoring case, to * the string {@code "true"}. * * @param str * a string. * @return */ public static boolean parseBoolean(final String str) { return isNullOrEmpty(str) ? false : Boolean.valueOf(str); } /** * Parses the char. * * @param str * @return */ public static char parseChar(final String str) { return isNullOrEmpty(str) ? CHAR_0 : ((str.length() == 1) ? str.charAt(0) : (char) Integer.parseInt(str)); } /** * Returns the value by calling {@code Byte.valueOf(String)} if {@code str} * is not {@code null}, otherwise, the default value 0 for {@code byte} is * returned. * * @param str * @return */ public static byte parseByte(final String str) { if (CommonUtil.isNullOrEmpty(str)) { return 0; } if (str.length() < 5) { Integer result = stringIntCache.get(str); if (result != null) { if (result.intValue() < Byte.MIN_VALUE || result.intValue() > Byte.MAX_VALUE) { throw new NumberFormatException("Value out of range. Value:\"" + str + "\" Radix: 10"); } return result.byteValue(); } } return Byte.parseByte(str); } /** * Returns the value by calling {@code Short.valueOf(String)} if {@code str} * is not {@code null}, otherwise, the default value 0 for {@code short} is * returned. * * @param str * @return */ public static short parseShort(final String str) { if (CommonUtil.isNullOrEmpty(str)) { return 0; } if (str.length() < 5) { Integer result = stringIntCache.get(str); if (result != null) { return result.shortValue(); } } return Short.parseShort(str); } /** * Returns the value by calling {@code Integer.valueOf(String)} if * {@code str} is not {@code null}, otherwise, the default value 0 for * {@code int} is returned. * * @param str * @return */ public static int parseInt(final String str) { if (CommonUtil.isNullOrEmpty(str)) { return 0; } if (str.length() < 5) { Integer result = stringIntCache.get(str); if (result != null) { return result.intValue(); } } return Integer.decode(str); } /** * Returns the value by calling {@code Long.valueOf(String)} if {@code str} * is not {@code null}, otherwise, the default value 0 for {@code long} is * returned. * * @param str * @return */ public static long parseLong(final String str) { if (CommonUtil.isNullOrEmpty(str)) { return 0; } if (str.length() < 5) { Integer result = stringIntCache.get(str); if (result != null) { return result.intValue(); } } return Long.decode(str); } /** * Returns the value by calling {@code Float.valueOf(String)} if {@code str} * is not {@code null}, otherwise, the default value 0f for {@code float} is * returned. * * @param str * @return */ public static float parseFloat(final String str) { if (isNullOrEmpty(str)) { return 0f; } return Float.parseFloat(str); } /** * Returns the value by calling {@code Double.valueOf(String)} if {@code str} * is not {@code null}, otherwise, the default value 0d for {@code double} is * returned. * * @param str * @return */ public static double parseDouble(final String str) { return isNullOrEmpty(str) ? 0d : Double.parseDouble(str); } /** * Base 64 encode. * * @param binaryData * @return */ public static String base64Encode(final byte[] binaryData) { if (CommonUtil.isNullOrEmpty(binaryData)) { return CommonUtil.EMPTY_STRING; } return Base64.encodeBase64String(binaryData); } /** * Base 64 encode chunked. * * @param binaryData * @return */ public static String base64EncodeChunked(final byte[] binaryData) { if (CommonUtil.isNullOrEmpty(binaryData)) { return CommonUtil.EMPTY_STRING; } return new String(Base64.encodeBase64Chunked(binaryData), Charsets.US_ASCII); } /** * Base 64 decode. * * @param base64String * @return */ public static byte[] base64Decode(final String base64String) { if (CommonUtil.isNullOrEmpty(base64String)) { return CommonUtil.EMPTY_BYTE_ARRAY; } return Base64.decodeBase64(base64String); } /** * Base 64 decode to string. * * @param base64String * @return */ public static String base64DecodeToString(final String base64String) { if (CommonUtil.isNullOrEmpty(base64String)) { return CommonUtil.EMPTY_STRING; } return new String(base64Decode(base64String)); } /** * Base 64 url encode. * * @param binaryData * @return */ public static String base64UrlEncode(final byte[] binaryData) { if (CommonUtil.isNullOrEmpty(binaryData)) { return CommonUtil.EMPTY_STRING; } return Base64.encodeBase64URLSafeString(binaryData); } /** * Base 64 url decode. * * @param base64String * @return */ public static byte[] base64UrlDecode(final String base64String) { if (CommonUtil.isNullOrEmpty(base64String)) { return CommonUtil.EMPTY_BYTE_ARRAY; } return Base64.decodeBase64URL(base64String); } /** * Base 64 url decode to string. * * @param base64String * @return */ public static String base64UrlDecodeToString(final String base64String) { if (CommonUtil.isNullOrEmpty(base64String)) { return CommonUtil.EMPTY_STRING; } return new String(Base64.decodeBase64URL(base64String)); } /** * * @param parameters * @return */ public static String urlEncode(final Object parameters) { if (parameters == null) { return CommonUtil.EMPTY_STRING; } return URLEncodedUtil.encode(parameters); } /** * * @param parameters * @param charset * @return */ public static String urlEncode(final Object parameters, final Charset charset) { if (parameters == null) { return CommonUtil.EMPTY_STRING; } return URLEncodedUtil.encode(parameters, charset); } /** * * @param urlQuery * @return */ public static Map urlDecode(final String urlQuery) { if (CommonUtil.isNullOrEmpty(urlQuery)) { return new LinkedHashMap<>(); } return URLEncodedUtil.decode(urlQuery); } /** * * @param urlQuery * @param charset * @return */ public static Map urlDecode(final String urlQuery, final Charset charset) { if (CommonUtil.isNullErrorMsg(urlQuery)) { return new LinkedHashMap<>(); } return URLEncodedUtil.decode(urlQuery, charset); } /** * * @param * @param targetClass * @param urlQuery * @return */ public static T urlDecode(final Class targetClass, final String urlQuery) { if (CommonUtil.isNullErrorMsg(urlQuery)) { return CommonUtil.newInstance(targetClass); } return URLEncodedUtil.decode(targetClass, urlQuery); } /** * * @param * @param targetClass * @param urlQuery * @param charset * @return */ public static T urlDecode(final Class targetClass, final String urlQuery, final Charset charset) { if (CommonUtil.isNullOrEmpty(urlQuery)) { return CommonUtil.newInstance(targetClass); } return URLEncodedUtil.decode(targetClass, urlQuery, charset); } /** * Returns the UUID without '-'. * * @return * @see UUID#randomUUID(). */ public static String guid() { return uuid().replace("-", ""); } /** * Returns an UUID. * * @return * @see UUID#randomUUID(). */ public static String uuid() { return UUID.randomUUID().toString(); } /** * Checks if is entity. * * @param cls * @return true, if is entity * @see ClassUtil#isEntity(Class) * @deprecated replaced by {@code ClassUtil.isEntity(Class)} */ @Deprecated public static boolean isEntity(final Class cls) { return ClassUtil.isEntity(cls); } /** * Checks if is dirty marker. * * @param cls * @return true, if is dirty marker * @see DirtyMarkerUtil#isDirtyMarker(Class) * @deprecated replaced by {@code ClassUtil.isDirtyMarker(Class)} */ @Deprecated public static boolean isDirtyMarker(final Class cls) { return DirtyMarkerUtil.isDirtyMarker(cls); } private static final Set> notKryoCompatible = CommonUtil.newHashSet(); /** * Returns a new created instance of the same class and set with same * properties retrieved by 'getXXX' method in the specified {@code entity}. * * @param * @param entity a Java Object what allows access to properties using getter * and setter methods. * @return */ @SuppressWarnings("unchecked") public static T copy(final T entity) { return copy((Class) entity.getClass(), entity); } /** * * @param * @param entity * @param selectPropNames * @return */ public static T copy(final T entity, final Collection selectPropNames) { return copy((Class) entity.getClass(), entity, selectPropNames); } /** * * @param * @param targetClass * @param entity * @return */ public static T copy(final Class targetClass, final Object entity) { return copy(targetClass, entity, null); } /** * Returns a new created instance of the specified {@code cls} and set with * same properties retrieved by 'getXXX' method in the specified * {@code entity}. * * @param * @param targetClass a Java Object what allows access to properties using getter * and setter methods. * @param entity a Java Object what allows access to properties using getter * and setter methods. * @param selectPropNames * @return */ @SuppressWarnings({ "unchecked" }) public static T copy(final Class targetClass, final Object entity, final Collection selectPropNames) { final Class srcCls = entity.getClass(); T copy = null; if (selectPropNames == null && Utils.kryoParser != null && targetClass.equals(srcCls) && !notKryoCompatible.contains(srcCls)) { try { copy = (T) Utils.kryoParser.copy(entity); } catch (Exception e) { notKryoCompatible.add(srcCls); // ignore } } if (copy != null) { return copy; } copy = CommonUtil.newInstance(targetClass); merge(entity, copy, selectPropNames); DirtyMarkerUtil.setDirtyMarker(entity, copy); return copy; } /** * * @param * @param targetClass * @param entity * @param ignoreUnknownProperty * @param ignorePropNames * @return */ @SuppressWarnings({ "unchecked" }) public static T copy(final Class targetClass, final Object entity, final boolean ignoreUnknownProperty, final Set ignorePropNames) { final Class srcCls = entity.getClass(); T copy = null; if (ignorePropNames == null && Utils.kryoParser != null && targetClass.equals(srcCls) && !notKryoCompatible.contains(srcCls)) { try { copy = (T) Utils.kryoParser.copy(entity); } catch (Exception e) { notKryoCompatible.add(srcCls); // ignore } } if (copy != null) { return copy; } copy = CommonUtil.newInstance(targetClass); merge(entity, copy, ignoreUnknownProperty, ignorePropNames); DirtyMarkerUtil.setDirtyMarker(entity, copy); return copy; } /** * * @param sourceEntity * @param targetEntity * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity) { return merge(sourceEntity, targetEntity, (Collection) null); } /** * Set all the signed properties(including all primitive type properties) in * the specified {@code sourceEntity} to the specified {@code targetEntity}. * * @param sourceEntity a Java Object what allows access to properties using getter * and setter methods. * @param targetEntity a Java Object what allows access to properties using getter * and setter methods. * @param selectPropNames * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final Collection selectPropNames) { final EntityInfo srcEntityInfo = ParserUtil.getEntityInfo(sourceEntity.getClass()); final EntityInfo targetEntityInfo = ParserUtil.getEntityInfo(targetEntity.getClass()); final boolean ignoreUnknownProperty = selectPropNames == null; if (selectPropNames == null) { if (sourceEntity instanceof DirtyMarker) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) sourceEntity); if (signedPropNames.size() == 0) { // logger.warn("no property is signed in the specified source entity: " + toString(entity)); } else { Object propValue = null; for (String propName : signedPropNames) { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); // if (Primitives.notNullOrDefault(propValue)) { // targetEntityInfo.setPropValue(targetEntity, propName, propValue, ignoreUnknownProperty); // } targetEntityInfo.setPropValue(targetEntity, propName, propValue, ignoreUnknownProperty); } } } else { Object propValue = null; for (PropInfo propInfo : srcEntityInfo.propInfoList) { propValue = srcEntityInfo.getPropValue(sourceEntity, propInfo.name); if (notNullOrDefault(propValue)) { targetEntityInfo.setPropValue(targetEntity, propInfo.name, propValue, ignoreUnknownProperty); } } } } else { for (String propName : selectPropNames) { targetEntityInfo.setPropValue(targetEntity, propName, srcEntityInfo.getPropValue(sourceEntity, propName), ignoreUnknownProperty); } } return targetEntity; } /** * Set all the signed properties(including all primitive type properties) in * the specified {@code sourceEntity} to the specified {@code targetEntity}. * * @param sourceEntity a Java Object what allows access to properties using getter * and setter methods. * @param targetEntity a Java Object what allows access to properties using getter * and setter methods. * @param filter * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final BiPredicate filter) { final EntityInfo srcEntityInfo = ParserUtil.getEntityInfo(sourceEntity.getClass()); final EntityInfo targetEntityInfo = ParserUtil.getEntityInfo(targetEntity.getClass()); final BiPredicate objFilter = (BiPredicate) filter; if (sourceEntity instanceof DirtyMarker) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) sourceEntity); if (signedPropNames.size() == 0) { // logger.warn("no property is signed in the specified source entity: " + toString(entity)); } else { Object propValue = null; for (String propName : signedPropNames) { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); if (objFilter.test(propName, propValue)) { targetEntityInfo.setPropValue(targetEntity, propName, propValue, false); } } } } else { Object propValue = null; for (PropInfo propInfo : srcEntityInfo.propInfoList) { propValue = propInfo.getPropValue(sourceEntity); if (objFilter.test(propInfo.name, propValue)) { targetEntityInfo.setPropValue(targetEntity, propInfo.name, propValue, false); } } } return targetEntity; } /** * * @param sourceEntity * @param targetEntity * @param ignoreUnknownProperty * @param ignorePropNames * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final boolean ignoreUnknownProperty, final Set ignorePropNames) { final EntityInfo srcEntityInfo = ParserUtil.getEntityInfo(sourceEntity.getClass()); final EntityInfo targetEntityInfo = ParserUtil.getEntityInfo(targetEntity.getClass()); if (sourceEntity instanceof DirtyMarker) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) sourceEntity); if (signedPropNames.size() == 0) { // logger.warn("no property is signed in the specified source entity: " + toString(entity)); } else { Object propValue = null; for (String propName : signedPropNames) { if (ignorePropNames == null || ignorePropNames.contains(propName) == false) { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); // if (Primitives.notNullOrDefault(propValue)) { // targetEntityInfo.setPropValue(targetEntity, propName, propValue, ignoreUnknownProperty); // } targetEntityInfo.setPropValue(targetEntity, propName, propValue, ignoreUnknownProperty); } } } } else { Object propValue = null; for (PropInfo propInfo : srcEntityInfo.propInfoList) { if (ignorePropNames == null || ignorePropNames.contains(propInfo.name) == false) { propValue = propInfo.getPropValue(sourceEntity); if (notNullOrDefault(propValue)) { targetEntityInfo.setPropValue(targetEntity, propInfo.name, propValue, ignoreUnknownProperty); } } } } return targetEntity; } /** * * @param sourceEntity * @param targetEntity * @param mergeFunc the first parameter is source property value, the second parameter is target property value. * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final BinaryOperator mergeFunc) { return merge(sourceEntity, targetEntity, (Collection) null, mergeFunc); } /** * Set all the signed properties(including all primitive type properties) in * the specified {@code sourceEntity} to the specified {@code targetEntity}. * * @param sourceEntity a Java Object what allows access to properties using getter * and setter methods. * @param targetEntity a Java Object what allows access to properties using getter * and setter methods. * @param selectPropNames * @param mergeFunc the first parameter is source property value, the second parameter is target property value. * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final Collection selectPropNames, final BinaryOperator mergeFunc) { final EntityInfo srcEntityInfo = ParserUtil.getEntityInfo(sourceEntity.getClass()); final EntityInfo targetEntityInfo = ParserUtil.getEntityInfo(targetEntity.getClass()); final BinaryOperator objMergeFunc = (BinaryOperator) mergeFunc; final boolean ignoreUnknownProperty = selectPropNames == null; if (selectPropNames == null) { if (sourceEntity instanceof DirtyMarker) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) sourceEntity); if (signedPropNames.size() == 0) { // logger.warn("no property is signed in the specified source entity: " + toString(entity)); } else { Object propValue = null; PropInfo targetPropInfo = null; for (String propName : signedPropNames) { targetPropInfo = targetEntityInfo.getPropInfo(propName); if (targetPropInfo == null) { if (ignoreUnknownProperty == false) { throw new IllegalArgumentException( "No property found by name: " + propName + " in target entity class: " + targetEntity.getClass()); } } else { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } } else { Object propValue = null; PropInfo targetPropInfo = null; for (PropInfo propInfo : srcEntityInfo.propInfoList) { targetPropInfo = targetEntityInfo.getPropInfo(propInfo.name); if (targetPropInfo == null) { if (ignoreUnknownProperty == false) { throw new IllegalArgumentException( "No property found by name: " + propInfo.name + " in target entity class: " + targetEntity.getClass()); } } else { propValue = propInfo.getPropValue(sourceEntity); targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } } else { Object propValue = null; PropInfo targetPropInfo = null; for (String propName : selectPropNames) { targetPropInfo = targetEntityInfo.getPropInfo(propName); if (targetPropInfo == null) { if (ignoreUnknownProperty == false) { throw new IllegalArgumentException("No property found by name: " + propName + " in target entity class: " + targetEntity.getClass()); } } else { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } return targetEntity; } /** * Set all the signed properties(including all primitive type properties) in * the specified {@code sourceEntity} to the specified {@code targetEntity}. * * @param sourceEntity a Java Object what allows access to properties using getter * and setter methods. * @param targetEntity a Java Object what allows access to properties using getter * and setter methods. * @param filter * @param mergeFunc the first parameter is source property value, the second parameter is target property value. * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final BiPredicate filter, final BinaryOperator mergeFunc) { final EntityInfo srcEntityInfo = ParserUtil.getEntityInfo(sourceEntity.getClass()); final EntityInfo targetEntityInfo = ParserUtil.getEntityInfo(targetEntity.getClass()); final BiPredicate objFilter = (BiPredicate) filter; final BinaryOperator objMergeFunc = (BinaryOperator) mergeFunc; if (sourceEntity instanceof DirtyMarker) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) sourceEntity); if (signedPropNames.size() == 0) { // logger.warn("no property is signed in the specified source entity: " + toString(entity)); } else { Object propValue = null; PropInfo targetPropInfo = null; for (String propName : signedPropNames) { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); if (objFilter.test(propName, propValue)) { targetPropInfo = targetEntityInfo.getPropInfo(propName); if (targetPropInfo == null) { throw new IllegalArgumentException( "No property found by name: " + propName + " in target entity class: " + targetEntity.getClass()); } targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } } else { Object propValue = null; PropInfo targetPropInfo = null; for (PropInfo propInfo : srcEntityInfo.propInfoList) { propValue = propInfo.getPropValue(sourceEntity); if (objFilter.test(propInfo.name, propValue)) { targetPropInfo = targetEntityInfo.getPropInfo(propInfo.name); if (targetPropInfo == null) { throw new IllegalArgumentException( "No property found by name: " + propInfo.name + " in target entity class: " + targetEntity.getClass()); } targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } return targetEntity; } /** * * @param sourceEntity * @param targetEntity * @param ignoreUnknownProperty * @param ignorePropNames * @param mergeFunc the first parameter is source property value, the second parameter is target property value. * @return {@code targetEntity} */ public static T merge(final Object sourceEntity, final T targetEntity, final boolean ignoreUnknownProperty, final Set ignorePropNames, final BinaryOperator mergeFunc) { final EntityInfo srcEntityInfo = ParserUtil.getEntityInfo(sourceEntity.getClass()); final EntityInfo targetEntityInfo = ParserUtil.getEntityInfo(targetEntity.getClass()); final BinaryOperator objMergeFunc = (BinaryOperator) mergeFunc; if (sourceEntity instanceof DirtyMarker) { final Set signedPropNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) sourceEntity); if (signedPropNames.size() == 0) { // logger.warn("no property is signed in the specified source entity: " // + toString(entity)); } else { Object propValue = null; PropInfo targetPropInfo = null; for (String propName : signedPropNames) { if (ignorePropNames == null || ignorePropNames.contains(propName) == false) { targetPropInfo = targetEntityInfo.getPropInfo(propName); if (targetPropInfo == null) { if (ignoreUnknownProperty == false) { throw new IllegalArgumentException( "No property found by name: " + propName + " in target entity class: " + targetEntity.getClass()); } } else { propValue = srcEntityInfo.getPropValue(sourceEntity, propName); targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } } } else { Object propValue = null; PropInfo targetPropInfo = null; for (PropInfo propInfo : srcEntityInfo.propInfoList) { if (ignorePropNames == null || ignorePropNames.contains(propInfo.name) == false) { targetPropInfo = targetEntityInfo.getPropInfo(propInfo.name); if (targetPropInfo == null) { if (ignoreUnknownProperty == false) { throw new IllegalArgumentException( "No property found by name: " + propInfo.name + " in target entity class: " + targetEntity.getClass()); } } else { propValue = propInfo.getPropValue(sourceEntity); targetPropInfo.setPropValue(targetEntity, objMergeFunc.apply(propValue, targetPropInfo.getPropValue(targetEntity))); } } } } return targetEntity; } /** * * @param entity * @param propNames */ @SafeVarargs public static void erase(final Object entity, final String... propNames) { if (entity == null || CommonUtil.isNullOrEmpty(propNames) || (entity instanceof DirtyMarker && DirtyMarkerUtil.signedPropNames((DirtyMarker) entity).size() == 0)) { return; } final EntityInfo entityInfo = ParserUtil.getEntityInfo(entity.getClass()); for (String propName : propNames) { entityInfo.setPropValue(entity, propName, null); } if (entity instanceof DirtyMarker) { final DirtyMarker dirtyMarkerEntity = (DirtyMarker) entity; for (String propName : propNames) { DirtyMarkerUtil.signedPropNames(dirtyMarkerEntity).remove(propName); DirtyMarkerUtil.dirtyPropNames(dirtyMarkerEntity).remove(propName); } } } /** * * @param entity * @param propNames */ public static void erase(final Object entity, final Collection propNames) { if (entity == null || CommonUtil.isNullOrEmpty(propNames) || (entity instanceof DirtyMarker && DirtyMarkerUtil.signedPropNames((DirtyMarker) entity).size() == 0)) { return; } final EntityInfo entityInfo = ParserUtil.getEntityInfo(entity.getClass()); for (String propName : propNames) { entityInfo.setPropValue(entity, propName, null); } if (entity instanceof DirtyMarker) { final DirtyMarker dirtyMarkerEntity = (DirtyMarker) entity; DirtyMarkerUtil.signedPropNames(dirtyMarkerEntity).removeAll(propNames); DirtyMarkerUtil.dirtyPropNames(dirtyMarkerEntity).removeAll(propNames); } } /** * * @param entity */ public static void eraseAll(final Object entity) { if (entity == null) { return; } final Class cls = entity.getClass(); final EntityInfo entityInfo = ParserUtil.getEntityInfo(cls); if (entity instanceof DirtyMarker) { final DirtyMarker dirtyMarkerEntity = (DirtyMarker) entity; final Set signedPropNames = DirtyMarkerUtil.signedPropNames(dirtyMarkerEntity); if (signedPropNames.size() == 0) { // logger.warn("No property is signed in the specified source entity: " + toString(entity)); return; } for (String propName : signedPropNames) { entityInfo.setPropValue(entity, propName, null); } DirtyMarkerUtil.signedPropNames(dirtyMarkerEntity).clear(); DirtyMarkerUtil.dirtyPropNames(dirtyMarkerEntity).clear(); } else { for (PropInfo propInfo : entityInfo.propInfoList) { propInfo.setPropValue(entity, null); } } } /** * Returns an empty immutable {@code List}. * * @param * @return * @see Collections#emptyList() */ @Immutable public static List emptyList() { return EMPTY_LIST; } /** * Returns an empty immutable {@code Set}. * * @param * @return * @see Collections#emptySet() */ @Immutable public static Set emptySet() { return EMPTY_SET; } /** * Returns an empty immutable {@code Map}. * * @param the key type * @param the value type * @return * @see Collections#emptyMap() */ @Immutable public static Map emptyMap() { return EMPTY_MAP; } /** * Returns an empty immutable {@code Iterator}. * * @param * @return * @see Collections#emptyIterator() */ public static Iterator emptyIterator() { return EMPTY_ITERATOR; } /** * Returns an empty immutable {@code ListIterator}. * * @param * @return * @see Collections#emptyListIterator() */ @Immutable public static ListIterator emptyListIterator() { return EMPTY_LIST_ITERATOR; } private static final ByteArrayInputStream EMPTY_INPUT_STREAM = new ByteArrayInputStream(CommonUtil.EMPTY_BYTE_ARRAY); /** * Returns an empty immutable {@code InputStream}. * * @return */ @Immutable public static InputStream emptyInputStream() { return EMPTY_INPUT_STREAM; } /** * * @param * @param a * @param b * @return true, if successful */ public static boolean anyNull(final T a, final T b) { return a == null || b == null; } /** * * @param * @param a * @param b * @param c * @return true, if successful */ public static boolean anyNull(final T a, final T b, final T c) { return a == null || b == null || c == null; } /** * * @param * @param a * @return true, if successful */ @SafeVarargs public static boolean anyNull(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return false; } for (T e : a) { if (e == null) { return true; } } return false; } /** * * @param * @param c * @return true, if successful */ public static boolean anyNull(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return false; } for (T e : c) { if (e == null) { return true; } } return false; } /** * * @param * @param a * @param b * @return true, if successful */ public static boolean allNull(final T a, final T b) { return a == null && b == null; } /** * * @param * @param a * @param b * @param c * @return true, if successful */ public static boolean allNull(final T a, final T b, final T c) { return a == null && b == null && c == null; } /** * * @param * @param a * @return true, if successful */ @SafeVarargs public static boolean allNull(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return true; } for (T e : a) { if (e != null) { return false; } } return true; } /** * * @param * @param c * @return true, if successful */ public static boolean allNull(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return true; } for (T e : c) { if (e != null) { return false; } } return true; } /** * Any null or empty. * * @param a * @param b * @return true, if successful */ public static boolean anyNullOrEmpty(final CharSequence a, final CharSequence b) { return a == null || a.length() == 0 || b == null || b.length() == 0; } /** * Any null or empty. * * @param a * @param b * @param c * @return true, if successful */ public static boolean anyNullOrEmpty(final CharSequence a, final CharSequence b, final CharSequence c) { return a == null || a.length() == 0 || b == null || b.length() == 0 || c == null || c.length() == 0; } /** * Any null or empty. * * @param css * @return true, if successful */ @SafeVarargs public static boolean anyNullOrEmpty(final CharSequence... css) { if (CommonUtil.isNullOrEmpty(css)) { return false; } for (CharSequence cs : css) { if (cs == null || cs.length() == 0) { return true; } } return false; } /** * Any null or empty. * * @param css * @return true, if successful */ public static boolean anyNullOrEmpty(final Collection css) { if (CommonUtil.isNullOrEmpty(css)) { return false; } for (CharSequence cs : css) { if (cs == null || cs.length() == 0) { return true; } } return false; } /** * * @param * @param a * @param b * @return */ public static boolean anyNullOrEmpty(final T[] a, final T[] b) { return a == null || a.length == 0 || b == null || b.length == 0; } /** * * @param * @param a * @param b * @param c * @return */ public static boolean anyNullOrEmpty(final T[] a, final T[] b, final T[] c) { return a == null || a.length == 0 || b == null || b.length == 0 || c == null || c.length == 0; } /** * * @param * @param a * @param b * @return */ public static > boolean anyNullOrEmpty(final T a, final T b) { return a == null || a.size() == 0 || b == null || b.size() == 0; } /** * * @param * @param a * @param b * @param c * @return */ public static > boolean anyNullOrEmpty(final T a, final T b, final T c) { return a == null || a.size() == 0 || b == null || b.size() == 0 || c == null || c.size() == 0; } /** * All null or empty. * * @param cs1 * @param cs2 * @return true, if successful */ public static boolean allNullOrEmpty(final CharSequence cs1, final CharSequence cs2) { return CommonUtil.isNullOrEmpty(cs1) && CommonUtil.isNullOrEmpty(cs2); } /** * All null or empty. * * @param cs1 * @param cs2 * @param cs3 * @return true, if successful */ public static boolean allNullOrEmpty(final CharSequence cs1, final CharSequence cs2, final CharSequence cs3) { return CommonUtil.isNullOrEmpty(cs1) && CommonUtil.isNullOrEmpty(cs2) && CommonUtil.isNullOrEmpty(cs3); } /** * All null or empty. * * @param css * @return true, if successful */ @SafeVarargs public static boolean allNullOrEmpty(final CharSequence... css) { if (CommonUtil.isNullOrEmpty(css)) { return true; } for (CharSequence cs : css) { if (CommonUtil.isNullOrEmpty(cs) == false) { return false; } } return true; } /** * All null or empty. * * @param css * @return true, if successful */ public static boolean allNullOrEmpty(final Collection css) { if (CommonUtil.isNullOrEmpty(css)) { return true; } for (CharSequence cs : css) { if (CommonUtil.isNullOrEmpty(cs) == false) { return false; } } return true; } /** * * @param * @param a * @param b * @return */ public static boolean allNullOrEmpty(final T[] a, final T[] b) { return isNullOrEmpty(a) && isNullOrEmpty(b); } /** * * @param * @param a * @param b * @param c * @return */ public static boolean allNullOrEmpty(final T[] a, final T[] b, final T[] c) { return isNullOrEmpty(a) && isNullOrEmpty(b) && isNullOrEmpty(c); } /** * * @param * @param a * @param b * @return */ public static > boolean allNullOrEmpty(final T a, final T b) { return isNullOrEmpty(a) && isNullOrEmpty(b); } /** * * @param * @param a * @param b * @param c * @return */ public static > boolean allNullOrEmpty(final T a, final T b, final T c) { return isNullOrEmpty(a) && isNullOrEmpty(b) && isNullOrEmpty(c); } /** * * @param * @param c * @return */ public static Nullable first(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return Nullable.empty(); } if (c instanceof List && c instanceof RandomAccess) { return Nullable.of(((List) c).get(0)); } else { return Nullable.of(c.iterator().next()); } } /** * * @param * @param c * @return */ public static Nullable last(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return Nullable.empty(); } if (c instanceof List) { final List list = (List) c; if (c instanceof RandomAccess) { return Nullable.of(list.get(c.size() - 1)); } else { return Nullable.of(list.listIterator(list.size()).previous()); } } else if (c instanceof Deque) { return Nullable.of(((Deque) c).descendingIterator().next()); } else { return Iterators.last(c.iterator()); } } /** * First non null. * * @param * @param a * @param b * @return */ public static Optional firstNonNull(final T a, final T b) { return a != null ? Optional.of(a) : (b != null ? Optional.of(b) : Optional. empty()); } /** * First non null. * * @param * @param a * @param b * @param c * @return */ public static Optional firstNonNull(final T a, final T b, final T c) { return a != null ? Optional.of(a) : (b != null ? Optional.of(b) : (c != null ? Optional.of(c) : Optional. empty())); } /** * First non null. * * @param * @param a * @return */ @SafeVarargs public static Optional firstNonNull(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return Optional.empty(); } for (T e : a) { if (e != null) { return Optional.of(e); } } return Optional.empty(); } /** * First non null. * * @param * @param c * @return */ public static Optional firstNonNull(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return Optional.empty(); } for (T e : c) { if (e != null) { return Optional.of(e); } } return Optional.empty(); } /** * Last non null. * * @param * @param a * @param b * @return */ public static Optional lastNonNull(final T a, final T b) { return b != null ? Optional.of(b) : (a != null ? Optional.of(a) : Optional. empty()); } /** * Last non null. * * @param * @param a * @param b * @param c * @return */ public static Optional lastNonNull(final T a, final T b, final T c) { return c != null ? Optional.of(c) : (b != null ? Optional.of(b) : (a != null ? Optional.of(a) : Optional. empty())); } /** * Last non null. * * @param * @param a * @return */ @SafeVarargs public static Optional lastNonNull(final T... a) { if (CommonUtil.isNullOrEmpty(a)) { return Optional.empty(); } for (int i = a.length - 1; i >= 0; i--) { if (a[i] != null) { return Optional.of(a[i]); } } return Optional.empty(); } /** * Last non null. * * @param * @param c * @return */ public static Optional lastNonNull(final Collection c) { if (CommonUtil.isNullOrEmpty(c)) { return Optional.empty(); } if (c instanceof List) { final List list = (List) c; if (c instanceof RandomAccess) { for (int i = c.size() - 1; i >= 0; i--) { if (list.get(i) != null) { return Optional.of(list.get(i)); } } } else { final ListIterator iter = list.listIterator(list.size()); T pre = null; while (iter.hasPrevious()) { if ((pre = iter.previous()) != null) { return Optional.of(pre); } } } } else if (c instanceof Deque) { final Iterator iter = ((Deque) c).descendingIterator(); T next = null; while (iter.hasNext()) { if ((next = iter.next()) != null) { return Optional.of(next); } } } else { Iterators.lastNonNull(c.iterator()); } return Optional.empty(); } /** * * @param * @param a * @param b * @return */ public static Optional firstNonEmpty(final T a, final T b) { return a != null && a.length() > 0 ? Optional.of(a) : (b != null && b.length() > 0 ? Optional.of(b) : Optional. empty()); } /** * * @param * @param a * @param b * @param c * @return */ public static Optional firstNonEmpty(final T a, final T b, final T c) { return a != null && a.length() > 0 ? Optional.of(a) : (b != null && b.length() > 0 ? Optional.of(b) : (c != null && c.length() > 0 ? Optional.of(c) : Optional. empty())); } /** * * @param * @param a * @param b * @return */ public static Optional firstNonEmpty(final T[] a, final T[] b) { return a != null && a.length > 0 ? Optional.of(a) : (b != null && b.length > 0 ? Optional.of(b) : Optional. empty()); } /** * * @param * @param a * @param b * @param c * @return */ public static Optional firstNonEmpty(final T[] a, final T[] b, final T[] c) { return a != null && a.length > 0 ? Optional.of(a) : (b != null && b.length > 0 ? Optional.of(b) : (c != null && c.length > 0 ? Optional.of(c) : Optional. empty())); } /** * * @param * @param a * @param b * @return */ public static > Optional firstNonEmpty(final T a, final T b) { return a != null && a.size() > 0 ? Optional.of(a) : (b != null && b.size() > 0 ? Optional.of(b) : Optional. empty()); } /** * * @param * @param a * @param b * @param c * @return */ public static > Optional firstNonEmpty(final T a, final T b, final T c) { return a != null && a.size() > 0 ? Optional.of(a) : (b != null && b.size() > 0 ? Optional.of(b) : (c != null && c.size() > 0 ? Optional.of(c) : Optional. empty())); } /** * * @param the key type * @param the value type * @param map * @return */ public static Optional> firstEntry(final Map map) { if (map == null || map.isEmpty()) { return Optional.empty(); } return Optional.of(map.entrySet().iterator().next()); } /** * * @param the key type * @param the value type * @param map * @return */ public static Optional> lastEntry(final Map map) { if (map == null || map.isEmpty()) { return Optional.empty(); } return Iterators.lastNonNull(map.entrySet().iterator()); } /** * First or null if empty. * * @param * @param c * @return */ public static T firstOrNullIfEmpty(final Collection c) { return firstOrDefaultIfEmpty(c, null); } /** * First or default if empty. * * @param * @param c * @param defaultValueForEmpty * @return */ public static T firstOrDefaultIfEmpty(final Collection c, final T defaultValueForEmpty) { if (CommonUtil.isNullOrEmpty(c)) { return defaultValueForEmpty; } if (c instanceof List && c instanceof RandomAccess) { return ((List) c).get(0); } else { return c.iterator().next(); } } /** * Last or null if empty. * * @param * @param c * @return */ public static T lastOrNullIfEmpty(final Collection c) { return lastOrDefaultIfEmpty(c, null); } /** * Last or default if empty. * * @param * @param c * @param defaultValueForEmpty * @return */ public static T lastOrDefaultIfEmpty(final Collection c, final T defaultValueForEmpty) { if (CommonUtil.isNullOrEmpty(c)) { return defaultValueForEmpty; } if (c instanceof List) { final List list = (List) c; if (c instanceof RandomAccess) { return list.get(c.size() - 1); } else { return list.listIterator(list.size()).previous(); } } else if (c instanceof Deque) { return ((Deque) c).descendingIterator().next(); } else { final Iterator iter = c.iterator(); T e = null; while (iter.hasNext()) { e = iter.next(); } return e; } } /** * Find first. * * @param the generic type * @param the element type * @param a the a * @param predicate the predicate * @return the nullable * @throws E the e */ @SuppressWarnings("deprecation") public static Nullable findFirst(final T[] a, final Throwables.Predicate predicate) throws E { return Iterables.findFirst(a, predicate); } /** * Find first. * * @param the generic type * @param the element type * @param c the c * @param predicate the predicate * @return the nullable * @throws E the e */ @SuppressWarnings("deprecation") public static Nullable findFirst(final Collection c, Throwables.Predicate predicate) throws E { return Iterables.findFirst(c, predicate); } /** * Find last. * * @param the generic type * @param the element type * @param a the a * @param predicate the predicate * @return the nullable * @throws E the e */ @SuppressWarnings("deprecation") public static Nullable findLast(final T[] a, final Throwables.Predicate predicate) throws E { return Iterables.findLast(a, predicate); } /** * Find last. * * @param the generic type * @param the element type * @param c the c * @param predicate the predicate * @return the nullable * @throws E the e */ @SuppressWarnings("deprecation") public static Nullable findLast(final Collection c, Throwables.Predicate predicate) throws E { return Iterables.findLast(c, predicate); } /** * Find first non null. * * @param the generic type * @param the element type * @param a the a * @param predicate the predicate * @return the optional * @throws E the e */ @SuppressWarnings("deprecation") public static Optional findFirstNonNull(final T[] a, final Throwables.Predicate predicate) throws E { return Iterables.findFirstNonNull(a, predicate); } /** * Find first non null. * * @param the generic type * @param the element type * @param c the c * @param predicate the predicate * @return the optional * @throws E the e */ @SuppressWarnings("deprecation") public static Optional findFirstNonNull(final Collection c, Throwables.Predicate predicate) throws E { return Iterables.findFirstNonNull(c, predicate); } /** * Find last non null. * * @param the generic type * @param the element type * @param a the a * @param predicate the predicate * @return the optional * @throws E the e */ @SuppressWarnings("deprecation") public static Optional findLastNonNull(final T[] a, final Throwables.Predicate predicate) throws E { return Iterables.findLastNonNull(a, predicate); } /** * Find last non null. * * @param the generic type * @param the element type * @param c the c * @param predicate the predicate * @return the optional * @throws E the e */ @SuppressWarnings("deprecation") public static Optional findLastNonNull(final Collection c, Throwables.Predicate predicate) throws E { return Iterables.findLastNonNull(c, predicate); } /** * Return at most first n elements. * * @param the generic type * @param c the c * @param n the n * @return the list */ public static List first(final Collection c, final int n) { N.checkArgument(n >= 0, "'n' can't be negative: " + n); if (N.isNullOrEmpty(c) || n == 0) { return new ArrayList<>(); } else if (c.size() <= n) { return new ArrayList<>(c); } else if (c instanceof List) { return new ArrayList<>(((List) c).subList(0, n)); } else { final List result = new ArrayList<>(N.min(n, c.size())); int cnt = 0; for (T e : c) { result.add(e); if (++cnt == n) { break; } } return result; } } /** * Return at most last n elements. * * @param the generic type * @param c the c * @param n the n * @return the list */ public static List last(final Collection c, final int n) { N.checkArgument(n >= 0, "'n' can't be negative: " + n); if (N.isNullOrEmpty(c) || n == 0) { return new ArrayList<>(); } else if (c.size() <= n) { return new ArrayList<>(c); } else if (c instanceof List) { return new ArrayList<>(((List) c).subList(c.size() - n, c.size())); } else { final List result = new ArrayList<>(N.min(n, c.size())); final Iterator iter = c.iterator(); int offset = c.size() - n; while (offset-- > 0) { iter.next(); } while (iter.hasNext()) { result.add(iter.next()); } return result; } } /** * Returns a read-only ImmutableCollection. * * @param the generic type * @param c the c * @param fromIndex the from index * @param toIndex the to index * @return the immutable collection */ public static ImmutableList slice(final List c, final int fromIndex, final int toIndex) { N.checkFromToIndex(fromIndex, toIndex, N.size(c)); if (N.isNullOrEmpty(c)) { return ImmutableList.empty(); } return ImmutableList.of(((List) c).subList(fromIndex, toIndex)); } /** * Returns a read-only ImmutableCollection. * * @param the generic type * @param c the c * @param fromIndex the from index * @param toIndex the to index * @return the immutable collection */ public static ImmutableCollection slice(final Collection c, final int fromIndex, final int toIndex) { N.checkFromToIndex(fromIndex, toIndex, N.size(c)); if (N.isNullOrEmpty(c)) { return ImmutableList.empty(); } if (c instanceof List) { return slice((List) c, fromIndex, toIndex); } return new Slice<>(c, fromIndex, toIndex); } /** * Returns a read-only Seq. * * @param the generic type * @param a the a * @param fromIndex the from index * @param toIndex the to index * @return the immutable collection */ public static ImmutableList slice(final T[] a, final int fromIndex, final int toIndex) { N.checkFromToIndex(fromIndex, toIndex, N.len(a)); if (N.isNullOrEmpty(a)) { return ImmutableList.empty(); } return slice(Array.asList(a), fromIndex, toIndex); } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param s * @return */ public static int len(final CharSequence s) { return s == null ? 0 : s.length(); } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final boolean[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final char[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final byte[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final short[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final int[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final long[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final float[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final double[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param a * @return */ public static int len(final Object[] a) { return a == null ? 0 : a.length; } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param c * @return */ public static int size(final Collection c) { return c == null ? 0 : c.size(); } /** * Returns the length/size of the specified {@code Array/Collection/Map/CharSequence}, or {@code 0} if it's empty or {@code null}. * * @param m * @return */ public static int size(final Map m) { return m == null ? 0 : m.size(); } /** * Returns an immutable empty list if the specified List is null, otherwise itself is returned. * * @param * @param list * @return */ public static List nullToEmpty(final List list) { return list == null ? CommonUtil. emptyList() : list; } /** * Returns an immutable empty set if the specified Set is null, otherwise itself is returned. * * @param * @param set * @return */ public static Set nullToEmpty(final Set set) { return set == null ? CommonUtil. emptySet() : set; } /** * Returns an immutable empty map if the specified Map is null, otherwise itself is returned. * * @param the key type * @param the value type * @param map * @return */ public static Map nullToEmpty(final Map map) { return map == null ? CommonUtil. emptyMap() : map; } /** * Returns an immutable empty Iterator if the specified Iterator is null, otherwise itself is returned. * * @param * @param iter * @return */ public static Iterator nullToEmpty(final Iterator iter) { return iter == null ? CommonUtil. emptyIterator() : iter; } /** * Returns an immutable empty ListIterator if the specified ListIterator is null, otherwise itself is returned. * * @param * @param iter * @return */ public static ListIterator nullToEmpty(final ListIterator iter) { return iter == null ? CommonUtil. emptyListIterator() : iter; } /** * Null to empty. * * @param str * @return */ public static String nullToEmpty(final String str) { return str == null ? EMPTY_STRING : str; } /** * Null to empty. * * @param a * @return */ public static boolean[] nullToEmpty(final boolean[] a) { return a == null ? EMPTY_BOOLEAN_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static char[] nullToEmpty(final char[] a) { return a == null ? EMPTY_CHAR_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static byte[] nullToEmpty(final byte[] a) { return a == null ? EMPTY_BYTE_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static short[] nullToEmpty(final short[] a) { return a == null ? EMPTY_SHORT_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static int[] nullToEmpty(final int[] a) { return a == null ? EMPTY_INT_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static long[] nullToEmpty(final long[] a) { return a == null ? EMPTY_LONG_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static float[] nullToEmpty(final float[] a) { return a == null ? EMPTY_FLOAT_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static double[] nullToEmpty(final double[] a) { return a == null ? EMPTY_DOUBLE_ARRAY : a; } /** * Null to empty. * * @param a * @return */ public static String[] nullToEmpty(final String[] a) { return a == null ? EMPTY_STRING_ARRAY : a; } /** * Null to empty. * * @param a * @return * @deprecated replaced by {@link CommonUtil#nullToEmpty(Object[], Class)} */ @Deprecated public static Object[] nullToEmpty(final Object[] a) { return a == null ? EMPTY_OBJECT_ARRAY : a; } /** * Null to empty. * * @param * @param arrayType * @param a * @return * @deprecated replaced by {@link CommonUtil#nullToEmpty(Object[], Class)} */ @Deprecated public static T[] nullToEmpty(final Class arrayType, final T[] a) { return a == null ? (T[]) CommonUtil.newArray(arrayType.getComponentType(), 0) : a; } /** * Null to empty. * * @param * @param a * @param arrayType * @return */ public static T[] nullToEmpty(final T[] a, final Class arrayType) { return a == null ? (T[]) CommonUtil.newArray(arrayType.getComponentType(), 0) : a; } /** * Returns an immutable empty Collection if the specified ImmutableCollection is null, otherwise itself is returned. * * @param * @param c * @return */ public static ImmutableCollection nullToEmpty(final ImmutableCollection c) { return c == null ? ImmutableList. empty() : c; } /** * Returns an immutable empty list if the specified ImmutableList is null, otherwise itself is returned. * * @param * @param list * @return */ public static ImmutableList nullToEmpty(final ImmutableList list) { return list == null ? ImmutableList. empty() : list; } /** * Returns an immutable empty list if the specified ImmutableSet is null, otherwise itself is returned. * * @param * @param set * @return */ public static ImmutableSet nullToEmpty(final ImmutableSet set) { return set == null ? ImmutableSet. empty() : set; } /** * Returns an immutable empty list if the specified ImmutableSortedSet is null, otherwise itself is returned. * * @param * @param set * @return */ public static ImmutableSortedSet nullToEmpty(final ImmutableSortedSet set) { return set == null ? ImmutableSortedSet. empty() : set; } /** * Returns an immutable empty list if the specified ImmutableNavigableSet is null, otherwise itself is returned. * * @param * @param set * @return */ public static ImmutableNavigableSet nullToEmpty(final ImmutableNavigableSet set) { return set == null ? ImmutableNavigableSet. empty() : set; } /** * Returns an immutable empty map if the specified ImmutableMap is null, otherwise itself is returned. * * @param the key type * @param the value type * @param map * @return */ public static ImmutableMap nullToEmpty(final ImmutableMap map) { return map == null ? ImmutableMap. empty() : map; } /** * Returns an immutable empty map if the specified ImmutableSortedMap is null, otherwise itself is returned. * * @param the key type * @param the value type * @param map * @return */ public static ImmutableSortedMap nullToEmpty(final ImmutableSortedMap map) { return map == null ? ImmutableSortedMap. empty() : map; } /** * Returns an immutable empty map if the specified ImmutableNavigableMap is null, otherwise itself is returned. * * @param the key type * @param the value type * @param map * @return */ public static ImmutableNavigableMap nullToEmpty(final ImmutableNavigableMap map) { return map == null ? ImmutableNavigableMap. empty() : map; } /** * Returns an immutable empty map if the specified ImmutableBiMap is null, otherwise itself is returned. * * @param the key type * @param the value type * @param map * @return */ public static ImmutableBiMap nullToEmpty(final ImmutableBiMap map) { return map == null ? ImmutableBiMap. empty() : map; } // /** // * Checks if is null or default. {@code null} is default value for all reference types, {@code false} is default value for primitive boolean, {@code 0} is the default value for primitive number type. // * // * @param s // * @return true, if is null or default // * @deprecated internal only // */ // @Deprecated // @Internal // @Beta // static boolean isNullOrDefault(final Object value) { // return (value == null) || equals(value, defaultValueOf(value.getClass())); // } /** * Checks if is null or empty. * * @param s * @return true, if is null or empty */ public static boolean isNullOrEmpty(final CharSequence s) { return (s == null) || (s.length() == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final boolean[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final char[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final byte[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final short[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final int[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final long[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final float[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final double[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param a * @return true, if is null or empty */ public static boolean isNullOrEmpty(final Object[] a) { return (a == null) || (a.length == 0); } /** * Checks if is null or empty. * * @param c * @return true, if is null or empty */ public static boolean isNullOrEmpty(final Collection c) { return (c == null) || (c.isEmpty()); } /** * Checks if is null or empty. * * @param m * @return true, if is null or empty */ public static boolean isNullOrEmpty(final Map m) { return (m == null) || (m.isEmpty()); } /** * Checks if is null or empty. * * @param s * @return true, if is null or empty */ public static boolean isNullOrEmpty(final Multiset s) { return (s == null) || (s.isEmpty()); } /** * Checks if is null or empty. * * @param m * @return true, if is null or empty */ public static boolean isNullOrEmpty(final Multimap m) { return (m == null) || (m.isEmpty()); } /** * Checks if is null or empty. * * @param rs * @return true, if is null or empty */ public static boolean isNullOrEmpty(final DataSet rs) { return (rs == null) || (rs.isEmpty()); } /** * Checks if is null or empty or blank. * * @param s * @return true, if is null or empty or blank */ // DON'T change 'OrEmptyOrBlank' to 'OrBlank' because of the occurring order in the auto-completed context menu. public static boolean isNullOrEmptyOrBlank(final CharSequence s) { if (CommonUtil.isNullOrEmpty(s)) { return true; } for (int i = 0, len = s.length(); i < len; i++) { if (Character.isWhitespace(s.charAt(i)) == false) { return false; } } return true; } // /** // * Checks if it's not null or default. {@code null} is default value for all reference types, {@code false} is default value for primitive boolean, {@code 0} is the default value for primitive number type. // * // * // * @param s // * @return true, if it's not null or default // * @deprecated internal only // */ // @Deprecated // @Internal // @Beta // static boolean notNullOrDefault(final Object value) { // return (value != null) && !equals(value, defaultValueOf(value.getClass())); // } /** * Checks if is null or default. {@code null} is default value for all reference types, {@code false} is default value for primitive boolean, {@code 0} is the default value for primitive number type. * * @param s * @return true, if is null or default */ @Internal @Beta static boolean isNullOrDefault(final Object value) { return (value == null) || N.equals(value, N.defaultValueOf(value.getClass())); } /** * Not null or empty. * * @param s * @return true, if successful */ public static boolean notNullOrEmpty(final CharSequence s) { return (s != null) && (s.length() > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final boolean[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final char[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final byte[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final short[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final int[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final long[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final float[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final double[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param a * @return true, if successful */ public static boolean notNullOrEmpty(final Object[] a) { return (a != null) && (a.length > 0); } /** * Not null or empty. * * @param c * @return true, if successful */ public static boolean notNullOrEmpty(final Collection c) { return (c != null) && (c.size() > 0); } /** * Not null or empty. * * @param m * @return true, if successful */ public static boolean notNullOrEmpty(final Map m) { return (m != null) && (m.size() > 0); } /** * Not null or empty. * * @param s * @return true, if successful */ public static boolean notNullOrEmpty(final Multiset s) { return (s != null) && (s.size() > 0); } /** * Not null or empty. * * @param m * @return true, if successful */ public static boolean notNullOrEmpty(final Multimap m) { return (m != null) && (m.size() > 0); } /** * Not null or empty. * * @param rs * @return true, if successful */ public static boolean notNullOrEmpty(final DataSet rs) { return (rs != null) && (rs.size() > 0); } /** * Not null or empty or blank. * * @param s * @return true, if successful */ // DON'T change 'OrEmptyOrBlank' to 'OrBlank' because of the occurring order in the auto-completed context menu. public static boolean notNullOrEmptyOrBlank(final CharSequence s) { return !CommonUtil.isNullOrEmptyOrBlank(s); } /** * Checks if it's not null or default. {@code null} is default value for all reference types, {@code false} is default value for primitive boolean, {@code 0} is the default value for primitive number type. * * * @param s * @return true, if it's not null or default */ @Internal @Beta static boolean notNullOrDefault(final Object value) { return (value != null) && !N.equals(value, N.defaultValueOf(value.getClass())); } /** * Checks if is null error msg. * * @param msg * @return true, if is null error msg */ private static boolean isNullErrorMsg(final String msg) { // shortest message: "it is null" return msg.length() > 9 && msg.indexOf(WD._SPACE) > 0; } /** * * @param index * @param length * @throws IndexOutOfBoundsException the index out of bounds exception */ public static void checkIndex(final int index, final int length) throws IndexOutOfBoundsException { if (index < 0 || index >= length) { throw new IndexOutOfBoundsException("Index " + index + " is out-of-bounds for length " + length); } } /** * Check from to index. * * @param fromIndex * @param toIndex * @param length * @throws IndexOutOfBoundsException the index out of bounds exception */ public static void checkFromToIndex(final int fromIndex, final int toIndex, final int length) throws IndexOutOfBoundsException { if (fromIndex < 0 || fromIndex > toIndex || toIndex > length) { throw new IndexOutOfBoundsException("Index range [" + fromIndex + ", " + toIndex + "] is out-of-bounds for length " + length); } } /** * Check from index size. * * @param fromIndex * @param size * @param length * @throws IndexOutOfBoundsException the index out of bounds exception */ public static void checkFromIndexSize(final int fromIndex, final int size, final int length) throws IndexOutOfBoundsException { if ((fromIndex < 0 || size < 0 || length < 0) || size > length - fromIndex) { throw new IndexOutOfBoundsException("Start Index " + fromIndex + " with size " + size + " is out-of-bounds for length " + length); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * * @param expression a boolean expression * @throws IllegalArgumentException if {@code expression} is false */ public static void checkArgument(boolean expression) { if (!expression) { throw new IllegalArgumentException(); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * * @param expression a boolean expression * @param errorMessage the exception message to use if the check fails; will be converted to a * string using {@link String#valueOf(Object)} * @throws IllegalArgumentException if {@code expression} is false */ public static void checkArgument(boolean expression, String errorMessage) { if (!expression) { throw new IllegalArgumentException(errorMessage); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, boolean p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkArgument(boolean b, String errorMessageTemplate, boolean p1, boolean p2) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkArgument(boolean b, String errorMessageTemplate, boolean p1, boolean p2, boolean p3) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, char p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, byte p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, short p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, int p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkArgument(boolean b, String errorMessageTemplate, int p1, int p2) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkArgument(boolean b, String errorMessageTemplate, int p1, int p2, int p3) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, long p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkArgument(boolean b, String errorMessageTemplate, long p1, long p2) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkArgument(boolean b, String errorMessageTemplate, long p1, long p2, long p3) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, float p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkArgument(boolean b, String errorMessageTemplate, float p1, float p2) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkArgument(boolean b, String errorMessageTemplate, float p1, float p2, float p3) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, double p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkArgument(boolean b, String errorMessageTemplate, double p1, double p2) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkArgument(boolean b, String errorMessageTemplate, double p1, double p2, double p3) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkArgument(boolean b, String errorMessageTemplate, Object p) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkArgument(boolean b, String errorMessageTemplate, Object p1, Object p2) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving one or more parameters to the calling method. * *

See {@link #checkArgument(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkArgument(boolean b, String errorMessageTemplate, Object p1, Object p2, Object p3) { if (!b) { throw new IllegalArgumentException(format(errorMessageTemplate, p1, p2, p3)); } } /** * * @param * @param b * @param errorMessageSupplier */ public static void checkArgument(boolean b, Supplier errorMessageSupplier) { if (!b) { throw new IllegalArgumentException(errorMessageSupplier.get()); } } /** * Check arg not null. * * @param * @param obj * @return * @throws IllegalArgumentException if {@code obj} is {@code null} */ public static T checkArgNotNull(final T obj) { if (obj == null) { throw new IllegalArgumentException(); } return obj; } /** * Check arg not null. * * @param * @param obj * @param errorMessage * @return * @throws IllegalArgumentException if {@code obj} is {@code null} */ public static T checkArgNotNull(final T obj, final String errorMessage) { if (obj == null) { if (isNullErrorMsg(errorMessage)) { throw new IllegalArgumentException(errorMessage); } else { throw new IllegalArgumentException("'" + errorMessage + "' can not be null"); } } return obj; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static boolean[] checkArgNotNullOrEmpty(final boolean[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static char[] checkArgNotNullOrEmpty(final char[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static byte[] checkArgNotNullOrEmpty(final byte[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static short[] checkArgNotNullOrEmpty(final short[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static int[] checkArgNotNullOrEmpty(final int[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static long[] checkArgNotNullOrEmpty(final long[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static float[] checkArgNotNullOrEmpty(final float[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static double[] checkArgNotNullOrEmpty(final double[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static T[] checkArgNotNullOrEmpty(final T[] arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is {@code null} or empty, and throws {@code IllegalArgumentException} if it is. * * @param * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is {@code null} or empty. */ public static > T checkArgNotNullOrEmpty(final T arg, final String argNameOrErrorMsg) { if (CommonUtil.isNullOrEmpty(arg)) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be null or empty"); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Check if the specified parameter is null or empty or blank. * * @param * @param arg * @param msg name of parameter or error message * @return * @throws IllegalArgumentException if the specified parameter is null or empty. */ // DON'T change 'OrEmptyOrBlank' to 'OrBlank' because of the occurring order in the auto-completed context menu. public static T checkArgNotNullOrEmptyOrBlank(final T arg, final String msg) { if (CommonUtil.isNullOrEmptyOrBlank(arg)) { if (isNullErrorMsg(msg)) { throw new IllegalArgumentException(msg); } else { throw new IllegalArgumentException("'" + msg + "' can not be null or empty or blank"); } } return arg; } /** * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is negative. */ public static int checkArgNotNegative(final int arg, final String argNameOrErrorMsg) { if (arg < 0) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is negative. */ public static long checkArgNotNegative(final long arg, final String argNameOrErrorMsg) { if (arg < 0) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is not negative, and throws {@code IllegalArgumentException} if it is. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is negative. */ public static double checkArgNotNegative(final double arg, final String argNameOrErrorMsg) { if (arg < 0) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be negative: " + arg); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is negative. */ public static int checkArgPositive(final int arg, final String argNameOrErrorMsg) { if (arg <= 0) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is negative. */ public static long checkArgPositive(final long arg, final String argNameOrErrorMsg) { if (arg <= 0) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Checks if the specified {@code arg} is positive, and throws {@code IllegalArgumentException} if it is not. * * @param arg * @param argNameOrErrorMsg * @return * @throws IllegalArgumentException if the specified {@code arg} is negative. */ public static double checkArgPositive(final double arg, final String argNameOrErrorMsg) { if (arg <= 0) { if (argNameOrErrorMsg.indexOf(' ') == INDEX_NOT_FOUND) { throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg); } else { throw new IllegalArgumentException(argNameOrErrorMsg); } } return arg; } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * * @param expression a boolean expression * @throws IllegalStateException if {@code expression} is false */ public static void checkState(boolean expression) { if (!expression) { throw new IllegalStateException(); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * * @param expression a boolean expression * @param errorMessage the exception message to use if the check fails; will be converted to a * string using {@link String#valueOf(Object)} * @throws IllegalStateException if {@code expression} is false */ public static void checkState(boolean expression, String errorMessage) { if (!expression) { throw new IllegalStateException(errorMessage); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkState(boolean b, String errorMessageTemplate, int p) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkState(boolean b, String errorMessageTemplate, int p1, int p2) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkState(boolean b, String errorMessageTemplate, int p1, int p2, int p3) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkState(boolean b, String errorMessageTemplate, long p) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkState(boolean b, String errorMessageTemplate, long p1, long p2) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkState(boolean b, String errorMessageTemplate, long p1, long p2, long p3) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkState(boolean b, String errorMessageTemplate, float p) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkState(boolean b, String errorMessageTemplate, float p1, float p2) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkState(boolean b, String errorMessageTemplate, float p1, float p2, float p3) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkState(boolean b, String errorMessageTemplate, double p) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkState(boolean b, String errorMessageTemplate, double p1, double p2) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkState(boolean b, String errorMessageTemplate, double p1, double p2, double p3) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p */ public static void checkState(boolean b, String errorMessageTemplate, Object p) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 */ public static void checkState(boolean b, String errorMessageTemplate, Object p1, Object p2) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2)); } } /** * Ensures the truth of an expression involving the state of the calling instance, but not * involving any parameters to the calling method. * *

See {@link #checkState(boolean, String, Object...)} for details. * * @param b * @param errorMessageTemplate * @param p1 * @param p2 * @param p3 */ public static void checkState(boolean b, String errorMessageTemplate, Object p1, Object p2, Object p3) { if (!b) { throw new IllegalStateException(format(errorMessageTemplate, p1, p2, p3)); } } /** * * @param * @param b * @param errorMessageSupplier */ public static void checkState(boolean b, Supplier errorMessageSupplier) { if (!b) { throw new IllegalStateException(errorMessageSupplier.get()); } } /** * * @param template * @param arg * @return */ static String format(String template, Object arg) { template = String.valueOf(template); // null -> "null" // start substituting the arguments into the '%s' placeholders final StringBuilder sb = Objectory.createStringBuilder(template.length() + 16); String placeholder = "{}"; int placeholderStart = template.indexOf(placeholder); if (placeholderStart < 0) { placeholder = "%s"; placeholderStart = template.indexOf(placeholder); } if (placeholderStart >= 0) { sb.append(template, 0, placeholderStart); sb.append(CommonUtil.toString(arg)); sb.append(template, placeholderStart + 2, template.length()); } else { sb.append(" ["); sb.append(CommonUtil.toString(arg)); sb.append(']'); } final String result = sb.toString(); Objectory.recycle(sb); return result; } /** * * @param template * @param arg1 * @param arg2 * @return */ static String format(String template, Object arg1, Object arg2) { template = String.valueOf(template); // null -> "null" // start substituting the arguments into the '%s' placeholders final StringBuilder sb = Objectory.createStringBuilder(template.length() + 32); String placeholder = "{}"; int placeholderStart = template.indexOf(placeholder); if (placeholderStart < 0) { placeholder = "%s"; placeholderStart = template.indexOf(placeholder); } int templateStart = 0; int cnt = 0; if (placeholderStart >= 0) { cnt++; sb.append(template, templateStart, placeholderStart); sb.append(CommonUtil.toString(arg1)); templateStart = placeholderStart + 2; placeholderStart = template.indexOf(placeholder, templateStart); if (placeholderStart >= 0) { cnt++; sb.append(template, templateStart, placeholderStart); sb.append(CommonUtil.toString(arg2)); templateStart = placeholderStart + 2; } sb.append(template, templateStart, template.length()); } if (cnt == 0) { sb.append(" ["); sb.append(CommonUtil.toString(arg1)); sb.append(", "); sb.append(CommonUtil.toString(arg2)); sb.append(']'); } else if (cnt == 1) { sb.append(" ["); sb.append(CommonUtil.toString(arg2)); sb.append(']'); } final String result = sb.toString(); Objectory.recycle(sb); return result; } /** * * @param template * @param arg1 * @param arg2 * @param arg3 * @return */ static String format(String template, Object arg1, Object arg2, Object arg3) { template = String.valueOf(template); // null -> "null" // start substituting the arguments into the '%s' placeholders final StringBuilder sb = Objectory.createStringBuilder(template.length() + 48); String placeholder = "{}"; int placeholderStart = template.indexOf(placeholder); if (placeholderStart < 0) { placeholder = "%s"; placeholderStart = template.indexOf(placeholder); } int templateStart = 0; int cnt = 0; if (placeholderStart >= 0) { cnt++; sb.append(template, templateStart, placeholderStart); sb.append(CommonUtil.toString(arg1)); templateStart = placeholderStart + 2; placeholderStart = template.indexOf(placeholder, templateStart); if (placeholderStart >= 0) { cnt++; sb.append(template, templateStart, placeholderStart); sb.append(CommonUtil.toString(arg2)); templateStart = placeholderStart + 2; placeholderStart = template.indexOf(placeholder, templateStart); if (placeholderStart >= 0) { cnt++; sb.append(template, templateStart, placeholderStart); sb.append(CommonUtil.toString(arg3)); templateStart = placeholderStart + 2; } } sb.append(template, templateStart, template.length()); } if (cnt == 0) { sb.append(" ["); sb.append(CommonUtil.toString(arg1)); sb.append(", "); sb.append(CommonUtil.toString(arg2)); sb.append(", "); sb.append(CommonUtil.toString(arg3)); sb.append(']'); } else if (cnt == 1) { sb.append(" ["); sb.append(CommonUtil.toString(arg2)); sb.append(", "); sb.append(CommonUtil.toString(arg3)); sb.append(']'); } else if (cnt == 2) { sb.append(" ["); sb.append(CommonUtil.toString(arg3)); sb.append(']'); } final String result = sb.toString(); Objectory.recycle(sb); return result; } /** * Substitutes each {@code %s} in {@code template} with an argument. These are matched by * position: the first {@code %s} gets {@code args[0]}, etc. If there are more arguments than * placeholders, the unmatched arguments will be appended to the end of the formatted message in * square braces. * * @param template a non-null string containing 0 or more {@code %s} placeholders. * @param args the arguments to be substituted into the message template. Arguments are converted * to strings using {@link String#valueOf(Object)}. Arguments can be null. * @return */ // Note that this is somewhat-improperly used from Verify.java as well. static String format(String template, Object... args) { template = String.valueOf(template); // null -> "null" if (CommonUtil.isNullOrEmpty(args)) { return template; } // start substituting the arguments into the '%s' placeholders final StringBuilder sb = Objectory.createStringBuilder(template.length() + 16 * args.length); int templateStart = 0; int i = 0; String placeholder = "{}"; int placeholderStart = template.indexOf(placeholder); if (placeholderStart < 0) { placeholder = "%s"; placeholderStart = template.indexOf(placeholder); } while (placeholderStart >= 0 && i < args.length) { sb.append(template, templateStart, placeholderStart); sb.append(CommonUtil.toString(args[i++])); templateStart = placeholderStart + 2; placeholderStart = template.indexOf(placeholder, templateStart); } sb.append(template, templateStart, template.length()); // if we run out of placeholders, append the extra args in square braces if (i < args.length) { sb.append(" ["); sb.append(CommonUtil.toString(args[i++])); while (i < args.length) { sb.append(", "); sb.append(CommonUtil.toString(args[i++])); } sb.append(']'); } final String result = sb.toString(); Objectory.recycle(sb); return result; } /** * * @param a * @param b * @return */ public static int compare(final boolean a, final boolean b) { return (a == b) ? 0 : (a ? 1 : -1); } /** * * @param a * @param b * @return */ public static int compare(final byte a, final byte b) { return (a < b) ? -1 : ((a == b) ? 0 : 1); } /** * * @param a * @param b * @return */ public static int compare(final short a, final short b) { return (a < b) ? -1 : ((a == b) ? 0 : 1); } /** * * @param a * @param b * @return */ public static int compare(final int a, final int b) { return (a < b) ? -1 : ((a == b) ? 0 : 1); } /** * * @param a * @param b * @return */ public static int compare(final long a, final long b) { return (a < b) ? -1 : ((a == b) ? 0 : 1); } /** * * @param a * @param b * @return */ public static int compare(final float a, final float b) { return Float.compare(a, b); } /** * * @param a * @param b * @return */ public static int compare(final double a, final double b) { return Double.compare(a, b); } /** * * @param * @param a * @param b * @return */ public static > int compare(final T a, final T b) { return a == null ? (b == null ? 0 : -1) : (b == null ? 1 : a.compareTo(b)); } /** * Returns 0 if the arguments are identical and {@code c.compare(a, b)} * otherwise. Consequently, if both arguments are {@code null} 0 is * returned. * *

* Note that if one of the arguments is {@code null}, a * {@code NullPointerException} may or may not be thrown depending on what * ordering policy, if any, the {@link Comparator Comparator} chooses to * have for {@code null} values. * * @param * the type of the objects being compared * @param a * an object * @param b * an object to be compared with {@code a} * @param cmp * the {@code Comparator} to compare the first two arguments * @return 0 if the arguments are identical and {@code c.compare(a, b)} * otherwise. * @see Comparable * @see Comparator */ public static int compare(final T a, final T b, final Comparator cmp) { return a == null ? (b == null ? 0 : -1) : (b == null ? 1 : (cmp == null ? NATURAL_ORDER : cmp).compare(a, b)); } /** * Continue to compare the pairs of values (a1, b1), (a2, b2) until they're not equal. * 0 is returned if all of the pairs of values are equal. * * @param * @param * @param a1 * @param b1 * @param a2 * @param b2 * @return */ public static , T2 extends Comparable> int compare(T1 a1, T1 b1, T2 a2, T2 b2) { int res = CommonUtil.compare(a1, b1); return res == 0 ? CommonUtil.compare(a2, b2) : res; } /** * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3) until they're not equal. * 0 is returned if all of the pairs of values are equal. * * @param * @param * @param * @param a1 * @param b1 * @param a2 * @param b2 * @param a3 * @param b3 * @return */ public static , T2 extends Comparable, T3 extends Comparable> int compare(T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3) { int res = 0; if ((res = CommonUtil.compare(a1, b1)) != 0) { return res; } else if ((res = CommonUtil.compare(a2, b2)) != 0) { return res; } return CommonUtil.compare(a3, b3); } /** * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4) until they're not equal. * 0 is returned if all of the pairs of values are equal. * * @param * @param * @param * @param * @param a1 * @param b1 * @param a2 * @param b2 * @param a3 * @param b3 * @param a4 * @param b4 * @return */ public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable> int compare(T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4) { int res = 0; if ((res = CommonUtil.compare(a1, b1)) != 0) { return res; } else if ((res = CommonUtil.compare(a2, b2)) != 0) { return res; } else if ((res = CommonUtil.compare(a3, b3)) != 0) { return res; } return CommonUtil.compare(a4, b4); } /** * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4), (a5, b5) until they're not equal. * 0 is returned if all of the pairs of values are equal. * * @param * @param * @param * @param * @param * @param a1 * @param b1 * @param a2 * @param b2 * @param a3 * @param b3 * @param a4 * @param b4 * @param a5 * @param b5 * @return */ public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable, T5 extends Comparable> int compare( T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4, T5 a5, T5 b5) { int res = 0; if ((res = CommonUtil.compare(a1, b1)) != 0) { return res; } else if ((res = CommonUtil.compare(a2, b2)) != 0) { return res; } else if ((res = CommonUtil.compare(a3, b3)) != 0) { return res; } else if ((res = CommonUtil.compare(a4, b4)) != 0) { return res; } return CommonUtil.compare(a5, b5); } /** * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4), (a5, b5), (a6, b6) until they're not equal. * 0 is returned if all of the pairs of values are equal. * * @param * @param * @param * @param * @param * @param * @param a1 * @param b1 * @param a2 * @param b2 * @param a3 * @param b3 * @param a4 * @param b4 * @param a5 * @param b5 * @param a6 * @param b6 * @return */ public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable, T5 extends Comparable, T6 extends Comparable> int compare( T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4, T5 a5, T5 b5, T6 a6, T6 b6) { int res = 0; if ((res = CommonUtil.compare(a1, b1)) != 0) { return res; } else if ((res = CommonUtil.compare(a2, b2)) != 0) { return res; } else if ((res = CommonUtil.compare(a3, b3)) != 0) { return res; } else if ((res = CommonUtil.compare(a4, b4)) != 0) { return res; } else if ((res = CommonUtil.compare(a5, b5)) != 0) { return res; } return CommonUtil.compare(a6, b6); } /** * Continue to compare the pairs of values (a1, b1), (a2, b2), (a3, b3), (a4, b4), (a5, b5), (a6, b6), (a7, b7) until they're not equal. * 0 is returned if all of the pairs of values are equal. * * @param * @param * @param * @param * @param * @param * @param * @param a1 * @param b1 * @param a2 * @param b2 * @param a3 * @param b3 * @param a4 * @param b4 * @param a5 * @param b5 * @param a6 * @param b6 * @param a7 * @param b7 * @return */ public static , T2 extends Comparable, T3 extends Comparable, T4 extends Comparable, T5 extends Comparable, T6 extends Comparable, T7 extends Comparable> int compare( T1 a1, T1 b1, T2 a2, T2 b2, T3 a3, T3 b3, T4 a4, T4 b4, T5 a5, T5 b5, T6 a6, T6 b6, T7 a7, T7 b7) { int res = 0; if ((res = CommonUtil.compare(a1, b1)) != 0) { return res; } else if ((res = CommonUtil.compare(a2, b2)) != 0) { return res; } else if ((res = CommonUtil.compare(a3, b3)) != 0) { return res; } else if ((res = CommonUtil.compare(a4, b4)) != 0) { return res; } else if ((res = CommonUtil.compare(a5, b5)) != 0) { return res; } else if ((res = CommonUtil.compare(a6, b6)) != 0) { return res; } return CommonUtil.compare(a7, b7); } /** * * @param a * @param b * @return */ public static int compare(final boolean[] a, final boolean[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if (a[i] != b[i]) { return a[i] ? 1 : -1; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final boolean[] a, final int fromIndexA, final boolean[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return a[i] ? 1 : -1; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final char[] a, final char[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if (a[i] != b[i]) { return a[i] > b[i] ? 1 : -1; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final char[] a, final int fromIndexA, final char[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return a[i] > b[i] ? 1 : -1; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final byte[] a, final byte[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if (a[i] != b[i]) { return a[i] > b[i] ? 1 : -1; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final byte[] a, final int fromIndexA, final byte[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return a[i] > b[i] ? 1 : -1; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final short[] a, final short[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if (a[i] != b[i]) { return a[i] > b[i] ? 1 : -1; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final short[] a, final int fromIndexA, final short[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return a[i] > b[i] ? 1 : -1; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final int[] a, final int[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if (a[i] != b[i]) { return a[i] > b[i] ? 1 : -1; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final int[] a, final int fromIndexA, final int[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return a[i] > b[i] ? 1 : -1; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final long[] a, final long[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if (a[i] != b[i]) { return a[i] > b[i] ? 1 : -1; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final long[] a, final int fromIndexA, final long[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return a[i] > b[i] ? 1 : -1; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final float[] a, final float[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } int value = 0; for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if ((value = Float.compare(a[i], b[i])) != 0) { return value; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final float[] a, final int fromIndexA, final float[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } int value = 0; for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if ((value = Float.compare(a[i], b[j])) != 0) { return value; } } return 0; } /** * * @param a * @param b * @return */ public static int compare(final double[] a, final double[] b) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } int value = 0; for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if ((value = Double.compare(a[i], b[i])) != 0) { return value; } } return a.length - b.length; } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final double[] a, final int fromIndexA, final double[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } int value = 0; for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if ((value = Double.compare(a[i], b[j])) != 0) { return value; } } return 0; } /** * * @param * @param a * @param b * @return */ public static > int compare(final T[] a, final T[] b) { final Comparator cmp = NATURAL_ORDER; return compare(a, b, cmp); } /** * * @param * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static > int compare(final T[] a, final int fromIndexA, final T[] b, final int fromIndexB, final int len) { final Comparator cmp = NATURAL_ORDER; return compare(a, fromIndexA, b, fromIndexB, len, cmp); } /** * * @param * @param a * @param b * @param cmp * @return */ public static int compare(final T[] a, final T[] b, Comparator cmp) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } cmp = cmp == null ? NATURAL_ORDER : cmp; int value = 0; for (int i = 0, minLen = N.min(a.length, b.length); i < minLen; i++) { if ((value = cmp.compare(a[i], b[i])) != 0) { return value; } } return a.length - b.length; } /** * * @param * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @param cmp * @return */ public static int compare(final T[] a, final int fromIndexA, final T[] b, final int fromIndexB, final int len, Comparator cmp) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } cmp = cmp == null ? NATURAL_ORDER : cmp; int value = 0; for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if ((value = cmp.compare(a[i], b[j])) != 0) { return value; } } return 0; } /** * * @param * @param a * @param b * @return */ public static > int compare(final Collection a, final Collection b) { final Comparator cmp = NATURAL_ORDER; return compare(a, b, cmp); } /** * * @param * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return */ public static int compare(final Collection a, int fromIndexA, final Collection b, int fromIndexB, final int len) { final Comparator cmp = NATURAL_ORDER; return compare(a, fromIndexA, b, fromIndexB, len, cmp); } /** * * @param * @param a * @param b * @param cmp * @return */ public static int compare(final Collection a, final Collection b, Comparator cmp) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.isNullOrEmpty(b) ? 0 : -1; } else if (CommonUtil.isNullOrEmpty(b)) { return 1; } cmp = cmp == null ? NATURAL_ORDER : cmp; final Iterator iterA = a.iterator(); final Iterator iterB = b.iterator(); int value = 0; for (int i = 0, minLen = N.min(a.size(), b.size()); i < minLen; i++) { if ((value = cmp.compare(iterA.next(), iterB.next())) != 0) { return value; } } return a.size() - b.size(); } /** * * @param * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @param cmp * @return */ public static int compare(final Collection a, int fromIndexA, final Collection b, int fromIndexB, final int len, Comparator cmp) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, size(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, size(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return 0; } cmp = cmp == null ? NATURAL_ORDER : cmp; final Iterator iterA = a.iterator(); final Iterator iterB = b.iterator(); while (fromIndexA-- > 0) { iterA.next(); } while (fromIndexB-- > 0) { iterB.next(); } int value = 0; for (int i = 0; i < len; i++) { if ((value = cmp.compare(iterA.next(), iterB.next())) != 0) { return value; } } return 0; } /** * Compare ignore case. * * @param a * @param b * @return */ public static int compareIgnoreCase(final String a, final String b) { return a == null ? (b == null ? 0 : -1) : (b == null ? 1 : a.compareToIgnoreCase(b)); } /** * * @param a * @param b * @return boolean */ public static boolean equals(final boolean a, final boolean b) { return a == b; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final char a, final char b) { return a == b; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final byte a, final byte b) { return a == b; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final short a, final short b) { return a == b; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final int a, final int b) { return a == b; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final long a, final long b) { return a == b; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final float a, final float b) { return Float.compare(a, b) == 0; } /** * * @param a * @param b * @return boolean */ public static boolean equals(final double a, final double b) { return Double.compare(a, b) == 0; } /** * * @param a * @param b * @return true, if successful */ public static boolean equals(final String a, final String b) { return (a == null) ? b == null : (b == null ? false : a.length() == b.length() && a.equals(b)); } /** * Equals ignore case. * * @param a * @param b * @return true, if successful */ public static boolean equalsIgnoreCase(final String a, final String b) { return (a == null) ? b == null : (b == null ? false : a.equalsIgnoreCase(b)); } /** * compare {@code a} and {@code b} by * {@link Arrays#equals(Object[], Object[])} if both of them are array. * * @param a * @param b * @return boolean */ public static boolean equals(final Object a, final Object b) { if ((a == null) ? b == null : (b == null ? false : a.equals(b))) { return true; } if ((a != null) && (b != null)) { final Type typeA = typeOf(a.getClass()); if (typeA.isPrimitiveArray()) { final Type typeB = typeOf(b.getClass()); return typeA.clazz().equals(typeB.clazz()) && typeA.equals(a, b); } else if (typeA.isObjectArray()) { final Type typeB = typeOf(b.getClass()); return typeB.isObjectArray() && typeA.equals(a, b); } } return false; } /** * compare {@code a} and {@code b} by * {@link Arrays#equals(Object[], Object[])} if both of them are array. * * @param a * @param b * @return boolean */ public static boolean deepEquals(final Object a, final Object b) { if ((a == null) ? b == null : (b == null ? false : a.equals(b))) { return true; } if ((a != null) && (b != null) && a.getClass().isArray() && a.getClass().equals(b.getClass())) { return typeOf(a.getClass()).deepEquals(a, b); } return false; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(boolean[], boolean[]) */ public static boolean equals(final boolean[] a, final boolean[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final boolean[] a, final int fromIndexA, final boolean[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(char[], char[]) */ public static boolean equals(final char[] a, final char[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final char[] a, final int fromIndexA, final char[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(byte[], byte[]) */ public static boolean equals(final byte[] a, final byte[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final byte[] a, final int fromIndexA, final byte[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(short[], short[]) */ public static boolean equals(final short[] a, final short[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final short[] a, final int fromIndexA, final short[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(int[], int[]) */ public static boolean equals(final int[] a, final int[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final int[] a, final int fromIndexA, final int[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(long[], long[]) */ public static boolean equals(final long[] a, final long[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final long[] a, final int fromIndexA, final long[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (a[i] != b[j]) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(float[], float[]) */ public static boolean equals(final float[] a, final float[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final float[] a, final int fromIndexA, final float[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (Float.compare(a[i], b[j]) != 0) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(double[], double[]) */ public static boolean equals(final double[] a, final double[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final double[] a, final int fromIndexA, final double[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (Double.compare(a[i], b[j]) != 0) { return false; } } return true; } /** * * @param a * @param b * @return boolean * @see Arrays#equals(Object[], Object[]) */ public static boolean equals(final Object[] a, final Object[] b) { return a == b || (a != null && b != null && a.length == b.length && equals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equals(final Object[] a, final int fromIndexA, final Object[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } else if (a.getClass().equals(b.getClass()) == false) { return false; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (CommonUtil.equals(a[i], b[j]) == false) { return false; } } return true; } /** * * @param a * @param b * @return true, if successful * @see Arrays#deepEquals(Object[], Object[]) */ public static boolean deepEquals(final Object[] a, final Object[] b) { return a == b || (a != null && b != null && a.length == b.length && deepEquals(a, 0, b, 0, a.length)); } /** * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean deepEquals(final Object[] a, final int fromIndexA, final Object[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } else if (a.getClass().equals(b.getClass()) == false) { return false; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (CommonUtil.deepEquals(a[i], b[j]) == false) { return false; } } return true; } /** * Equals ignore case. * * @param a * @param b * @return true, if successful */ public static boolean equalsIgnoreCase(final String[] a, final String[] b) { return (a == null || b == null) ? a == b : (a.length == b.length && equalsIgnoreCase(a, 0, b, 0, a.length)); } /** * Equals ignore case. * * @param a * @param fromIndexA * @param b * @param fromIndexB * @param len * @return true, if successful */ public static boolean equalsIgnoreCase(final String[] a, final int fromIndexA, final String[] b, final int fromIndexB, final int len) { CommonUtil.checkArgNotNegative(len, "len"); CommonUtil.checkFromIndexSize(fromIndexA, len, len(a)); CommonUtil.checkFromIndexSize(fromIndexB, len, len(b)); if ((fromIndexA == fromIndexB && a == b) || len == 0) { return true; } else if (a.getClass().equals(b.getClass()) == false) { return false; } for (int i = fromIndexA, j = fromIndexB, k = 0; k < len; i++, j++, k++) { if (((a[i] == null || b[j] == null) ? a == b : a[i].equalsIgnoreCase(b[j])) == false) { return false; } } return true; } /** * * @param value * @return int */ public static int hashCode(final boolean value) { return value ? 1231 : 1237; } /** * * @param value * @return int */ public static int hashCode(final char value) { return value; } /** * * @param value * @return int */ public static int hashCode(final byte value) { return value; } /** * * @param value * @return int */ public static int hashCode(final short value) { return value; } /** * * @param value * @return int */ public static int hashCode(final int value) { return value; } /** * * @param value * @return int */ public static int hashCode(final long value) { return (int) (value ^ (value >>> 32)); } /** * * @param value * @return int */ public static int hashCode(final float value) { return Float.floatToIntBits(value); } /** * * @param value * @return int */ public static int hashCode(final double value) { long bits = Double.doubleToLongBits(value); return (int) (bits ^ (bits >>> 32)); } /** * * @param obj * @return int */ public static int hashCode(final Object obj) { if (obj == null) { return 0; } if (obj.getClass().isArray()) { return typeOf(obj.getClass()).hashCode(obj); } return obj.hashCode(); } /** * * @param obj * @return int */ public static int deepHashCode(final Object obj) { if (obj == null) { return 0; } if (obj.getClass().isArray()) { return typeOf(obj.getClass()).deepHashCode(obj); } return obj.hashCode(); } /** * * @param a * @return * @see Arrays#hashCode(boolean[]) */ public static int hashCode(final boolean[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final boolean[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + (a[i] ? 1231 : 1237); } return result; } /** * * @param a * @return * @see Arrays#hashCode(char[]) */ public static int hashCode(final char[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final char[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + a[i]; } return result; } /** * * @param a * @return * @see Arrays#hashCode(byte[]) */ public static int hashCode(final byte[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final byte[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + a[i]; } return result; } /** * * @param a * @return * @see Arrays#hashCode(short[]) */ public static int hashCode(final short[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final short[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + a[i]; } return result; } /** * * @param a * @return * @see Arrays#hashCode(int[]) */ public static int hashCode(final int[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final int[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + a[i]; } return result; } /** * * @param a * @return * @see Arrays#hashCode(long[]) */ public static int hashCode(final long[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final long[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + (int) (a[i] ^ (a[i] >>> 32)); } return result; } /** * * @param a * @return * @see Arrays#hashCode(float[]) */ public static int hashCode(final float[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final float[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + Float.floatToIntBits(a[i]); } return result; } /** * * @param a * @return * @see Arrays#hashCode(double[]) */ public static int hashCode(final double[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final double[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { long bits = Double.doubleToLongBits(a[i]); result = 31 * result + (int) (bits ^ (bits >>> 32)); } return result; } /** * * @param a * @return * @see Arrays#hashCode(Object[]) */ public static int hashCode(final Object[] a) { return a == null ? 0 : hashCode(a, 0, a.length); } /** * * @param a * @param fromIndex * @param toIndex * @return */ public static int hashCode(final Object[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + (a[i] == null ? 0 : a[i].hashCode()); } return result; } /** * Deep hash code. * * @param a * @return * @see Arrays#deepHashCode(Object[]) */ public static int deepHashCode(final Object[] a) { return a == null ? 0 : deepHashCode(a, 0, a.length); } /** * Deep hash code. * * @param a * @param fromIndex * @param toIndex * @return */ public static int deepHashCode(final Object[] a, final int fromIndex, final int toIndex) { if (a == null) { return 0; } int result = 1; for (int i = fromIndex; i < toIndex; i++) { result = 31 * result + (a[i] == null ? 0 : deepHashCode(a[i])); } return result; } /** * * @param value * @return int */ public static String toString(final boolean value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final char value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final byte value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final short value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final int value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final long value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final float value) { return stringOf(value); } /** * * @param value * @return int */ public static String toString(final double value) { return stringOf(value); } /** * * @param obj * @return int */ public static String toString(final Object obj) { if (obj == null) { return NULL_STRING; } else if (obj instanceof CharSequence) { return obj.toString(); } if (obj.getClass().isArray()) { return typeOf(obj.getClass()).toString(obj); } else if (obj instanceof Iterator) { final Iterator iter = (Iterator) obj; final Joiner joiner = Joiner.with(", ", "[", "]").reuseCachedBuffer(); while (iter.hasNext()) { joiner.append(CommonUtil.toString(iter.next())); } return joiner.toString(); } final Integer typeIdx = CLASS_TYPE_ENUM.get(obj.getClass()); if (typeIdx == null) { return obj.toString(); } switch (typeIdx.intValue()) { case 21: return toString(((Boolean) obj).booleanValue()); case 22: return toString(((Character) obj).charValue()); case 23: return toString(((Byte) obj).byteValue()); case 24: return toString(((Short) obj).shortValue()); case 25: return toString(((Integer) obj).intValue()); case 26: return toString(((Long) obj).longValue()); case 27: return toString(((Float) obj).floatValue()); case 28: return toString(((Double) obj).doubleValue()); default: return obj.toString(); } } /** * * @param obj * @return int */ public static String deepToString(final Object obj) { if (obj == null) { return NULL_STRING; } if (obj.getClass().isArray()) { return typeOf(obj.getClass()).deepToString(obj); } return obj.toString(); } /** * * @param a * @return * @see Arrays#toString(boolean[]) */ public static String toString(final boolean[] a) { if (a == null) { return CommonUtil.NULL_STRING; } if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final boolean[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final boolean[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final boolean[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(char[]) */ public static String toString(final char[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final char[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final char[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final char[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(byte[]) */ public static String toString(final byte[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final byte[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final byte[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final byte[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(short[]) */ public static String toString(final short[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final short[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final short[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final short[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(int[]) */ public static String toString(final int[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final int[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final int[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final int[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(long[]) */ public static String toString(final long[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final long[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final long[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final long[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(float[]) */ public static String toString(final float[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final float[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final float[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final float[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(double[]) */ public static String toString(final double[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final double[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final double[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final double[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(a[i]); } sb.append(WD._BRACKET_R); } /** * * @param a * @return * @see Arrays#toString(Object[]) */ public static String toString(final Object[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return toString(a, 0, a.length); } /** * * @param a * @param from * @param to * @return */ public static String toString(final Object[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); try { toString(sb, a, from, to); return sb.toString(); } finally { Objectory.recycle(sb); } } /** * * @param sb * @param a */ static void toString(final StringBuilder sb, final Object[] a) { if (a == null) { sb.append(NULL_STRING); } else if (a.length == 0) { sb.append("[]"); } else { toString(sb, a, 0, a.length); } } /** * * @param sb * @param a * @param from * @param to */ static void toString(final StringBuilder sb, final Object[] a, final int from, final int to) { sb.append(WD._BRACKET_L); for (int i = from; i < to; i++) { if (i > from) { sb.append(WD.COMMA_SPACE); } sb.append(toString(a[i])); } sb.append(WD._BRACKET_R); } /** * * @param a * @param defaultIfNull * @return */ public static String toString(final Object a, final String defaultIfNull) { return a == null ? defaultIfNull : toString(a); } /** * Deep to string. * * @param a * @return * @see Arrays#deepToString(Object[]) */ public static String deepToString(final Object[] a) { if (a == null) { return CommonUtil.NULL_STRING; } else if (a.length == 0) { return "[]"; } return deepToString(a, 0, a.length); } /** * Deep to string. * * @param a * @param from * @param to * @return */ public static String deepToString(final Object[] a, final int from, final int to) { final StringBuilder sb = Objectory.createStringBuilder(); final Set set = Objectory.createSet(); try { deepToString(sb, a, from, to, set); return sb.toString(); } finally { Objectory.recycle(set); Objectory.recycle(sb); } } /** * Deep to string. * * @param sb * @param a * @param processedElements */ static void deepToString(final StringBuilder sb, final Object[] a, final Set processedElements) { deepToString(sb, a, 0, a.length, processedElements); } /** * Deep to string. * * @param sb * @param a * @param from * @param to * @param processedElements */ static void deepToString(final StringBuilder sb, final Object[] a, final int from, final int to, final Set processedElements) { processedElements.add(a); sb.append(WD._BRACKET_L); Object element = null; Class eClass = null; for (int i = from; i < to; i++) { element = a[i]; if (i > from) { sb.append(WD.COMMA_SPACE); } if (element == null) { sb.append(CommonUtil.NULL_CHAR_ARRAY); continue; } eClass = element.getClass(); if (eClass.isArray()) { Integer enumInt = CLASS_TYPE_ENUM.get(eClass); int num = enumInt == null ? 0 : enumInt.intValue(); switch (num) { case 11: toString(sb, (boolean[]) element); break; case 12: toString(sb, (char[]) element); break; case 13: toString(sb, (byte[]) element); break; case 14: toString(sb, (short[]) element); break; case 15: toString(sb, (int[]) element); break; case 16: toString(sb, (long[]) element); break; case 17: toString(sb, (float[]) element); break; case 18: toString(sb, (double[]) element); break; case 19: toString(sb, (String[]) element); break; default: if (processedElements.contains(element)) { sb.append("[...]"); } else { deepToString(sb, (Object[]) element, processedElements); } } } else { // element is non-null and not an array sb.append(element.toString()); } } sb.append(WD._BRACKET_R); processedElements.remove(a); } /** * Deep to string. * * @param a * @param defaultIfNull * @return */ public static String deepToString(final Object[] a, final String defaultIfNull) { return a == null ? defaultIfNull : deepToString(a); } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final boolean[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final boolean[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } boolean tmp = false; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final char[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final char[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } char tmp = 0; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final byte[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final byte[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } byte tmp = 0; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final short[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final short[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } short tmp = 0; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final int[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final int[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } int tmp = 0; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final long[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final long[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } long tmp = 0L; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final float[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final float[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } float tmp = 0f; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** *

* Reverses the order of the given array. *

* * @param a */ public static void reverse(final double[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final double[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } double tmp = 0d; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } // Reverse // ----------------------------------------------------------------------- /** *

* Reverses the order of the given array. *

* *

* There is no special handling for multi-dimensional arrays. *

* * @param a */ public static void reverse(final Object[] a) { if (CommonUtil.isNullOrEmpty(a)) { return; } reverse(a, 0, a.length); } /** *

* Reverses the order of the given array in the given range. *

* * @param a * @param fromIndex * @param toIndex */ public static void reverse(final Object[] a, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, len(a)); if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } Object tmp = null; for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } /** * * @param list */ public static void reverse(final List list) { if (CommonUtil.isNullOrEmpty(list)) { return; } reverse(list, 0, list.size()); } /** * * @param list * @param fromIndex * @param toIndex */ public static void reverse(final List list, int fromIndex, int toIndex) { checkFromToIndex(fromIndex, toIndex, size(list)); if (CommonUtil.isNullOrEmpty(list) || list.size() == 1) { return; } final List l = (List) list; if (toIndex - fromIndex < REVERSE_THRESHOLD || list instanceof RandomAccess) { for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) { l.set(i, l.set(j, l.get(i))); } } else { final ListIterator fwd = l.listIterator(fromIndex); final ListIterator rev = l.listIterator(toIndex); for (int i = 0, mid = (toIndex - fromIndex) / 2; i < mid; i++) { Object tmp = fwd.next(); fwd.set(rev.previous()); rev.set(tmp); } } } /** * * @param c */ @SuppressWarnings("rawtypes") public static void reverse(final Collection c) { if (CommonUtil.isNullOrEmpty(c) || c.size() < 2) { return; } if (c instanceof List) { CommonUtil.reverse((List) c); } else { final Object[] tmp = c.toArray(); CommonUtil.reverse(tmp); c.clear(); c.addAll((List) Arrays.asList(tmp)); } } /** * * @param a * @param distance */ public static void rotate(final boolean[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { boolean tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final char[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { char tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final byte[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { byte tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final short[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { short tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final int[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { int tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final long[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { long tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final float[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { float tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final double[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { double tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param a * @param distance */ public static void rotate(final Object[] a, int distance) { if (a == null || a.length <= 1 || distance % a.length == 0) { return; } final int len = a.length; distance = distance % len; if (distance < 0) { distance += len; } if (distance == 0) { return; } for (int i = 0, count = 0; count < len; i++) { Object tmp = a[i]; int curr = i; int next = curr < distance ? curr - distance + len : curr - distance; while (next != i) { a[curr] = a[next]; curr = next; next = curr < distance ? curr - distance + len : curr - distance; count++; } a[curr] = tmp; count++; } } /** * * @param list * @param distance * @see java.util.Collections#rotate(List, int) */ public static void rotate(final List list, final int distance) { if (list == null || list.size() <= 1 || distance % list.size() == 0) { return; } Collections.rotate(list, distance); } /** * * @param c * @param distance */ @SuppressWarnings("rawtypes") public static void rotate(final Collection c, final int distance) { if (CommonUtil.isNullOrEmpty(c) || c.size() < 2) { return; } if (c instanceof List) { CommonUtil.rotate((List) c, distance); } else { final Object[] tmp = c.toArray(); CommonUtil.rotate(tmp, distance); c.clear(); c.addAll((List) Arrays.asList(tmp)); } } /** * * @param a */ public static void shuffle(final boolean[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final boolean[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final char[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final char[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final byte[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final byte[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final short[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final short[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final int[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final int[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final long[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final long[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final float[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final float[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param a */ public static void shuffle(final double[] a) { shuffle(a, RAND); } /** * * @param a * @param rnd */ public static void shuffle(final double[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param * @param a */ public static void shuffle(final T[] a) { shuffle(a, RAND); } /** * * @param * @param a * @param rnd */ public static void shuffle(final T[] a, final Random rnd) { if (CommonUtil.isNullOrEmpty(a) || a.length == 1) { return; } for (int i = a.length; i > 1; i--) { swap(a, i - 1, rnd.nextInt(i)); } } /** * * @param list */ public static void shuffle(final List list) { shuffle(list, RAND); } /** * * @param list * @param rnd * @see java.util.Collections#shuffle(List, Random) */ public static void shuffle(final List list, final Random rnd) { if (CommonUtil.isNullOrEmpty(list) || list.size() == 1) { return; } Collections.shuffle(list, rnd); } /** * * @param c */ @SuppressWarnings("rawtypes") public static void shuffle(final Collection c) { if (CommonUtil.isNullOrEmpty(c) || c.size() < 2) { return; } if (c instanceof List) { CommonUtil.shuffle((List) c); } else { final Object[] tmp = c.toArray(); CommonUtil.shuffle(tmp); c.clear(); c.addAll((List) Arrays.asList(tmp)); } } /** * * @param c * @param rnd */ @SuppressWarnings("rawtypes") public static void shuffle(final Collection c, final Random rnd) { if (CommonUtil.isNullOrEmpty(c) || c.size() < 2) { return; } if (c instanceof List) { CommonUtil.shuffle((List) c, rnd); } else { final Object[] tmp = c.toArray(); CommonUtil.shuffle(tmp, rnd); c.clear(); c.addAll((List) Arrays.asList(tmp)); } } /** * * @param a * @param i * @param j */ public static void swap(final boolean[] a, final int i, final int j) { final boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final char[] a, final int i, final int j) { final char tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final byte[] a, final int i, final int j) { final byte tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final short[] a, final int i, final int j) { final short tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final int[] a, final int i, final int j) { final int tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final long[] a, final int i, final int j) { final long tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final float[] a, final int i, final int j) { final float tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final double[] a, final int i, final int j) { final double tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param a * @param i * @param j */ public static void swap(final Object[] a, final int i, final int j) { final Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; } /** * * @param list * @param i * @param j */ public static void swap(final List list, final int i, final int j) { Collections.swap(list, i, j); } /** * * @param * @param pair */ public static void swap(final Pair pair) { pair.set(pair.right, pair.left); } /** * * @param * @param * @param pair * @param predicate * @return true, if successful * @throws E the e */ public static boolean swapIf(final Pair pair, Throwables.Predicate, E> predicate) throws E { if (predicate.test(pair)) { pair.set(pair.right, pair.left); return true; } return false; } /** * * @param * @param * @param triple */ public static void swap(final Triple triple) { final T left = triple.left; triple.setLeft(triple.right); triple.setRight(left); } /** * * @param * @param * @param * @param triple * @param predicate * @return true, if successful * @throws E the e */ public static boolean swapIf(final Triple triple, Throwables.Predicate, E> predicate) throws E { if (predicate.test(triple)) { final T left = triple.left; triple.setLeft(triple.right); triple.setRight(left); return true; } return false; } /** * * @param a * @param val */ public static void fill(final boolean[] a, final boolean val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final boolean[] a, final int fromIndex, final int toIndex, final boolean val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final char[] a, final char val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final char[] a, final int fromIndex, final int toIndex, final char val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final byte[] a, final byte val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final byte[] a, final int fromIndex, final int toIndex, final byte val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final short[] a, final short val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final short[] a, final int fromIndex, final int toIndex, final short val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final int[] a, final int val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final int[] a, final int fromIndex, final int toIndex, final int val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final long[] a, final long val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final long[] a, final int fromIndex, final int toIndex, final long val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final float[] a, final float val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final float[] a, final int fromIndex, final int toIndex, final float val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final double[] a, final double val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final double[] a, final int fromIndex, final int toIndex, final double val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param a * @param val */ public static void fill(final Object[] a, final Object val) { Arrays.fill(a, val); } /** * * @param a * @param fromIndex * @param toIndex * @param val */ public static void fill(final Object[] a, final int fromIndex, final int toIndex, final Object val) { Arrays.fill(a, fromIndex, toIndex, val); } /** * * @param * @param list * @param val */ public static void fill(final List list, final T val) { fill(list, 0, list.size(), val); } /** * The specified value will be added/inserted into the specified List. * The List will be extended automatically if the size of the List is less than the specified toIndex. * * @param * @param list * @param fromIndex * @param toIndex * @param val */ public static void fill(final List list, final int fromIndex, final int toIndex, final T val) { checkFromToIndex(fromIndex, toIndex, Integer.MAX_VALUE); int size = list.size(); if (size < toIndex) { if (fromIndex < size) { for (int i = fromIndex; i < size; i++) { list.set(i, val); } } else { for (int i = size; i < fromIndex; i++) { list.add(null); } } for (int i = 0, len = toIndex - list.size(); i < len; i++) { list.add(val); } } else { if (toIndex - fromIndex < FILL_THRESHOLD || list instanceof RandomAccess) { for (int i = fromIndex; i < toIndex; i++) { list.set(i, val); } } else { final ListIterator itr = list.listIterator(fromIndex); for (int i = fromIndex; i < toIndex; i++) { itr.next(); itr.set(val); } } } } /** * * @param * @param value * @param n * @return */ public static List repeat(final T value, final int n) { CommonUtil.checkArgNotNegative(n, "n"); final List res = new ArrayList<>(n); fill(res, 0, n, value); return res; } /** * Repeats the elements in the specified Collection one by one. * *
     * 
     * Seq.nRepeat(N.asList(1, 2, 3), 2) => [1, 1, 2, 2, 3, 3]
     * 
     * 
* * @param * @param c * @param n * @return */ public static List repeatEach(final Collection c, final int n) { CommonUtil.checkArgNotNegative(n, "n"); if (n == 0 || isNullOrEmpty(c)) { return new ArrayList<>(); } final List result = new ArrayList<>(c.size() * n); for (T e : c) { for (int i = 0; i < n; i++) { result.add(e); } } return result; } /** *
     * 
     * Seq.repeat(N.asList(1, 2, 3), 2) => [1, 2, 3, 1, 2, 3]
     * 
     * 
* * @param * @param c * @param n * @return */ public static List repeatAll(final Collection c, final int n) { CommonUtil.checkArgNotNegative(n, "n"); if (n == 0 || isNullOrEmpty(c)) { return new ArrayList<>(); } final List result = new ArrayList<>(c.size() * n); for (int i = 0; i < n; i++) { result.addAll(c); } return result; } /** * Repeats the elements in the specified Collection one by one till reach the specified size. * *
     * 
     * Seq.nRepeatToSize(N.asList(1, 2, 3), 5) => [1, 1, 2, 2, 3]
     * 
     * 
* * @param * @param c * @param size * @return */ public static List repeatEachToSize(final Collection c, final int size) { CommonUtil.checkArgNotNegative(size, "size"); checkArgument(size == 0 || notNullOrEmpty(c), "Collection can not be empty or null when size > 0"); if (size == 0 || isNullOrEmpty(c)) { return new ArrayList<>(); } final int n = size / c.size(); int mod = size % c.size(); final List result = new ArrayList<>(size); for (T e : c) { for (int i = 0, len = mod-- > 0 ? n + 1 : n; i < len; i++) { result.add(e); } if (result.size() == size) { break; } } return result; } /** *
     * 
     * Seq.repeatToSize(N.asList(1, 2, 3), 5) => [1, 2, 3, 1, 2]
     * 
     * 
* * @param * @param c * @param size * @return */ public static List repeatAllToSize(final Collection c, final int size) { CommonUtil.checkArgNotNegative(size, "size"); checkArgument(size == 0 || notNullOrEmpty(c), "Collection can not be empty or null when size > 0"); if (size == 0 || isNullOrEmpty(c)) { return new ArrayList<>(); } final List result = new ArrayList<>(size); while (result.size() < size) { if (c.size() <= size - result.size()) { result.addAll(c); } else { final Iterator iter = c.iterator(); for (int i = 0, len = size - result.size(); i < len; i++) { result.add(iter.next()); } } } return result; } /** * Copies all of the elements from one list into another. After the * operation, the index of each copied element in the destination list * will be identical to its index in the source list. The destination * list must be at least as long as the source list. If it is longer, the * remaining elements in the destination list are unaffected.

* * This method runs in linear time. * * @param * @param src * @param dest * @throws IndexOutOfBoundsException if the destination list is too small * to contain the entire source List. * @throws UnsupportedOperationException if the destination list's * list-iterator does not support the set operation. * @see java.util.Collections#copy(List, List) */ public static void copy(final List src, final List dest) { if (src.size() > dest.size()) { throw new IllegalArgumentException("Source does not fit in dest"); } Collections.copy(dest, src); } /** * * @param * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final List src, final int srcPos, final List dest, final int destPos, final int length) { if (src.size() < srcPos + length) { throw new IllegalArgumentException("The size of src list less than " + (srcPos + length)); } if (dest.size() < destPos + length) { throw new IllegalArgumentException("The size of dest list less than " + (destPos + length)); } if (src instanceof RandomAccess && dest instanceof RandomAccess) { for (int i = 0; i < length; i++) { dest.set(destPos + i, src.get(srcPos + i)); } } else { final ListIterator srcIterator = src.listIterator(); final ListIterator destIterator = dest.listIterator(); int idx = 0; while (idx < srcPos) { srcIterator.next(); idx++; } idx = 0; while (idx < destPos) { destIterator.next(); idx++; } for (int i = 0; i < length; i++) { destIterator.next(); destIterator.set(srcIterator.next()); } } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final boolean[] src, final int srcPos, final boolean[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final char[] src, final int srcPos, final char[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final byte[] src, final int srcPos, final byte[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final short[] src, final int srcPos, final short[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final int[] src, final int srcPos, final int[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final long[] src, final int srcPos, final long[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final float[] src, final int srcPos, final float[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final double[] src, final int srcPos, final double[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length */ public static void copy(final Object[] src, final int srcPos, final Object[] dest, final int destPos, final int length) { if (src.length < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (dest.length < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } if (length < MIN_SIZE_FOR_COPY_ALL) { // for same array copy. if (destPos > srcPos) { for (int i = length - 1; i >= 0; i--) { dest[destPos + i] = src[srcPos + i]; } } else { for (int i = 0; i < length; i++) { dest[destPos + i] = src[srcPos + i]; } } } else { System.arraycopy(src, srcPos, dest, destPos, length); } } /** * * @param src * @param srcPos * @param dest * @param destPos * @param length * @see System#arraycopy(Object, int, Object, int, int) is called */ public static void copy(final Object src, final int srcPos, final Object dest, final int destPos, final int length) { if (Array.getLength(src) < srcPos + length) { throw new IllegalArgumentException("The size of src array less than " + (srcPos + length)); } if (Array.getLength(dest) < destPos + length) { throw new IllegalArgumentException("The size of dest array less than " + (destPos + length)); } System.arraycopy(src, srcPos, dest, destPos, length); } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(boolean[], int) */ public static boolean[] copyOf(final boolean[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final boolean[] copy = new boolean[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(char[], int) */ public static char[] copyOf(final char[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final char[] copy = new char[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(byte[], int) */ public static byte[] copyOf(final byte[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final byte[] copy = new byte[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(short[], int) */ public static short[] copyOf(final short[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final short[] copy = new short[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(int[], int) */ public static int[] copyOf(final int[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final int[] copy = new int[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(long[], int) */ public static long[] copyOf(final long[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final long[] copy = new long[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(float[], int) */ public static float[] copyOf(final float[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final float[] copy = new float[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param original * @param newLength * @return * @see Arrays#copyOf(double[], int) */ public static double[] copyOf(final double[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } final double[] copy = new double[newLength]; if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * * @param * @param original * @param newLength * @return * @see Arrays#copyOf(Object[], int) */ public static T[] copyOf(final T[] original, final int newLength) { if (newLength == original.length) { return original.clone(); } return (T[]) copyOf(original, newLength, original.getClass()); } /** * * @param * @param * @param original * @param newLength * @param newType * @return * @see Arrays#copyOf(Object[], int, Class) */ public static T[] copyOf(final U[] original, final int newLength, final Class newType) { final T[] copy = Object[].class.equals(newType) ? (T[]) new Object[newLength] : (T[]) CommonUtil.newArray(newType.getComponentType(), newLength); if (CommonUtil.notNullOrEmpty(original)) { copy(original, 0, copy, 0, Math.min(original.length, newLength)); } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(boolean[], int, int) */ public static boolean[] copyOfRange(final boolean[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final boolean[] copy = new boolean[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static boolean[] copyOfRange(final boolean[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_BOOLEAN_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final boolean[] copy = new boolean[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(char[], int, int) */ public static char[] copyOfRange(final char[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final char[] copy = new char[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static char[] copyOfRange(final char[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_CHAR_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final char[] copy = new char[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(byte[], int, int) */ public static byte[] copyOfRange(final byte[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final byte[] copy = new byte[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static byte[] copyOfRange(final byte[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_BYTE_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final byte[] copy = new byte[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(short[], int, int) */ public static short[] copyOfRange(final short[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final short[] copy = new short[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static short[] copyOfRange(final short[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_SHORT_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final short[] copy = new short[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(int[], int, int) */ public static int[] copyOfRange(final int[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final int[] copy = new int[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * *

     * 
     * int[] a = { 0, 1, 2, 3, 4, 5 };
     * N.copyOfRange(a, 1, 5, 1)); // [1, 2, 3, 4]
     * N.copyOfRange(a, 1, 5, 2); // [1, 3]
     *
     * N.copyOfRange(a, 5, 1, -1); // [5, 4, 3, 2]
     * N.copyOfRange(a, 5, 1, -2); // [5, 3]
     * N.copyOfRange(a, 5, -1, -1); // [5, 4, 3, 2, 1, 0]
     * N.copyOfRange(a, 6, -1, -1); // [5, 4, 3, 2, 1, 0]
     * 
     * 
* * @param original * @param from * @param to * @param step * @return */ public static int[] copyOfRange(final int[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_INT_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final int[] copy = new int[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(long[], int, int) */ public static long[] copyOfRange(final long[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final long[] copy = new long[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static long[] copyOfRange(final long[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_LONG_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final long[] copy = new long[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(float[], int, int) */ public static float[] copyOfRange(final float[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final float[] copy = new float[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static float[] copyOfRange(final float[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_FLOAT_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final float[] copy = new float[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(double[], int, int) */ public static double[] copyOfRange(final double[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } final int newLength = to - from; final double[] copy = new double[newLength]; copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param original * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static double[] copyOfRange(final double[] original, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_DOUBLE_ARRAY; } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final double[] copy = new double[len]; for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param * @param original * @param from * @param to * @return * @see Arrays#copyOfRange(T[], int, int) */ public static T[] copyOfRange(final T[] original, final int from, final int to) { if (from == 0 && to == original.length) { return original.clone(); } return copyOfRange(original, from, to, (Class) original.getClass()); } /** * Copy all the elements in original, through to-from, by step. * * @param * @param original * @param from * @param to * @param step * @return */ public static T[] copyOfRange(final T[] original, final int from, final int to, final int step) { return copyOfRange(original, from, to, step, (Class) original.getClass()); } /** * {@link Arrays#copyOfRange(Object[], int, int, Class)}. * * @param * @param * @param original * @param from * @param to * @param newType * @return */ public static T[] copyOfRange(final U[] original, final int from, final int to, final Class newType) { final int newLength = to - from; final T[] copy = Object[].class.equals(newType) ? (T[]) new Object[newLength] : (T[]) CommonUtil.newArray(newType.getComponentType(), newLength); copy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; } /** * Copy all the elements in original, through to-from, by step. * * @param * @param original * @param from * @param to * @param step * @param newType * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ public static T[] copyOfRange(final T[] original, int from, final int to, final int step, final Class newType) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, original.length); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return Object[].class.equals(newType) ? (T[]) new Object[0] : (T[]) CommonUtil.newArray(newType.getComponentType(), 0); } if (step == 1) { return copyOfRange(original, from, to); } from = from > to ? N.min(original.length - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); final T[] copy = Object[].class.equals(newType) ? (T[]) new Object[len] : (T[]) CommonUtil.newArray(newType.getComponentType(), len); for (int i = 0, j = from; i < len; i++, j += step) { copy[i] = original[j]; } return copy; } /** * Copy of range. * * @param * @param c * @param from * @param to * @return * @see Arrays#copyOfRange(T[], int, int) */ public static List copyOfRange(final List c, final int from, final int to) { CommonUtil.checkFromToIndex(from, to, c.size()); final List result = new ArrayList<>(to - from); result.addAll(c.subList(from, to)); return result; } /** * Copy all the elements in original, through to-from, by step. * * @param * @param c * @param from * @param to * @param step * @return */ @SuppressWarnings("deprecation") public static List copyOfRange(final List c, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, c.size()); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return new ArrayList<>(); } if (step == 1) { return copyOfRange(c, from, to); } from = from > to ? N.min(c.size() - 1, from) : from; final int len = (to - from) / step + ((to - from) % step == 0 ? 0 : 1); List result = null; if (c instanceof RandomAccess) { result = new ArrayList<>(len); for (int i = 0, j = from; i < len; i++, j += step) { result.add(c.get(j)); } } else { final T[] a = (T[]) c.subList(from, to).toArray(); result = InternalUtil.createList(CommonUtil.copyOfRange(a, 0, a.length, step)); } return result; } /** * Copy of range. * * @param str * @param from * @param to * @return */ public static String copyOfRange(final String str, final int from, final int to) { return str.substring(from, to); } /** * Copy of range. * * @param str * @param from * @param to * @param step * @return * @see CommonUtil#copyOfRange(int[], int, int, int) */ @SuppressWarnings("deprecation") public static String copyOfRange(final String str, int from, final int to, final int step) { CommonUtil.checkFromToIndex(from < to ? from : (to == -1 ? 0 : to), from < to ? to : from, str.length()); if (step == 0) { throw new IllegalArgumentException("The input parameter 'by' can not be zero"); } if (from == to || from < to != step > 0) { return CommonUtil.EMPTY_STRING; } if (step == 1) { return copyOfRange(str, from, to); } return InternalUtil.newString(copyOfRange(InternalUtil.getCharsForReadOnly(str), from, to, step), true); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static boolean[] clone(final boolean[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static char[] clone(final char[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static byte[] clone(final byte[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static short[] clone(final short[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static int[] clone(final int[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static long[] clone(final long[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static float[] clone(final float[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param original * @return */ public static double[] clone(final double[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array. null is returned if the input array is null. * * @param * @param original * @return */ public static T[] clone(final T[] original) { if (original == null) { return null; } return original.clone(); } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static boolean[][] clone(final boolean[][] original) { if (original == null) { return null; } final boolean[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static char[][] clone(final char[][] original) { if (original == null) { return null; } final char[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static byte[][] clone(final byte[][] original) { if (original == null) { return null; } final byte[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static short[][] clone(final short[][] original) { if (original == null) { return null; } final short[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static int[][] clone(final int[][] original) { if (original == null) { return null; } final int[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static long[][] clone(final long[][] original) { if (original == null) { return null; } final long[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static float[][] clone(final float[][] original) { if (original == null) { return null; } final float[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static double[][] clone(final double[][] original) { if (original == null) { return null; } final double[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param * @param original * @return */ public static T[][] clone(final T[][] original) { if (original == null) { return null; } final T[][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static boolean[][][] clone(final boolean[][][] original) { if (original == null) { return null; } final boolean[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static char[][][] clone(final char[][][] original) { if (original == null) { return null; } final char[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static byte[][][] clone(final byte[][][] original) { if (original == null) { return null; } final byte[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static short[][][] clone(final short[][][] original) { if (original == null) { return null; } final short[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static int[][][] clone(final int[][][] original) { if (original == null) { return null; } final int[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static long[][][] clone(final long[][][] original) { if (original == null) { return null; } final long[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static float[][][] clone(final float[][][] original) { if (original == null) { return null; } final float[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param original * @return */ public static double[][][] clone(final double[][][] original) { if (original == null) { return null; } final double[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * Clone the original array and its sub arrays. null is returned if the input array is null. * * @param * @param original * @return */ public static T[][][] clone(final T[][][] original) { if (original == null) { return null; } final T[][][] cp = original.clone(); for (int i = 0, len = cp.length; i < len; i++) { cp[i] = clone(original[i]); } return cp; } /** * * @param * @param newType * @param a * @return */ public static T[] copy(Class newType, Object[] a) { if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.newArray(newType.getComponentType(), 0); } return CommonUtil.copyOf(a, a.length, newType); } /** * * @param * @param newType * @param a * @return */ public static T[][] copy(Class newType, Object[][] a) { final Class componentType = (Class) newType.getComponentType(); if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.newArray(componentType, 0); } final int len = CommonUtil.len(a); final T[][] result = CommonUtil.newArray(componentType, len); for (int i = 0; i < len; i++) { result[i] = copy(componentType, a[i]); } return result; } /** * * @param * @param newType * @param a * @return */ public static T[][][] copy(Class newType, Object[][][] a) { final Class componentType = (Class) newType.getComponentType(); if (CommonUtil.isNullOrEmpty(a)) { return CommonUtil.newArray(componentType, 0); } final int len = CommonUtil.len(a); final T[][][] result = CommonUtil.newArray(componentType, len); for (int i = 0; i < len; i++) { result[i] = copy(componentType, a[i]); } return result; } /** * * @param a */ public static void sort(final boolean[] a) { Array.sort(a); } /** * * @param a */ public static void sort(final char[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final char[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final byte[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final byte[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final short[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final short[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final int[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final int[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final long[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final long[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final float[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final float[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final double[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final double[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param a */ public static void sort(final Object[] a) { Array.sort(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void sort(final Object[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); } /** * * @param * @param a * @param cmp */ public static void sort(final T[] a, final Comparator cmp) { Array.sort(a, cmp); } /** * * @param * @param a * @param fromIndex * @param toIndex * @param cmp */ public static void sort(final T[] a, final int fromIndex, final int toIndex, final Comparator cmp) { Array.sort(a, fromIndex, toIndex, cmp); } /** * * @param * @param c */ public static > void sort(final List c) { Array.sort(c); } /** * * @param * @param c * @param fromIndex * @param toIndex */ public static > void sort(final List c, final int fromIndex, final int toIndex) { Array.sort(c, fromIndex, toIndex); } /** * * @param * @param c * @param cmp */ public static void sort(final List c, final Comparator cmp) { Array.sort(c, cmp); } /** * * @param * @param c * @param fromIndex * @param toIndex * @param cmp */ public static void sort(final List c, final int fromIndex, final int toIndex, final Comparator cmp) { Array.sort(c, fromIndex, toIndex, cmp); } /** * * @param * @param * @param a * @param keyMapper */ public static > void sortBy(final T[] a, final Function keyMapper) { sort(a, Comparators.comparingBy(keyMapper)); } /** * * @param * @param * @param c * @param keyMapper */ public static > void sortBy(final List c, final Function keyMapper) { sort(c, Comparators.comparingBy(keyMapper)); } /** * Sort by int. * * @param * @param a * @param keyMapper */ public static void sortByInt(final T[] a, final ToIntFunction keyMapper) { sort(a, Comparators.comparingInt(keyMapper)); } /** * Sort by int. * * @param * @param c * @param keyMapper */ public static void sortByInt(final List c, final ToIntFunction keyMapper) { sort(c, Comparators.comparingInt(keyMapper)); } /** * Sort by long. * * @param * @param a * @param keyMapper */ public static void sortByLong(final T[] a, final ToLongFunction keyMapper) { sort(a, Comparators.comparingLong(keyMapper)); } /** * Sort by long. * * @param * @param c * @param keyMapper */ public static void sortByLong(final List c, final ToLongFunction keyMapper) { sort(c, Comparators.comparingLong(keyMapper)); } /** * Sort by double. * * @param * @param a * @param keyMapper */ public static void sortByDouble(final T[] a, final ToDoubleFunction keyMapper) { sort(a, Comparators.comparingDouble(keyMapper)); } /** * Sort by double. * * @param * @param c * @param keyMapper */ public static void sortByDouble(final List c, final ToDoubleFunction keyMapper) { sort(c, Comparators.comparingDouble(keyMapper)); } /** * * @param a */ public static void reverseSort(final boolean[] a) { Array.reverseSort(a); } /** * * @param a */ public static void reverseSort(final char[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final char[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final byte[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final byte[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final short[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final short[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final int[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final int[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final long[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final long[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final float[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final float[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final double[] a) { Array.sort(a); reverse(a); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final double[] a, final int fromIndex, final int toIndex) { Array.sort(a, fromIndex, toIndex); reverse(a, fromIndex, toIndex); } /** * * @param a */ public static void reverseSort(final Object[] a) { sort(a, Fn.reversedOrder()); } /** * * @param a * @param fromIndex * @param toIndex */ public static void reverseSort(final Object[] a, final int fromIndex, final int toIndex) { sort(a, fromIndex, toIndex, Fn.reversedOrder()); } /** * * @param * @param c */ public static > void reverseSort(final List c) { sort(c, Fn.reversedOrder()); } /** * * @param * @param c * @param fromIndex * @param toIndex */ public static > void reverseSort(final List c, final int fromIndex, final int toIndex) { sort(c, fromIndex, toIndex, Fn.reversedOrder()); } /** * Reverse sort by. * * @param * @param * @param a * @param keyMapper */ public static > void reverseSortBy(final T[] a, final Function keyMapper) { sort(a, Comparators.reversedComparingBy(keyMapper)); } /** * Reverse sort by. * * @param * @param * @param c * @param keyMapper */ public static > void reverseSortBy(final List c, final Function keyMapper) { sort(c, Comparators.reversedComparingBy(keyMapper)); } /** * {@link Arrays#binarySearch(boolean[], boolean)}. * * @param a * @param key * @return */ static int binarySearch(final boolean[] a, final boolean key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(char[], char)}. * * @param a * @param key * @return */ public static int binarySearch(final char[] a, final char key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(char[], int, int, char)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final char[] a, final int fromIndex, final int toIndex, final char key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(byte[], byte)}. * * @param a * @param key * @return */ public static int binarySearch(final byte[] a, final byte key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(byte[], int, int, byte)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final byte[] a, final int fromIndex, final int toIndex, final byte key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(short[], short)}. * * @param a * @param key * @return */ public static int binarySearch(final short[] a, final short key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(short[], int, int, short)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final short[] a, final int fromIndex, final int toIndex, final short key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(int[], int)}. * * @param a * @param key * @return */ public static int binarySearch(final int[] a, final int key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(int[], int, int, int)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final int[] a, final int fromIndex, final int toIndex, final int key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(long[], long)}. * * @param a * @param key * @return */ public static int binarySearch(final long[] a, final long key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(long[], int, int, long)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final long[] a, final int fromIndex, final int toIndex, final long key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(float[], float)}. * * @param a * @param key * @return */ public static int binarySearch(final float[] a, final float key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(float[], int, int, float)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final float[] a, final int fromIndex, final int toIndex, final float key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(double[], double)}. * * @param a * @param key * @return */ public static int binarySearch(final double[] a, final double key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(double[], int, int, double)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final double[] a, final int fromIndex, final int toIndex, final double key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(Object[], Object)}. * * @param a * @param key * @return */ public static int binarySearch(final Object[] a, final Object key) { return Array.binarySearch(a, key); } /** * {@link Arrays#binarySearch(Object[], int, int, Object)}. * * @param a * @param fromIndex * @param toIndex * @param key * @return */ public static int binarySearch(final Object[] a, final int fromIndex, final int toIndex, final Object key) { return Array.binarySearch(a, fromIndex, toIndex, key); } /** * {@link Arrays#binarySearch(Object[], Object, Comparator)}. * * @param * @param a * @param key * @param cmp * @return */ public static int binarySearch(final T[] a, final T key, final Comparator cmp) { return Array.binarySearch(a, key, cmp); } /** * {@link Arrays#binarySearch(Object[], int, int, Object, Comparator)}. * * @param * @param a * @param fromIndex * @param toIndex * @param key * @param cmp * @return */ public static int binarySearch(final T[] a, final int fromIndex, final int toIndex, final T key, final Comparator cmp) { return Array.binarySearch(a, fromIndex, toIndex, key, cmp); } /** * {@link Collections#binarySearch(List, Object)}. * * @param * @param c * @param key * @return */ public static > int binarySearch(final List c, final T key) { return Array.binarySearch(c, key); } /** * * @param * @param c * @param fromIndex * @param toIndex * @param key * @return */ public static > int binarySearch(final List c, final int fromIndex, final int toIndex, final T key) { return Array.binarySearch(c, fromIndex, toIndex, key); } /** * * @param * @param c * @param key * @param cmp * @return */ public static int binarySearch(final List c, final T key, final Comparator cmp) { return Array.binarySearch(c, key, cmp); } /** * * @param * @param c * @param fromIndex * @param toIndex * @param key * @param cmp * @return * @see Collections#binarySearch(List, Object, Comparator) */ public static int binarySearch(final List c, final int fromIndex, final int toIndex, final T key, final Comparator cmp) { return Array.binarySearch(c, fromIndex, toIndex, key, cmp); } /** * Binary search by. * * @param * @param * @param a * @param key * @param keyMapper * @return */ public static > int binarySearchBy(final T[] a, final T key, final Function keyMapper) { return binarySearch(a, key, Comparators.comparingBy(keyMapper)); } /** * Binary search by. * * @param * @param * @param c * @param key * @param keyMapper * @return */ public static > int binarySearchBy(final List c, final T key, final Function keyMapper) { return binarySearch(c, key, Comparators.comparingBy(keyMapper)); } /** * * @param a * @param e * @return */ public static int indexOf(final boolean[] a, final boolean e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final boolean[] a, final int fromIndex, final boolean e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final char[] a, final char e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final char[] a, final int fromIndex, final char e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final byte[] a, final byte e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final byte[] a, final int fromIndex, final byte e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final short[] a, final short e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final short[] a, final int fromIndex, final short e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final int[] a, final int e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final int[] a, final int fromIndex, final int e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final long[] a, final long e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final long[] a, final int fromIndex, final long e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final float[] a, final float e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final float[] a, final int fromIndex, final float e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (Float.compare(a[i], e) == 0) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final double[] a, final double e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final double[] a, final int fromIndex, final double e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (Double.compare(a[i], e) == 0) { return i; } } return INDEX_NOT_FOUND; } /** * * @param a * @param e * @return */ public static int indexOf(final Object[] a, final Object e) { return indexOf(a, 0, e); } /** * * @param a * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final Object[] a, final int fromIndex, final Object e) { final int len = len(a); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } for (int i = N.max(fromIndex, 0); i < len; i++) { if (equals(a[i], e)) { return i; } } return INDEX_NOT_FOUND; } /** * * @param list * @param e * @return */ public static int indexOf(final List list, final Object e) { return indexOf(list, 0, e); } /** * * @param list * @param fromIndex the index from which to start the search. * @param e * @return */ public static int indexOf(final List list, final int fromIndex, final Object e) { final int len = size(list); if (len == 0 || fromIndex >= len) { return INDEX_NOT_FOUND; } if (list instanceof RandomAccess) { for (int i = N.max(fromIndex, 0); i < len; i++) { if (equals(list.get(i), e)) { return i; } } } else { final ListIterator iter = list.listIterator(N.max(fromIndex, 0)); int idx = fromIndex; while (iter.hasNext()) { if (equals(iter.next(), e)) { return idx; } idx++; } } return INDEX_NOT_FOUND; } /** * Index of sub list. * * @param sourceList * @param targetSubList * @return * @see java.util.Collections#indexOfSubList(List, List) */ public static int indexOfSubList(final List sourceList, final List targetSubList) { if (CommonUtil.isNullOrEmpty(sourceList) || CommonUtil.isNullOrEmpty(targetSubList)) { return INDEX_NOT_FOUND; } return Collections.indexOfSubList(sourceList, targetSubList); } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final boolean[] a, final boolean e) { return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final boolean[] a, final int fromIndex, final boolean e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final char[] a, final char e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final char[] a, final int fromIndex, final char e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final byte[] a, final byte e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final byte[] a, final int fromIndex, final byte e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final short[] a, final short e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final short[] a, final int fromIndex, final short e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final int[] a, final int e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final int[] a, final int fromIndex, final int e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final long[] a, final long e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final long[] a, final int fromIndex, final long e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (a[i] == e) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final float[] a, final float e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final float[] a, final int fromIndex, final float e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (Float.compare(a[i], e) == 0) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final double[] a, final double e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final double[] a, final int fromIndex, final double e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (Double.compare(a[i], e) == 0) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param a * @param e * @return */ public static int lastIndexOf(final Object[] a, final Object e) { if (CommonUtil.isNullOrEmpty(a)) { return INDEX_NOT_FOUND; } return lastIndexOf(a, a.length - 1, e); } /** * Last index of. * * @param a * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final Object[] a, final int fromIndex, final Object e) { final int len = len(a); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (equals(a[i], e)) { return i; } } return INDEX_NOT_FOUND; } /** * Last index of. * * @param list * @param e * @return */ public static int lastIndexOf(final List list, final Object e) { if (CommonUtil.isNullOrEmpty(list)) { return INDEX_NOT_FOUND; } return lastIndexOf(list, list.size() - 1, e); } /** * Last index of. * * @param list * @param fromIndex the start index to traverse backwards from * @param e * @return */ public static int lastIndexOf(final List list, final int fromIndex, final Object e) { final int len = size(list); if (len == 0 || fromIndex < 0) { return INDEX_NOT_FOUND; } if (list instanceof RandomAccess) { for (int i = N.min(fromIndex, len - 1); i >= 0; i--) { if (equals(list.get(i), e)) { return i; } } } else { int startIndexFromBack = N.min(fromIndex, len - 1); final ListIterator iter = list.listIterator(startIndexFromBack + 1); while (iter.hasPrevious()) { if (equals(iter.previous(), e)) { return startIndexFromBack; } startIndexFromBack--; } } return INDEX_NOT_FOUND; } /** * Last index of sub list. * * @param sourceList * @param targetSubList * @return * @see java.util.Collections#lastIndexOfSubList(List, List) */ public static int lastIndexOfSubList(final List sourceList, final List targetSubList) { if (CommonUtil.isNullOrEmpty(sourceList) || CommonUtil.isNullOrEmpty(targetSubList)) { return INDEX_NOT_FOUND; } return Collections.lastIndexOfSubList(sourceList, targetSubList); } /** * Find first index. * * @param the generic type * @param the element type * @param a the a * @param predicate the predicate * @return the optional int * @throws E the e */ @SuppressWarnings("deprecation") public static OptionalInt findFirstIndex(final T[] a, final Throwables.Predicate predicate) throws E { return Iterables.findFirstIndex(a, predicate); } /** * Find first index. * * @param the generic type * @param the element type * @param c the c * @param predicate the predicate * @return the optional int * @throws E the e */ @SuppressWarnings("deprecation") public static OptionalInt findFirstIndex(final Collection c, final Throwables.Predicate predicate) throws E { return Iterables.findFirstIndex(c, predicate); } /** * Find last index. * * @param the generic type * @param the element type * @param a the a * @param predicate the predicate * @return the optional int * @throws E the e */ @SuppressWarnings("deprecation") public static OptionalInt findLastIndex(final T[] a, final Throwables.Predicate predicate) throws E { return Iterables.findLastIndex(a, predicate); } /** * Find last index. * * @param the generic type * @param the element type * @param c the c * @param predicate the predicate * @return the optional int * @throws E the e */ @SuppressWarnings("deprecation") public static OptionalInt findLastIndex(final Collection c, final Throwables.Predicate predicate) throws E { return Iterables.findLastIndex(c, predicate); } /** * Creates the mask. * * @param * @param interfaceClass * @return */ static T createMask(final Class interfaceClass) { InvocationHandler h = new InvocationHandler() { @Override public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable { throw new UnsupportedOperationException("It's a mask"); } }; return newProxyInstance(interfaceClass, h); } /** * The Class NullMask. */ static class NullMask implements Serializable { /** The Constant serialVersionUID. */ private static final long serialVersionUID = 5887875956120266479L; /** * Instantiates a new null mask. */ private NullMask() { } /** * * @return */ @Override public String toString() { return "NULL"; } /** * * @return */ private Object readResolve() { return NULL_MASK; } } }