/**     * Append the given object to the given array, returning a new array     * consisting of the input array contents plus the given object.     * @param array the array to append to (can be {@code null})     * @param obj the object to append     * @return the new array (of the same component type; never {@code null})     */    public static <A, O extends A> A[] addObjectToArray(A[] array, O obj) {        Class<?> compType = Object.class;        if (array != null) {            compType = array.getClass().getComponentType();        }        else if (obj != null) {            compType = obj.getClass();        }        int newArrLength = (array != null ? array.length + 1 : 1);        @SuppressWarnings("unchecked")        A[] newArr = (A[]) Array.newInstance(compType, newArrLength);        if (array != null) {            System.arraycopy(array, 0, newArr, 0, array.length);        }        newArr[newArr.length - 1] = obj;        return newArr;    }

    /**     * Convert the given array (which may be a primitive array) to an     * object array (if necessary of primitive wrapper objects).     * <p>A {@code null} source value will be converted to an     * empty Object array.     * @param source the (potentially primitive) array     * @return the corresponding object array (never {@code null})     * @throws IllegalArgumentException if the parameter is not an array     */    public static Object[] toObjectArray(Object source) {        if (source instanceof Object[]) {            return (Object[]) source;        }        if (source == null) {            return new Object[0];        }        if (!source.getClass().isArray()) {            throw new IllegalArgumentException("Source is not an array: " + source);        }        int length = Array.getLength(source);        if (length == 0) {            return new Object[0];        }        Class<?> wrapperType = Array.get(source, 0).getClass();        Object[] newArray = (Object[]) Array.newInstance(wrapperType, length);        for (int i = 0; i < length; i++) {            newArray[i] = Array.get(source, i);        }        return newArray;    }

    /**     * Return as hash code for the given object; typically the value of     * {@code Object#hashCode()}}. If the object is an array,     * this method will delegate to any of the {@code nullSafeHashCode}     * methods for arrays in this class. If the object is {@code null},     * this method returns 0.     * @see #nullSafeHashCode(Object[])     * @see #nullSafeHashCode(boolean[])     * @see #nullSafeHashCode(byte[])     * @see #nullSafeHashCode(char[])     * @see #nullSafeHashCode(double[])     * @see #nullSafeHashCode(float[])     * @see #nullSafeHashCode(int[])     * @see #nullSafeHashCode(long[])     * @see #nullSafeHashCode(short[])     */    public static int nullSafeHashCode(Object obj) {        if (obj == null) {            return 0;        }        if (obj.getClass().isArray()) {            if (obj instanceof Object[]) {                return nullSafeHashCode((Object[]) obj);            }            if (obj instanceof boolean[]) {                return nullSafeHashCode((boolean[]) obj);            }            if (obj instanceof byte[]) {                return nullSafeHashCode((byte[]) obj);            }            if (obj instanceof char[]) {                return nullSafeHashCode((char[]) obj);            }            if (obj instanceof double[]) {                return nullSafeHashCode((double[]) obj);            }            if (obj instanceof float[]) {                return nullSafeHashCode((float[]) obj);            }            if (obj instanceof int[]) {                return nullSafeHashCode((int[]) obj);            }            if (obj instanceof long[]) {                return nullSafeHashCode((long[]) obj);            }            if (obj instanceof short[]) {                return nullSafeHashCode((short[]) obj);            }        }        return obj.hashCode();    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(Object[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (Object element : array) {            hash = MULTIPLIER * hash + nullSafeHashCode(element);        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(boolean[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (boolean element : array) {            hash = MULTIPLIER * hash + hashCode(element);        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(byte[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (byte element : array) {            hash = MULTIPLIER * hash + element;        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(char[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (char element : array) {            hash = MULTIPLIER * hash + element;        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(double[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (double element : array) {            hash = MULTIPLIER * hash + hashCode(element);        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(float[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (float element : array) {            hash = MULTIPLIER * hash + hashCode(element);        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(int[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (int element : array) {            hash = MULTIPLIER * hash + element;        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(long[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (long element : array) {            hash = MULTIPLIER * hash + hashCode(element);        }        return hash;    }    /**     * Return a hash code based on the contents of the specified array.     * If {@code array} is {@code null}, this method returns 0.     */    public static int nullSafeHashCode(short[] array) {        if (array == null) {            return 0;        }        int hash = INITIAL_HASH;        for (short element : array) {            hash = MULTIPLIER * hash + element;        }        return hash;    }    /**     * Return the same value as {@link Boolean#hashCode()}}.     * @see Boolean#hashCode()     */    public static int hashCode(boolean bool) {        return (bool ? 1231 : 1237);    }    /**     * Return the same value as {@link Double#hashCode()}}.     * @see Double#hashCode()     */    public static int hashCode(double dbl) {        return hashCode(Double.doubleToLongBits(dbl));    }    /**     * Return the same value as {@link Float#hashCode()}}.     * @see Float#hashCode()     */    public static int hashCode(float flt) {        return Float.floatToIntBits(flt);    }    /**     * Return the same value as {@link Long#hashCode()}}.     * @see Long#hashCode()     */    public static int hashCode(long lng) {        return (int) (lng ^ (lng >>> 32));    }