仿抖音个人中心，下拉放大缩小效果

package cn.migudm.pullzoomdemo; import java.lang.reflect.Array; import java.util.Arrays; /** * Desc: * <p> * Author: yzd * Date: 2018-08-09 * Copyright: Copyright (c) 2010-2018 * Company: @咪咕动漫 * Updater: * Update Time: * Update Comments: */ public class ObjectUtil { /** * Instantiates a new Object util. */ private ObjectUtil() { } /** * The constant INITIAL_HASH. */ private static final int INITIAL_HASH = 7; /** * The constant MULTIPLIER. */ private static final int MULTIPLIER = 31; /** * The constant EMPTY_STRING. */ private static final String EMPTY_STRING = ""; /** * The constant NULL_STRING. */ private static final String NULL_STRING = "null"; /** * The constant ARRAY_START. */ private static final String ARRAY_START = "{"; /** * The constant ARRAY_END. */ private static final String ARRAY_END = "}"; /** * The constant EMPTY_ARRAY. */ private static final String EMPTY_ARRAY = ARRAY_START + ARRAY_END; /** * The constant ARRAY_ELEMENT_SEPARATOR. */ private static final String ARRAY_ELEMENT_SEPARATOR = ", "; /** * Return whether the given throwable is a checked exception: that is, * neither a RuntimeException nor an Error. * * @param ex the throwable to check * @return whether the throwable is a checked exception * @see Exception * @see RuntimeException * @see Error */ public static boolean isCheckedException(Throwable ex) { return !(ex instanceof RuntimeException || ex instanceof Error); } /** * Check whether the given exception is compatible with the exceptions * declared in a throws clause. * * @param ex the exception to checked * @param declaredExceptions the exceptions declared in the throws clause * @return whether the given exception is compatible */ public static boolean isCompatibleWithThrowsClause(Throwable ex, Class<?>[] declaredExceptions) { if (!isCheckedException(ex)) { return true; } if (declaredExceptions != null) { int i = 0; while (i < declaredExceptions.length) { if (declaredExceptions[i].isAssignableFrom(ex.getClass())) { return true; } i++; } } return false; } /** * Determine whether the given object is an array: either an Object array or * a primitive array. * * @param obj the object to check * @return boolean */ public static boolean isArray(Object obj) { return (obj != null && obj.getClass().isArray()); } /** * Determine whether the given array is empty: i.e. <code>null</code> or of * zero length. * * @param array the array to check * @return boolean */ public static boolean isEmpty(Object[] array) { return (array == null || array.length == 0); } /** * Check whether the given array contains the given element. * * @param array the array to check (may be <code>null</code>, in which case the return value will always be <code>false</code>) * @param element the element to check for * @return whether the element has been found in the given array */ public static boolean containsElement(Object[] array, Object element) { if (array == null) { return false; } for (Object arrayEle : array) { if (nullSafeEquals(arrayEle, element)) { return true; } } return false; } /** * Check whether the given array of enum constants contains a constant with * the given name, ignoring case when determining a match. * * @param enumValues the enum values to check, typically the product of a call to MyEnum.values() * @param constant the constant name to find (must not be null or empty string) * @return whether the constant has been found in the given array */ public static boolean containsConstant(Enum<?>[] enumValues, String constant) { return containsConstant(enumValues, constant, false); } /** * Check whether the given array of enum constants contains a constant with * the given name. * * @param enumValues the enum values to check, typically the product of a call to MyEnum.values() * @param constant the constant name to find (must not be null or empty string) * @param caseSensitive whether case is significant in determining a match * @return whether the constant has been found in the given array */ public static boolean containsConstant(Enum<?>[] enumValues, String constant, boolean caseSensitive) { for (Enum<?> candidate : enumValues) { if (caseSensitive ? candidate.toString().equals(constant) : candidate.toString().equalsIgnoreCase(constant)) { return true; } } return false; } /** * Case insensitive alternative to {@link Enum#valueOf(Class, String)}. * * @param <E> the concrete Enum type * @param enumValues the array of all Enum constants in question, usually per Enum.values() * @param constant the constant to get the enum value of * @return e * @throws IllegalArgumentException if the given constant is not found in the given array of enum values. Use {@link #containsConstant(Enum[], String)} as a guard to avoid this exception. */ public static <E extends Enum<?>> E caseInsensitiveValueOf(E[] enumValues, String constant) { for (E candidate : enumValues) { if (candidate.toString().equalsIgnoreCase(constant)) { return candidate; } } throw new IllegalArgumentException( String.format("constant [%s] does not exist in enum type %s", constant, enumValues.getClass().getComponentType().getName())); } /** * Append the given object to the given array, returning a new array * consisting of the input array contents plus the given object. * * @param <A> * @param <O> * @param array the array to append to (can be <code>null</code>) * @param obj the object to append * @return the new array (of the same component type; never <code>null</code>) */ 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</code> source value will be converted to an empty Object * array. * * @param source the (potentially primitive) array * @return the corresponding object array (never <code>null</code>) * @throws IllegalArgumentException if the parameter is not an array */ public static Object[] toObjectArray(Object source) { if (source instanceof Object[]) { return (Object[]) source; } if (so