Java checks whether an array check is an empty array to check if an array contains an element

    /**      * Determine whether the given object is an array:     * Either an object array or a primitive array.      @param obj the object to check      */     Public Static Boolean IsArray (Object obj) {        returnnull && obj.getclass (). IsArray ());    } 

    /**      * Determine whether the given array is empty:     * i.e. {@code  null} or of zero length.      @param  array the array to check     */public    static Boolean IsEmpty (object[] array) {        returnnull | | array.length = = 0);    }

    /*** Check Whether the given array contains the given element. * @paramarray the array to check@codenull}, * in which case the return value would always be {@codefalse}) * @paramelement The element to check for *@returnwhether the element has been found in the given array*/     Public Static Booleancontainselement (object[] array, Object element) {if(Array = =NULL) {            return false; }         for(Object arrayele:array) {if(Nullsafeequals (Arrayele, Element)) {return true; }        }        return false; }

Two objects are equal, including array of numbers

    /*** Determine if the given objects is equal, returning {@codetrue} * If both is {@codenull} or {@codefalse} If only one is * {@codenull}. * <p>compares arrays with {@codeArrays.equals}, performing an equality * check based on the array elements rather than the array reference. * @paramO1 First Object to compare *@paramO2 Second Object to compare *@returnwhether the given objects is equal *@seejava.util.arrays#equals*/     Public Static BooleanNullsafeequals (Object O1, Object O2) {if(O1 = =O2) {            return true; }        if(O1 = =NULL|| O2 = =NULL) {            return false; }        if(O1.equals (O2)) {return true; }        if(O1.getclass (). IsArray () &&O2.getclass (). IsArray ()) {            if(O1instanceofObject[] && O2instanceofobject[]) {                returnarrays.equals ((object[]) O1, (object[]) O2); }            if(O1instanceof Boolean[] && O2instanceof Boolean[]) {                returnArrays.equals ((Boolean[]) O1, (Boolean[]) O2); }            if(O1instanceof byte[] && O2instanceof byte[]) {                returnArrays.equals ((byte[]) O1, (byte[]) O2); }            if(O1instanceof Char[] && O2instanceof Char[]) {                returnArrays.equals ((Char[]) O1, (Char[]) O2); }            if(O1instanceof Double[] && O2instanceof Double[]) {                returnArrays.equals ((Double[]) O1, (Double[]) O2); }            if(O1instanceof float[] && O2instanceof float[]) {                returnArrays.equals ((float[]) O1, (float[]) O2); }            if(O1instanceof int[] && O2instanceof int[]) {                returnArrays.equals ((int[]) O1, (int[]) O2); }            if(O1instanceof Long[] && O2instanceof Long[]) {                returnArrays.equals ((Long[]) O1, (Long[]) O2); }            if(O1instanceof  Short[] && O2instanceof  Short[]) {                returnArrays.equals (( Short[]) O1, ( Short[]) O2); }        }        return false; }

Determines whether a string is included in the enumeration array (ignoring case)

    /*** Check whether the given array of enum constants contains a constant with the given name, * ignoring case WH     En determining a match. * @paramEnumValues the enum values to check, typically the product of a call to Myenum.values () *@paramconstant The constant name to find (must isn't be null or empty string) *@returnwhether the constant have been found in the given array*/     Public Static BooleanContainsconstant (enum<?>[] enumvalues, String constant) {        returnContainsconstant (EnumValues, Constant,false); }

Determines whether a string is contained in the enumeration array

    /*** Check whether the given array of enum constants contains a constant with the given name. * @paramEnumValues the enum values to check, typically the product of a call to Myenum.values () *@paramconstant The constant name to find (must isn't be null or empty string) *@paramCaseSensitive Whether case was significant in determining a match *@returnwhether the constant have been found in the given array*/     Public Static BooleanContainsconstant (enum<?>[] enumvalues, String constant,Booleancasesensitive) {         for(enum<?>candidate:enumvalues) {            if(casesensitive?)candidate.tostring (). Equals (constant): Candidate.tostring (). Equalsignorecase (c Onstant)) {return true; }        }        return false; }

    /*** Case insensitive alternative to {@linkenum#valueof (Class, String)}. * @param<E> The concrete Enum type *@paramEnumValues The array of all enums constants in question, usually per enum.values () *@paramconstant The constant to get the enum value of *@throwsIllegalArgumentException 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<eextendsEnum<?>>E caseinsensitivevalueof (e[] enumvalues, String constant) { for(E candidate:enumvalues) {if(Candidate.tostring (). Equalsignorecase (constant)) {returncandidate; }        }        Throw Newillegalargumentexception (String.Format ("Constant [%s] does not exist in enum type%s", Constant, Enumvalues.getclass (). Getcomponenttype (). GetName ())); }

Java checks whether an array check is an empty array to check if an array contains an element