    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.lang;
    018
    019    import java.lang.reflect.Array;
    020    import java.util.HashMap;
    021    import java.util.Map;
    022
    023    import org.apache.commons.lang.builder.EqualsBuilder;
    024    import org.apache.commons.lang.builder.HashCodeBuilder;
    025    import org.apache.commons.lang.builder.ToStringBuilder;
    026    import org.apache.commons.lang.builder.ToStringStyle;
    027
    028    /**
    029     * <p>Operations on arrays, primitive arrays (like <code>int[]</code>) and
    030     * primitive wrapper arrays (like <code>Integer[]</code>).</p>
    031     *
    032     * <p>This class tries to handle <code>null</code> input gracefully.
    033     * An exception will not be thrown for a <code>null</code>
    034     * array input. However, an Object array that contains a <code>null</code>
    035     * element may throw an exception. Each method documents its behaviour.</p>
    036     *
    037     * <p>#ThreadSafe#</p>
    038     * @author Apache Software Foundation
    039     * @author Moritz Petersen
    040     * @author <a href="mailto:fredrik@westermarck.com">Fredrik Westermarck</a>
    041     * @author Nikolay Metchev
    042     * @author Matthew Hawthorne
    043     * @author Tim O'Brien
    044     * @author Pete Gieser
    045     * @author Gary Gregory
    046     * @author <a href="mailto:equinus100@hotmail.com">Ashwin S</a>
    047     * @author Maarten Coene
    048     * @since 2.0
    049     * @version $Id: ArrayUtils.java 1056988 2011-01-09 17:58:53Z niallp $
    050     */
    051    public class ArrayUtils {
    052
    053        /**
    054         * An empty immutable <code>Object</code> array.
    055         */
    056        public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
    057        /**
    058         * An empty immutable <code>Class</code> array.
    059         */
    060        public static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
    061        /**
    062         * An empty immutable <code>String</code> array.
    063         */
    064        public static final String[] EMPTY_STRING_ARRAY = new String[0];
    065        /**
    066         * An empty immutable <code>long</code> array.
    067         */
    068        public static final long[] EMPTY_LONG_ARRAY = new long[0];
    069        /**
    070         * An empty immutable <code>Long</code> array.
    071         */
    072        public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];
    073        /**
    074         * An empty immutable <code>int</code> array.
    075         */
    076        public static final int[] EMPTY_INT_ARRAY = new int[0];
    077        /**
    078         * An empty immutable <code>Integer</code> array.
    079         */
    080        public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];
    081        /**
    082         * An empty immutable <code>short</code> array.
    083         */
    084        public static final short[] EMPTY_SHORT_ARRAY = new short[0];
    085        /**
    086         * An empty immutable <code>Short</code> array.
    087         */
    088        public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];
    089        /**
    090         * An empty immutable <code>byte</code> array.
    091         */
    092        public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
    093        /**
    094         * An empty immutable <code>Byte</code> array.
    095         */
    096        public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];
    097        /**
    098         * An empty immutable <code>double</code> array.
    099         */
    100        public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
    101        /**
    102         * An empty immutable <code>Double</code> array.
    103         */
    104        public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0];
    105        /**
    106         * An empty immutable <code>float</code> array.
    107         */
    108        public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
    109        /**
    110         * An empty immutable <code>Float</code> array.
    111         */
    112        public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];
    113        /**
    114         * An empty immutable <code>boolean</code> array.
    115         */
    116        public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
    117        /**
    118         * An empty immutable <code>Boolean</code> array.
    119         */
    120        public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0];
    121        /**
    122         * An empty immutable <code>char</code> array.
    123         */
    124        public static final char[] EMPTY_CHAR_ARRAY = new char[0];
    125        /**
    126         * An empty immutable <code>Character</code> array.
    127         */
    128        public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0];
    129
    130        /**
    131         * The index value when an element is not found in a list or array: <code>-1</code>.
    132         * This value is returned by methods in this class and can also be used in comparisons with values returned by
    133         * various method from {@link java.util.List}.
    134         */
    135        public static final int INDEX_NOT_FOUND = -1;
    136
    137        /**
    138         * <p>ArrayUtils instances should NOT be constructed in standard programming.
    139         * Instead, the class should be used as <code>ArrayUtils.clone(new int[] {2})</code>.</p>
    140         *
    141         * <p>This constructor is public to permit tools that require a JavaBean instance
    142         * to operate.</p>
    143         */
    144        public ArrayUtils() {
    145          super();
    146        }
    147
    148        // Basic methods handling multi-dimensional arrays
    149        //-----------------------------------------------------------------------
    150        /**
    151         * <p>Outputs an array as a String, treating <code>null</code> as an empty array.</p>
    152         *
    153         * <p>Multi-dimensional arrays are handled correctly, including
    154         * multi-dimensional primitive arrays.</p>
    155         *
    156         * <p>The format is that of Java source code, for example <code>{a,b}</code>.</p>
    157         *
    158         * @param array  the array to get a toString for, may be <code>null</code>
    159         * @return a String representation of the array, '{}' if null array input
    160         */
    161        public static String toString(Object array) {
    162            return toString(array, "{}");
    163        }
    164
    165        /**
    166         * <p>Outputs an array as a String handling <code>null</code>s.</p>
    167         *
    168         * <p>Multi-dimensional arrays are handled correctly, including
    169         * multi-dimensional primitive arrays.</p>
    170         *
    171         * <p>The format is that of Java source code, for example <code>{a,b}</code>.</p>
    172         *
    173         * @param array  the array to get a toString for, may be <code>null</code>
    174         * @param stringIfNull  the String to return if the array is <code>null</code>
    175         * @return a String representation of the array
    176         */
    177        public static String toString(Object array, String stringIfNull) {
    178            if (array == null) {
    179                return stringIfNull;
    180            }
    181            return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
    182        }
    183
    184        /**
    185         * <p>Get a hashCode for an array handling multi-dimensional arrays correctly.</p>
    186         *
    187         * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p>
    188         *
    189         * @param array  the array to get a hashCode for, may be <code>null</code>
    190         * @return a hashCode for the array, zero if null array input
    191         */
    192        public static int hashCode(Object array) {
    193            return new HashCodeBuilder().append(array).toHashCode();
    194        }
    195
    196        /**
    197         * <p>Compares two arrays, using equals(), handling multi-dimensional arrays
    198         * correctly.</p>
    199         *
    200         * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p>
    201         *
    202         * @param array1  the left hand array to compare, may be <code>null</code>
    203         * @param array2  the right hand array to compare, may be <code>null</code>
    204         * @return <code>true</code> if the arrays are equal
    205         */
    206        public static boolean isEquals(Object array1, Object array2) {
    207            return new EqualsBuilder().append(array1, array2).isEquals();
    208        }
    209
    210        // To map
    211        //-----------------------------------------------------------------------
    212        /**
    213         * <p>Converts the given array into a {@link java.util.Map}. Each element of the array
    214         * must be either a {@link java.util.Map.Entry} or an Array, containing at least two
    215         * elements, where the first element is used as key and the second as
    216         * value.</p>
    217         *
    218         * <p>This method can be used to initialize:</p>
    219         * <pre>
    220         * // Create a Map mapping colors.
    221         * Map colorMap = MapUtils.toMap(new String[][] {{
    222         *     {"RED", "#FF0000"},
    223         *     {"GREEN", "#00FF00"},
    224         *     {"BLUE", "#0000FF"}});
    225         * </pre>
    226         *
    227         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    228         *
    229         * @param array  an array whose elements are either a {@link java.util.Map.Entry} or
    230         *  an Array containing at least two elements, may be <code>null</code>
    231         * @return a <code>Map</code> that was created from the array
    232         * @throws IllegalArgumentException  if one element of this Array is
    233         *  itself an Array containing less then two elements
    234         * @throws IllegalArgumentException  if the array contains elements other
    235         *  than {@link java.util.Map.Entry} and an Array
    236         */
    237        public static Map toMap(Object[] array) {
    238            if (array == null) {
    239                return null;
    240            }
    241            final Map map = new HashMap((int) (array.length * 1.5));
    242            for (int i = 0; i < array.length; i++) {
    243                Object object = array[i];
    244                if (object instanceof Map.Entry) {
    245                    Map.Entry entry = (Map.Entry) object;
    246                    map.put(entry.getKey(), entry.getValue());
    247                } else if (object instanceof Object[]) {
    248                    Object[] entry = (Object[]) object;
    249                    if (entry.length < 2) {
    250                        throw new IllegalArgumentException("Array element " + i + ", '"
    251                            + object
    252                            + "', has a length less than 2");
    253                    }
    254                    map.put(entry[0], entry[1]);
    255                } else {
    256                    throw new IllegalArgumentException("Array element " + i + ", '"
    257                            + object
    258                            + "', is neither of type Map.Entry nor an Array");
    259                }
    260            }
    261            return map;
    262        }
    263
    264        // Clone
    265        //-----------------------------------------------------------------------
    266        /**
    267         * <p>Shallow clones an array returning a typecast result and handling
    268         * <code>null</code>.</p>
    269         *
    270         * <p>The objects in the array are not cloned, thus there is no special
    271         * handling for multi-dimensional arrays.</p>
    272         *
    273         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    274         *
    275         * @param array  the array to shallow clone, may be <code>null</code>
    276         * @return the cloned array, <code>null</code> if <code>null</code> input
    277         */
    278        public static Object[] clone(Object[] array) {
    279            if (array == null) {
    280                return null;
    281            }
    282            return (Object[]) array.clone();
    283        }
    284
    285        /**
    286         * <p>Clones an array returning a typecast result and handling
    287         * <code>null</code>.</p>
    288         *
    289         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    290         *
    291         * @param array  the array to clone, may be <code>null</code>
    292         * @return the cloned array, <code>null</code> if <code>null</code> input
    293         */
    294        public static long[] clone(long[] array) {
    295            if (array == null) {
    296                return null;
    297            }
    298            return (long[]) array.clone();
    299        }
    300
    301        /**
    302         * <p>Clones an array returning a typecast result and handling
    303         * <code>null</code>.</p>
    304         *
    305         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    306         *
    307         * @param array  the array to clone, may be <code>null</code>
    308         * @return the cloned array, <code>null</code> if <code>null</code> input
    309         */
    310        public static int[] clone(int[] array) {
    311            if (array == null) {
    312                return null;
    313            }
    314            return (int[]) array.clone();
    315        }
    316
    317        /**
    318         * <p>Clones an array returning a typecast result and handling
    319         * <code>null</code>.</p>
    320         *
    321         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    322         *
    323         * @param array  the array to clone, may be <code>null</code>
    324         * @return the cloned array, <code>null</code> if <code>null</code> input
    325         */
    326        public static short[] clone(short[] array) {
    327            if (array == null) {
    328                return null;
    329            }
    330            return (short[]) array.clone();
    331        }
    332
    333        /**
    334         * <p>Clones an array returning a typecast result and handling
    335         * <code>null</code>.</p>
    336         *
    337         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    338         *
    339         * @param array  the array to clone, may be <code>null</code>
    340         * @return the cloned array, <code>null</code> if <code>null</code> input
    341         */
    342        public static char[] clone(char[] array) {
    343            if (array == null) {
    344                return null;
    345            }
    346            return (char[]) array.clone();
    347        }
    348
    349        /**
    350         * <p>Clones an array returning a typecast result and handling
    351         * <code>null</code>.</p>
    352         *
    353         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    354         *
    355         * @param array  the array to clone, may be <code>null</code>
    356         * @return the cloned array, <code>null</code> if <code>null</code> input
    357         */
    358        public static byte[] clone(byte[] array) {
    359            if (array == null) {
    360                return null;
    361            }
    362            return (byte[]) array.clone();
    363        }
    364
    365        /**
    366         * <p>Clones an array returning a typecast result and handling
    367         * <code>null</code>.</p>
    368         *
    369         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    370         *
    371         * @param array  the array to clone, may be <code>null</code>
    372         * @return the cloned array, <code>null</code> if <code>null</code> input
    373         */
    374        public static double[] clone(double[] array) {
    375            if (array == null) {
    376                return null;
    377            }
    378            return (double[]) array.clone();
    379        }
    380
    381        /**
    382         * <p>Clones an array returning a typecast result and handling
    383         * <code>null</code>.</p>
    384         *
    385         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    386         *
    387         * @param array  the array to clone, may be <code>null</code>
    388         * @return the cloned array, <code>null</code> if <code>null</code> input
    389         */
    390        public static float[] clone(float[] array) {
    391            if (array == null) {
    392                return null;
    393            }
    394            return (float[]) array.clone();
    395        }
    396
    397        /**
    398         * <p>Clones an array returning a typecast result and handling
    399         * <code>null</code>.</p>
    400         *
    401         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    402         *
    403         * @param array  the array to clone, may be <code>null</code>
    404         * @return the cloned array, <code>null</code> if <code>null</code> input
    405         */
    406        public static boolean[] clone(boolean[] array) {
    407            if (array == null) {
    408                return null;
    409            }
    410            return (boolean[]) array.clone();
    411        }
    412
    413        // nullToEmpty
    414        //-----------------------------------------------------------------------
    415        /**
    416         * <p>Defensive programming technique to change a <code>null</code>
    417         * reference to an empty one.</p>
    418         *
    419         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    420         *
    421         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    422         * the empty <code>public static</code> references in this class.</p>
    423         *
    424         * @param array  the array to check for <code>null</code> or empty
    425         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    426         * @since 2.5
    427         */
    428        public static Object[] nullToEmpty(Object[] array) {
    429            if (array == null || array.length == 0) {
    430                return EMPTY_OBJECT_ARRAY;
    431            }
    432            return array;
    433        }
    434
    435        /**
    436         * <p>Defensive programming technique to change a <code>null</code>
    437         * reference to an empty one.</p>
    438         *
    439         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    440         *
    441         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    442         * the empty <code>public static</code> references in this class.</p>
    443         *
    444         * @param array  the array to check for <code>null</code> or empty
    445         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    446         * @since 2.5
    447         */
    448        public static String[] nullToEmpty(String[] array) {
    449            if (array == null || array.length == 0) {
    450                return EMPTY_STRING_ARRAY;
    451            }
    452            return array;
    453        }
    454
    455        /**
    456         * <p>Defensive programming technique to change a <code>null</code>
    457         * reference to an empty one.</p>
    458         *
    459         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    460         *
    461         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    462         * the empty <code>public static</code> references in this class.</p>
    463         *
    464         * @param array  the array to check for <code>null</code> or empty
    465         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    466         * @since 2.5
    467         */
    468        public static long[] nullToEmpty(long[] array) {
    469            if (array == null || array.length == 0) {
    470                return EMPTY_LONG_ARRAY;
    471            }
    472            return array;
    473        }
    474
    475        /**
    476         * <p>Defensive programming technique to change a <code>null</code>
    477         * reference to an empty one.</p>
    478         *
    479         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    480         *
    481         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    482         * the empty <code>public static</code> references in this class.</p>
    483         *
    484         * @param array  the array to check for <code>null</code> or empty
    485         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    486         * @since 2.5
    487         */
    488        public static int[] nullToEmpty(int[] array) {
    489            if (array == null || array.length == 0) {
    490                return EMPTY_INT_ARRAY;
    491            }
    492            return array;
    493        }
    494
    495        /**
    496         * <p>Defensive programming technique to change a <code>null</code>
    497         * reference to an empty one.</p>
    498         *
    499         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    500         *
    501         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    502         * the empty <code>public static</code> references in this class.</p>
    503         *
    504         * @param array  the array to check for <code>null</code> or empty
    505         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    506         * @since 2.5
    507         */
    508        public static short[] nullToEmpty(short[] array) {
    509            if (array == null || array.length == 0) {
    510                return EMPTY_SHORT_ARRAY;
    511            }
    512            return array;
    513        }
    514
    515        /**
    516         * <p>Defensive programming technique to change a <code>null</code>
    517         * reference to an empty one.</p>
    518         *
    519         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    520         *
    521         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    522         * the empty <code>public static</code> references in this class.</p>
    523         *
    524         * @param array  the array to check for <code>null</code> or empty
    525         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    526         * @since 2.5
    527         */
    528        public static char[] nullToEmpty(char[] array) {
    529            if (array == null || array.length == 0) {
    530                return EMPTY_CHAR_ARRAY;
    531            }
    532            return array;
    533        }
    534
    535        /**
    536         * <p>Defensive programming technique to change a <code>null</code>
    537         * reference to an empty one.</p>
    538         *
    539         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    540         *
    541         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    542         * the empty <code>public static</code> references in this class.</p>
    543         *
    544         * @param array  the array to check for <code>null</code> or empty
    545         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    546         * @since 2.5
    547         */
    548        public static byte[] nullToEmpty(byte[] array) {
    549            if (array == null || array.length == 0) {
    550                return EMPTY_BYTE_ARRAY;
    551            }
    552            return array;
    553        }
    554
    555        /**
    556         * <p>Defensive programming technique to change a <code>null</code>
    557         * reference to an empty one.</p>
    558         *
    559         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    560         *
    561         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    562         * the empty <code>public static</code> references in this class.</p>
    563         *
    564         * @param array  the array to check for <code>null</code> or empty
    565         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    566         * @since 2.5
    567         */
    568        public static double[] nullToEmpty(double[] array) {
    569            if (array == null || array.length == 0) {
    570                return EMPTY_DOUBLE_ARRAY;
    571            }
    572            return array;
    573        }
    574
    575        /**
    576         * <p>Defensive programming technique to change a <code>null</code>
    577         * reference to an empty one.</p>
    578         *
    579         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    580         *
    581         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    582         * the empty <code>public static</code> references in this class.</p>
    583         *
    584         * @param array  the array to check for <code>null</code> or empty
    585         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    586         * @since 2.5
    587         */
    588        public static float[] nullToEmpty(float[] array) {
    589            if (array == null || array.length == 0) {
    590                return EMPTY_FLOAT_ARRAY;
    591            }
    592            return array;
    593        }
    594
    595        /**
    596         * <p>Defensive programming technique to change a <code>null</code>
    597         * reference to an empty one.</p>
    598         *
    599         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    600         *
    601         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    602         * the empty <code>public static</code> references in this class.</p>
    603         *
    604         * @param array  the array to check for <code>null</code> or empty
    605         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    606         * @since 2.5
    607         */
    608        public static boolean[] nullToEmpty(boolean[] array) {
    609            if (array == null || array.length == 0) {
    610                return EMPTY_BOOLEAN_ARRAY;
    611            }
    612            return array;
    613        }
    614
    615        /**
    616         * <p>Defensive programming technique to change a <code>null</code>
    617         * reference to an empty one.</p>
    618         *
    619         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    620         *
    621         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    622         * the empty <code>public static</code> references in this class.</p>
    623         *
    624         * @param array  the array to check for <code>null</code> or empty
    625         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    626         * @since 2.5
    627         */
    628        public static Long[] nullToEmpty(Long[] array) {
    629            if (array == null || array.length == 0) {
    630                return EMPTY_LONG_OBJECT_ARRAY;
    631            }
    632            return array;
    633        }
    634
    635        /**
    636         * <p>Defensive programming technique to change a <code>null</code>
    637         * reference to an empty one.</p>
    638         *
    639         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    640         *
    641         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    642         * the empty <code>public static</code> references in this class.</p>
    643         *
    644         * @param array  the array to check for <code>null</code> or empty
    645         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    646         * @since 2.5
    647         */
    648        public static Integer[] nullToEmpty(Integer[] array) {
    649            if (array == null || array.length == 0) {
    650                return EMPTY_INTEGER_OBJECT_ARRAY;
    651            }
    652            return array;
    653        }
    654
    655        /**
    656         * <p>Defensive programming technique to change a <code>null</code>
    657         * reference to an empty one.</p>
    658         *
    659         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    660         *
    661         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    662         * the empty <code>public static</code> references in this class.</p>
    663         *
    664         * @param array  the array to check for <code>null</code> or empty
    665         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    666         * @since 2.5
    667         */
    668        public static Short[] nullToEmpty(Short[] array) {
    669            if (array == null || array.length == 0) {
    670                return EMPTY_SHORT_OBJECT_ARRAY;
    671            }
    672            return array;
    673        }
    674
    675        /**
    676         * <p>Defensive programming technique to change a <code>null</code>
    677         * reference to an empty one.</p>
    678         *
    679         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    680         *
    681         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    682         * the empty <code>public static</code> references in this class.</p>
    683         *
    684         * @param array  the array to check for <code>null</code> or empty
    685         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    686         * @since 2.5
    687         */
    688        public static Character[] nullToEmpty(Character[] array) {
    689            if (array == null || array.length == 0) {
    690                return EMPTY_CHARACTER_OBJECT_ARRAY;
    691            }
    692            return array;
    693        }
    694
    695        /**
    696         * <p>Defensive programming technique to change a <code>null</code>
    697         * reference to an empty one.</p>
    698         *
    699         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    700         *
    701         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    702         * the empty <code>public static</code> references in this class.</p>
    703         *
    704         * @param array  the array to check for <code>null</code> or empty
    705         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    706         * @since 2.5
    707         */
    708        public static Byte[] nullToEmpty(Byte[] array) {
    709            if (array == null || array.length == 0) {
    710                return EMPTY_BYTE_OBJECT_ARRAY;
    711            }
    712            return array;
    713        }
    714
    715        /**
    716         * <p>Defensive programming technique to change a <code>null</code>
    717         * reference to an empty one.</p>
    718         *
    719         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    720         *
    721         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    722         * the empty <code>public static</code> references in this class.</p>
    723         *
    724         * @param array  the array to check for <code>null</code> or empty
    725         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    726         * @since 2.5
    727         */
    728        public static Double[] nullToEmpty(Double[] array) {
    729            if (array == null || array.length == 0) {
    730                return EMPTY_DOUBLE_OBJECT_ARRAY;
    731            }
    732            return array;
    733        }
    734
    735        /**
    736         * <p>Defensive programming technique to change a <code>null</code>
    737         * reference to an empty one.</p>
    738         *
    739         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    740         *
    741         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    742         * the empty <code>public static</code> references in this class.</p>
    743         *
    744         * @param array  the array to check for <code>null</code> or empty
    745         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    746         * @since 2.5
    747         */
    748        public static Float[] nullToEmpty(Float[] array) {
    749            if (array == null || array.length == 0) {
    750                return EMPTY_FLOAT_OBJECT_ARRAY;
    751            }
    752            return array;
    753        }
    754
    755        /**
    756         * <p>Defensive programming technique to change a <code>null</code>
    757         * reference to an empty one.</p>
    758         *
    759         * <p>This method returns an empty array for a <code>null</code> input array.</p>
    760         *
    761         * <p>As a memory optimizing technique an empty array passed in will be overridden with
    762         * the empty <code>public static</code> references in this class.</p>
    763         *
    764         * @param array  the array to check for <code>null</code> or empty
    765         * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
    766         * @since 2.5
    767         */
    768        public static Boolean[] nullToEmpty(Boolean[] array) {
    769            if (array == null || array.length == 0) {
    770                return EMPTY_BOOLEAN_OBJECT_ARRAY;
    771            }
    772            return array;
    773        }
    774
    775        // Subarrays
    776        //-----------------------------------------------------------------------
    777        /**
    778         * <p>Produces a new array containing the elements between
    779         * the start and end indices.</p>
    780         *
    781         * <p>The start index is inclusive, the end index exclusive.
    782         * Null array input produces null output.</p>
    783         *
    784         * <p>The component type of the subarray is always the same as
    785         * that of the input array. Thus, if the input is an array of type
    786         * <code>Date</code>, the following usage is envisaged:</p>
    787         *
    788         * <pre>
    789         * Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5);
    790         * </pre>
    791         *
    792         * @param array  the array
    793         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    794         *      is promoted to 0, overvalue (&gt;array.length) results
    795         *      in an empty array.
    796         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    797         *      returned subarray. Undervalue (&lt; startIndex) produces
    798         *      empty array, overvalue (&gt;array.length) is demoted to
    799         *      array length.
    800         * @return a new array containing the elements between
    801         *      the start and end indices.
    802         * @since 2.1
    803         */
    804        public static Object[] subarray(Object[] array, int startIndexInclusive, int endIndexExclusive) {
    805            if (array == null) {
    806                return null;
    807            }
    808            if (startIndexInclusive < 0) {
    809                startIndexInclusive = 0;
    810            }
    811            if (endIndexExclusive > array.length) {
    812                endIndexExclusive = array.length;
    813            }
    814            int newSize = endIndexExclusive - startIndexInclusive;
    815            Class type = array.getClass().getComponentType();
    816            if (newSize <= 0) {
    817                return (Object[]) Array.newInstance(type, 0);
    818            }
    819            Object[] subarray = (Object[]) Array.newInstance(type, newSize);
    820            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    821            return subarray;
    822        }
    823
    824        /**
    825         * <p>Produces a new <code>long</code> array containing the elements
    826         * between the start and end indices.</p>
    827         *
    828         * <p>The start index is inclusive, the end index exclusive.
    829         * Null array input produces null output.</p>
    830         *
    831         * @param array  the array
    832         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    833         *      is promoted to 0, overvalue (&gt;array.length) results
    834         *      in an empty array.
    835         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    836         *      returned subarray. Undervalue (&lt; startIndex) produces
    837         *      empty array, overvalue (&gt;array.length) is demoted to
    838         *      array length.
    839         * @return a new array containing the elements between
    840         *      the start and end indices.
    841         * @since 2.1
    842         */
    843        public static long[] subarray(long[] array, int startIndexInclusive, int endIndexExclusive) {
    844            if (array == null) {
    845                return null;
    846            }
    847            if (startIndexInclusive < 0) {
    848                startIndexInclusive = 0;
    849            }
    850            if (endIndexExclusive > array.length) {
    851                endIndexExclusive = array.length;
    852            }
    853            int newSize = endIndexExclusive - startIndexInclusive;
    854            if (newSize <= 0) {
    855                return EMPTY_LONG_ARRAY;
    856            }
    857
    858            long[] subarray = new long[newSize];
    859            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    860            return subarray;
    861        }
    862
    863        /**
    864         * <p>Produces a new <code>int</code> array containing the elements
    865         * between the start and end indices.</p>
    866         *
    867         * <p>The start index is inclusive, the end index exclusive.
    868         * Null array input produces null output.</p>
    869         *
    870         * @param array  the array
    871         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    872         *      is promoted to 0, overvalue (&gt;array.length) results
    873         *      in an empty array.
    874         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    875         *      returned subarray. Undervalue (&lt; startIndex) produces
    876         *      empty array, overvalue (&gt;array.length) is demoted to
    877         *      array length.
    878         * @return a new array containing the elements between
    879         *      the start and end indices.
    880         * @since 2.1
    881         */
    882        public static int[] subarray(int[] array, int startIndexInclusive, int endIndexExclusive) {
    883            if (array == null) {
    884                return null;
    885            }
    886            if (startIndexInclusive < 0) {
    887                startIndexInclusive = 0;
    888            }
    889            if (endIndexExclusive > array.length) {
    890                endIndexExclusive = array.length;
    891            }
    892            int newSize = endIndexExclusive - startIndexInclusive;
    893            if (newSize <= 0) {
    894                return EMPTY_INT_ARRAY;
    895            }
    896
    897            int[] subarray = new int[newSize];
    898            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    899            return subarray;
    900        }
    901
    902        /**
    903         * <p>Produces a new <code>short</code> array containing the elements
    904         * between the start and end indices.</p>
    905         *
    906         * <p>The start index is inclusive, the end index exclusive.
    907         * Null array input produces null output.</p>
    908         *
    909         * @param array  the array
    910         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    911         *      is promoted to 0, overvalue (&gt;array.length) results
    912         *      in an empty array.
    913         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    914         *      returned subarray. Undervalue (&lt; startIndex) produces
    915         *      empty array, overvalue (&gt;array.length) is demoted to
    916         *      array length.
    917         * @return a new array containing the elements between
    918         *      the start and end indices.
    919         * @since 2.1
    920         */
    921        public static short[] subarray(short[] array, int startIndexInclusive, int endIndexExclusive) {
    922            if (array == null) {
    923                return null;
    924            }
    925            if (startIndexInclusive < 0) {
    926                startIndexInclusive = 0;
    927            }
    928            if (endIndexExclusive > array.length) {
    929                endIndexExclusive = array.length;
    930            }
    931            int newSize = endIndexExclusive - startIndexInclusive;
    932            if (newSize <= 0) {
    933                return EMPTY_SHORT_ARRAY;
    934            }
    935
    936            short[] subarray = new short[newSize];
    937            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    938            return subarray;
    939        }
    940
    941        /**
    942         * <p>Produces a new <code>char</code> array containing the elements
    943         * between the start and end indices.</p>
    944         *
    945         * <p>The start index is inclusive, the end index exclusive.
    946         * Null array input produces null output.</p>
    947         *
    948         * @param array  the array
    949         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    950         *      is promoted to 0, overvalue (&gt;array.length) results
    951         *      in an empty array.
    952         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    953         *      returned subarray. Undervalue (&lt; startIndex) produces
    954         *      empty array, overvalue (&gt;array.length) is demoted to
    955         *      array length.
    956         * @return a new array containing the elements between
    957         *      the start and end indices.
    958         * @since 2.1
    959         */
    960        public static char[] subarray(char[] array, int startIndexInclusive, int endIndexExclusive) {
    961            if (array == null) {
    962                return null;
    963            }
    964            if (startIndexInclusive < 0) {
    965                startIndexInclusive = 0;
    966            }
    967            if (endIndexExclusive > array.length) {
    968                endIndexExclusive = array.length;
    969            }
    970            int newSize = endIndexExclusive - startIndexInclusive;
    971            if (newSize <= 0) {
    972                return EMPTY_CHAR_ARRAY;
    973            }
    974
    975            char[] subarray = new char[newSize];
    976            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    977            return subarray;
    978        }
    979
    980        /**
    981         * <p>Produces a new <code>byte</code> array containing the elements
    982         * between the start and end indices.</p>
    983         *
    984         * <p>The start index is inclusive, the end index exclusive.
    985         * Null array input produces null output.</p>
    986         *
    987         * @param array  the array
    988         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    989         *      is promoted to 0, overvalue (&gt;array.length) results
    990         *      in an empty array.
    991         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    992         *      returned subarray. Undervalue (&lt; startIndex) produces
    993         *      empty array, overvalue (&gt;array.length) is demoted to
    994         *      array length.
    995         * @return a new array containing the elements between
    996         *      the start and end indices.
    997         * @since 2.1
    998         */
    999        public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
    1000            if (array == null) {
    1001                return null;
    1002            }
    1003            if (startIndexInclusive < 0) {
    1004                startIndexInclusive = 0;
    1005            }
    1006            if (endIndexExclusive > array.length) {
    1007                endIndexExclusive = array.length;
    1008            }
    1009            int newSize = endIndexExclusive - startIndexInclusive;
    1010            if (newSize <= 0) {
    1011                return EMPTY_BYTE_ARRAY;
    1012            }
    1013
    1014            byte[] subarray = new byte[newSize];
    1015            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    1016            return subarray;
    1017        }
    1018
    1019        /**
    1020         * <p>Produces a new <code>double</code> array containing the elements
    1021         * between the start and end indices.</p>
    1022         *
    1023         * <p>The start index is inclusive, the end index exclusive.
    1024         * Null array input produces null output.</p>
    1025         *
    1026         * @param array  the array
    1027         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    1028         *      is promoted to 0, overvalue (&gt;array.length) results
    1029         *      in an empty array.
    1030         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    1031         *      returned subarray. Undervalue (&lt; startIndex) produces
    1032         *      empty array, overvalue (&gt;array.length) is demoted to
    1033         *      array length.
    1034         * @return a new array containing the elements between
    1035         *      the start and end indices.
    1036         * @since 2.1
    1037         */
    1038        public static double[] subarray(double[] array, int startIndexInclusive, int endIndexExclusive) {
    1039            if (array == null) {
    1040                return null;
    1041            }
    1042            if (startIndexInclusive < 0) {
    1043                startIndexInclusive = 0;
    1044            }
    1045            if (endIndexExclusive > array.length) {
    1046                endIndexExclusive = array.length;
    1047            }
    1048            int newSize = endIndexExclusive - startIndexInclusive;
    1049            if (newSize <= 0) {
    1050                return EMPTY_DOUBLE_ARRAY;
    1051            }
    1052
    1053            double[] subarray = new double[newSize];
    1054            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    1055            return subarray;
    1056        }
    1057
    1058        /**
    1059         * <p>Produces a new <code>float</code> array containing the elements
    1060         * between the start and end indices.</p>
    1061         *
    1062         * <p>The start index is inclusive, the end index exclusive.
    1063         * Null array input produces null output.</p>
    1064         *
    1065         * @param array  the array
    1066         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    1067         *      is promoted to 0, overvalue (&gt;array.length) results
    1068         *      in an empty array.
    1069         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    1070         *      returned subarray. Undervalue (&lt; startIndex) produces
    1071         *      empty array, overvalue (&gt;array.length) is demoted to
    1072         *      array length.
    1073         * @return a new array containing the elements between
    1074         *      the start and end indices.
    1075         * @since 2.1
    1076         */
    1077        public static float[] subarray(float[] array, int startIndexInclusive, int endIndexExclusive) {
    1078            if (array == null) {
    1079                return null;
    1080            }
    1081            if (startIndexInclusive < 0) {
    1082                startIndexInclusive = 0;
    1083            }
    1084            if (endIndexExclusive > array.length) {
    1085                endIndexExclusive = array.length;
    1086            }
    1087            int newSize = endIndexExclusive - startIndexInclusive;
    1088            if (newSize <= 0) {
    1089                return EMPTY_FLOAT_ARRAY;
    1090            }
    1091
    1092            float[] subarray = new float[newSize];
    1093            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    1094            return subarray;
    1095        }
    1096
    1097        /**
    1098         * <p>Produces a new <code>boolean</code> array containing the elements
    1099         * between the start and end indices.</p>
    1100         *
    1101         * <p>The start index is inclusive, the end index exclusive.
    1102         * Null array input produces null output.</p>
    1103         *
    1104         * @param array  the array
    1105         * @param startIndexInclusive  the starting index. Undervalue (&lt;0)
    1106         *      is promoted to 0, overvalue (&gt;array.length) results
    1107         *      in an empty array.
    1108         * @param endIndexExclusive  elements up to endIndex-1 are present in the
    1109         *      returned subarray. Undervalue (&lt; startIndex) produces
    1110         *      empty array, overvalue (&gt;array.length) is demoted to
    1111         *      array length.
    1112         * @return a new array containing the elements between
    1113         *      the start and end indices.
    1114         * @since 2.1
    1115         */
    1116        public static boolean[] subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive) {
    1117            if (array == null) {
    1118                return null;
    1119            }
    1120            if (startIndexInclusive < 0) {
    1121                startIndexInclusive = 0;
    1122            }
    1123            if (endIndexExclusive > array.length) {
    1124                endIndexExclusive = array.length;
    1125            }
    1126            int newSize = endIndexExclusive - startIndexInclusive;
    1127            if (newSize <= 0) {
    1128                return EMPTY_BOOLEAN_ARRAY;
    1129            }
    1130
    1131            boolean[] subarray = new boolean[newSize];
    1132            System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
    1133            return subarray;
    1134        }
    1135
    1136        // Is same length
    1137        //-----------------------------------------------------------------------
    1138        /**
    1139         * <p>Checks whether two arrays are the same length, treating
    1140         * <code>null</code> arrays as length <code>0</code>.
    1141         *
    1142         * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
    1143         *
    1144         * @param array1 the first array, may be <code>null</code>
    1145         * @param array2 the second array, may be <code>null</code>
    1146         * @return <code>true</code> if length of arrays matches, treating
    1147         *  <code>null</code> as an empty array
    1148         */
    1149        public static boolean isSameLength(Object[] array1, Object[] array2) {
    1150            if ((array1 == null && array2 != null && array2.length > 0) ||
    1151                (array2 == null && array1 != null && array1.length > 0) ||
    1152                (array1 != null && array2 != null && array1.length != array2.length)) {
    1153                    return false;
    1154            }
    1155            return true;
    1156        }
    1157
    1158        /**
    1159         * <p>Checks whether two arrays are the same length, treating
    1160         * <code>null</code> arrays as length <code>0</code>.</p>
    1161         *
    1162         * @param array1 the first array, may be <code>null</code>
    1163         * @param array2 the second array, may be <code>null</code>
    1164         * @return <code>true</code> if length of arrays matches, treating
    1165         *  <code>null</code> as an empty array
    1166         */
    1167        public static boolean isSameLength(long[] array1, long[] array2) {
    1168            if ((array1 == null && array2 != null && array2.length > 0) ||
    1169                (array2 == null && array1 != null && array1.length > 0) ||
    1170                (array1 != null && array2 != null && array1.length != array2.length)) {
    1171                    return false;
    1172            }
    1173            return true;
    1174        }
    1175
    1176        /**
    1177         * <p>Checks whether two arrays are the same length, treating
    1178         * <code>null</code> arrays as length <code>0</code>.</p>
    1179         *
    1180         * @param array1 the first array, may be <code>null</code>
    1181         * @param array2 the second array, may be <code>null</code>
    1182         * @return <code>true</code> if length of arrays matches, treating
    1183         *  <code>null</code> as an empty array
    1184         */
    1185        public static boolean isSameLength(int[] array1, int[] array2) {
    1186            if ((array1 == null && array2 != null && array2.length > 0) ||
    1187                (array2 == null && array1 != null && array1.length > 0) ||
    1188                (array1 != null && array2 != null && array1.length != array2.length)) {
    1189                    return false;
    1190            }
    1191            return true;
    1192        }
    1193
    1194        /**
    1195         * <p>Checks whether two arrays are the same length, treating
    1196         * <code>null</code> arrays as length <code>0</code>.</p>
    1197         *
    1198         * @param array1 the first array, may be <code>null</code>
    1199         * @param array2 the second array, may be <code>null</code>
    1200         * @return <code>true</code> if length of arrays matches, treating
    1201         *  <code>null</code> as an empty array
    1202         */
    1203        public static boolean isSameLength(short[] array1, short[] array2) {
    1204            if ((array1 == null && array2 != null && array2.length > 0) ||
    1205                (array2 == null && array1 != null && array1.length > 0) ||
    1206                (array1 != null && array2 != null && array1.length != array2.length)) {
    1207                    return false;
    1208            }
    1209            return true;
    1210        }
    1211
    1212        /**
    1213         * <p>Checks whether two arrays are the same length, treating
    1214         * <code>null</code> arrays as length <code>0</code>.</p>
    1215         *
    1216         * @param array1 the first array, may be <code>null</code>
    1217         * @param array2 the second array, may be <code>null</code>
    1218         * @return <code>true</code> if length of arrays matches, treating
    1219         *  <code>null</code> as an empty array
    1220         */
    1221        public static boolean isSameLength(char[] array1, char[] array2) {
    1222            if ((array1 == null && array2 != null && array2.length > 0) ||
    1223                (array2 == null && array1 != null && array1.length > 0) ||
    1224                (array1 != null && array2 != null && array1.length != array2.length)) {
    1225                    return false;
    1226            }
    1227            return true;
    1228        }
    1229
    1230        /**
    1231         * <p>Checks whether two arrays are the same length, treating
    1232         * <code>null</code> arrays as length <code>0</code>.</p>
    1233         *
    1234         * @param array1 the first array, may be <code>null</code>
    1235         * @param array2 the second array, may be <code>null</code>
    1236         * @return <code>true</code> if length of arrays matches, treating
    1237         *  <code>null</code> as an empty array
    1238         */
    1239        public static boolean isSameLength(byte[] array1, byte[] array2) {
    1240            if ((array1 == null && array2 != null && array2.length > 0) ||
    1241                (array2 == null && array1 != null && array1.length > 0) ||
    1242                (array1 != null && array2 != null && array1.length != array2.length)) {
    1243                    return false;
    1244            }
    1245            return true;
    1246        }
    1247
    1248        /**
    1249         * <p>Checks whether two arrays are the same length, treating
    1250         * <code>null</code> arrays as length <code>0</code>.</p>
    1251         *
    1252         * @param array1 the first array, may be <code>null</code>
    1253         * @param array2 the second array, may be <code>null</code>
    1254         * @return <code>true</code> if length of arrays matches, treating
    1255         *  <code>null</code> as an empty array
    1256         */
    1257        public static boolean isSameLength(double[] array1, double[] array2) {
    1258            if ((array1 == null && array2 != null && array2.length > 0) ||
    1259                (array2 == null && array1 != null && array1.length > 0) ||
    1260                (array1 != null && array2 != null && array1.length != array2.length)) {
    1261                    return false;
    1262            }
    1263            return true;
    1264        }
    1265
    1266        /**
    1267         * <p>Checks whether two arrays are the same length, treating
    1268         * <code>null</code> arrays as length <code>0</code>.</p>
    1269         *
    1270         * @param array1 the first array, may be <code>null</code>
    1271         * @param array2 the second array, may be <code>null</code>
    1272         * @return <code>true</code> if length of arrays matches, treating
    1273         *  <code>null</code> as an empty array
    1274         */
    1275        public static boolean isSameLength(float[] array1, float[] array2) {
    1276            if ((array1 == null && array2 != null && array2.length > 0) ||
    1277                (array2 == null && array1 != null && array1.length > 0) ||
    1278                (array1 != null && array2 != null && array1.length != array2.length)) {
    1279                    return false;
    1280            }
    1281            return true;
    1282        }
    1283
    1284        /**
    1285         * <p>Checks whether two arrays are the same length, treating
    1286         * <code>null</code> arrays as length <code>0</code>.</p>
    1287         *
    1288         * @param array1 the first array, may be <code>null</code>
    1289         * @param array2 the second array, may be <code>null</code>
    1290         * @return <code>true</code> if length of arrays matches, treating
    1291         *  <code>null</code> as an empty array
    1292         */
    1293        public static boolean isSameLength(boolean[] array1, boolean[] array2) {
    1294            if ((array1 == null && array2 != null && array2.length > 0) ||
    1295                (array2 == null && array1 != null && array1.length > 0) ||
    1296                (array1 != null && array2 != null && array1.length != array2.length)) {
    1297                    return false;
    1298            }
    1299            return true;
    1300        }
    1301
    1302        //-----------------------------------------------------------------------
    1303        /**
    1304         * <p>Returns the length of the specified array.
    1305         * This method can deal with <code>Object</code> arrays and with primitive arrays.</p>
    1306         *
    1307         * <p>If the input array is <code>null</code>, <code>0</code> is returned.</p>
    1308         *
    1309         * <pre>
    1310         * ArrayUtils.getLength(null)            = 0
    1311         * ArrayUtils.getLength([])              = 0
    1312         * ArrayUtils.getLength([null])          = 1
    1313         * ArrayUtils.getLength([true, false])   = 2
    1314         * ArrayUtils.getLength([1, 2, 3])       = 3
    1315         * ArrayUtils.getLength(["a", "b", "c"]) = 3
    1316         * </pre>
    1317         *
    1318         * @param array  the array to retrieve the length from, may be null
    1319         * @return The length of the array, or <code>0</code> if the array is <code>null</code>
    1320         * @throws IllegalArgumentException if the object arguement is not an array.
    1321         * @since 2.1
    1322         */
    1323        public static int getLength(Object array) {
    1324            if (array == null) {
    1325                return 0;
    1326            }
    1327            return Array.getLength(array);
    1328        }
    1329
    1330        /**
    1331         * <p>Checks whether two arrays are the same type taking into account
    1332         * multi-dimensional arrays.</p>
    1333         *
    1334         * @param array1 the first array, must not be <code>null</code>
    1335         * @param array2 the second array, must not be <code>null</code>
    1336         * @return <code>true</code> if type of arrays matches
    1337         * @throws IllegalArgumentException if either array is <code>null</code>
    1338         */
    1339        public static boolean isSameType(Object array1, Object array2) {
    1340            if (array1 == null || array2 == null) {
    1341                throw new IllegalArgumentException("The Array must not be null");
    1342            }
    1343            return array1.getClass().getName().equals(array2.getClass().getName());
    1344        }
    1345
    1346        // Reverse
    1347        //-----------------------------------------------------------------------
    1348        /**
    1349         * <p>Reverses the order of the given array.</p>
    1350         *
    1351         * <p>There is no special handling for multi-dimensional arrays.</p>
    1352         *
    1353         * <p>This method does nothing for a <code>null</code> input array.</p>
    1354         *
    1355         * @param array  the array to reverse, may be <code>null</code>
    1356         */
    1357        public static void reverse(Object[] array) {
    1358            if (array == null) {
    1359                return;
    1360            }
    1361            int i = 0;
    1362            int j = array.length - 1;
    1363            Object tmp;
    1364            while (j > i) {
    1365                tmp = array[j];
    1366                array[j] = array[i];
    1367                array[i] = tmp;
    1368                j--;
    1369                i++;
    1370            }
    1371        }
    1372
    1373        /**
    1374         * <p>Reverses the order of the given array.</p>
    1375         *
    1376         * <p>This method does nothing for a <code>null</code> input array.</p>
    1377         *
    1378         * @param array  the array to reverse, may be <code>null</code>
    1379         */
    1380        public static void reverse(long[] array) {
    1381            if (array == null) {
    1382                return;
    1383            }
    1384            int i = 0;
    1385            int j = array.length - 1;
    1386            long tmp;
    1387            while (j > i) {
    1388                tmp = array[j];
    1389                array[j] = array[i];
    1390                array[i] = tmp;
    1391                j--;
    1392                i++;
    1393            }
    1394        }
    1395
    1396        /**
    1397         * <p>Reverses the order of the given array.</p>
    1398         *
    1399         * <p>This method does nothing for a <code>null</code> input array.</p>
    1400         *
    1401         * @param array  the array to reverse, may be <code>null</code>
    1402         */
    1403        public static void reverse(int[] array) {
    1404            if (array == null) {
    1405                return;
    1406            }
    1407            int i = 0;
    1408            int j = array.length - 1;
    1409            int tmp;
    1410            while (j > i) {
    1411                tmp = array[j];
    1412                array[j] = array[i];
    1413                array[i] = tmp;
    1414                j--;
    1415                i++;
    1416            }
    1417        }
    1418
    1419        /**
    1420         * <p>Reverses the order of the given array.</p>
    1421         *
    1422         * <p>This method does nothing for a <code>null</code> input array.</p>
    1423         *
    1424         * @param array  the array to reverse, may be <code>null</code>
    1425         */
    1426        public static void reverse(short[] array) {
    1427            if (array == null) {
    1428                return;
    1429            }
    1430            int i = 0;
    1431            int j = array.length - 1;
    1432            short tmp;
    1433            while (j > i) {
    1434                tmp = array[j];
    1435                array[j] = array[i];
    1436                array[i] = tmp;
    1437                j--;
    1438                i++;
    1439            }
    1440        }
    1441
    1442        /**
    1443         * <p>Reverses the order of the given array.</p>
    1444         *
    1445         * <p>This method does nothing for a <code>null</code> input array.</p>
    1446         *
    1447         * @param array  the array to reverse, may be <code>null</code>
    1448         */
    1449        public static void reverse(char[] array) {
    1450            if (array == null) {
    1451                return;
    1452            }
    1453            int i = 0;
    1454            int j = array.length - 1;
    1455            char tmp;
    1456            while (j > i) {
    1457                tmp = array[j];
    1458                array[j] = array[i];
    1459                array[i] = tmp;
    1460                j--;
    1461                i++;
    1462            }
    1463        }
    1464
    1465        /**
    1466         * <p>Reverses the order of the given array.</p>
    1467         *
    1468         * <p>This method does nothing for a <code>null</code> input array.</p>
    1469         *
    1470         * @param array  the array to reverse, may be <code>null</code>
    1471         */
    1472        public static void reverse(byte[] array) {
    1473            if (array == null) {
    1474                return;
    1475            }
    1476            int i = 0;
    1477            int j = array.length - 1;
    1478            byte tmp;
    1479            while (j > i) {
    1480                tmp = array[j];
    1481                array[j] = array[i];
    1482                array[i] = tmp;
    1483                j--;
    1484                i++;
    1485            }
    1486        }
    1487
    1488        /**
    1489         * <p>Reverses the order of the given array.</p>
    1490         *
    1491         * <p>This method does nothing for a <code>null</code> input array.</p>
    1492         *
    1493         * @param array  the array to reverse, may be <code>null</code>
    1494         */
    1495        public static void reverse(double[] array) {
    1496            if (array == null) {
    1497                return;
    1498            }
    1499            int i = 0;
    1500            int j = array.length - 1;
    1501            double tmp;
    1502            while (j > i) {
    1503                tmp = array[j];
    1504                array[j] = array[i];
    1505                array[i] = tmp;
    1506                j--;
    1507                i++;
    1508            }
    1509        }
    1510
    1511        /**
    1512         * <p>Reverses the order of the given array.</p>
    1513         *
    1514         * <p>This method does nothing for a <code>null</code> input array.</p>
    1515         *
    1516         * @param array  the array to reverse, may be <code>null</code>
    1517         */
    1518        public static void reverse(float[] array) {
    1519            if (array == null) {
    1520                return;
    1521            }
    1522            int i = 0;
    1523            int j = array.length - 1;
    1524            float tmp;
    1525            while (j > i) {
    1526                tmp = array[j];
    1527                array[j] = array[i];
    1528                array[i] = tmp;
    1529                j--;
    1530                i++;
    1531            }
    1532        }
    1533
    1534        /**
    1535         * <p>Reverses the order of the given array.</p>
    1536         *
    1537         * <p>This method does nothing for a <code>null</code> input array.</p>
    1538         *
    1539         * @param array  the array to reverse, may be <code>null</code>
    1540         */
    1541        public static void reverse(boolean[] array) {
    1542            if (array == null) {
    1543                return;
    1544            }
    1545            int i = 0;
    1546            int j = array.length - 1;
    1547            boolean tmp;
    1548            while (j > i) {
    1549                tmp = array[j];
    1550                array[j] = array[i];
    1551                array[i] = tmp;
    1552                j--;
    1553                i++;
    1554            }
    1555        }
    1556
    1557        // IndexOf search
    1558        // ----------------------------------------------------------------------
    1559
    1560        // Object IndexOf
    1561        //-----------------------------------------------------------------------
    1562        /**
    1563         * <p>Finds the index of the given object in the array.</p>
    1564         *
    1565         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1566         *
    1567         * @param array  the array to search through for the object, may be <code>null</code>
    1568         * @param objectToFind  the object to find, may be <code>null</code>
    1569         * @return the index of the object within the array,
    1570         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1571         */
    1572        public static int indexOf(Object[] array, Object objectToFind) {
    1573            return indexOf(array, objectToFind, 0);
    1574        }
    1575
    1576        /**
    1577         * <p>Finds the index of the given object in the array starting at the given index.</p>
    1578         *
    1579         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1580         *
    1581         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    1582         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    1583         *
    1584         * @param array  the array to search through for the object, may be <code>null</code>
    1585         * @param objectToFind  the object to find, may be <code>null</code>
    1586         * @param startIndex  the index to start searching at
    1587         * @return the index of the object within the array starting at the index,
    1588         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1589         */
    1590        public static int indexOf(Object[] array, Object objectToFind, int startIndex) {
    1591            if (array == null) {
    1592                return INDEX_NOT_FOUND;
    1593            }
    1594            if (startIndex < 0) {
    1595                startIndex = 0;
    1596            }
    1597            if (objectToFind == null) {
    1598                for (int i = startIndex; i < array.length; i++) {
    1599                    if (array[i] == null) {
    1600                        return i;
    1601                    }
    1602                }
    1603            } else if (array.getClass().getComponentType().isInstance(objectToFind)) {
    1604                for (int i = startIndex; i < array.length; i++) {
    1605                    if (objectToFind.equals(array[i])) {
    1606                        return i;
    1607                    }
    1608                }
    1609            }
    1610            return INDEX_NOT_FOUND;
    1611        }
    1612
    1613        /**
    1614         * <p>Finds the last index of the given object within the array.</p>
    1615         *
    1616         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1617         *
    1618         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    1619         * @param objectToFind  the object to find, may be <code>null</code>
    1620         * @return the last index of the object within the array,
    1621         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1622         */
    1623        public static int lastIndexOf(Object[] array, Object objectToFind) {
    1624            return lastIndexOf(array, objectToFind, Integer.MAX_VALUE);
    1625        }
    1626
    1627        /**
    1628         * <p>Finds the last index of the given object in the array starting at the given index.</p>
    1629         *
    1630         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1631         *
    1632         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than
    1633         * the array length will search from the end of the array.</p>
    1634         *
    1635         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    1636         * @param objectToFind  the object to find, may be <code>null</code>
    1637         * @param startIndex  the start index to travers backwards from
    1638         * @return the last index of the object within the array,
    1639         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1640         */
    1641        public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) {
    1642            if (array == null) {
    1643                return INDEX_NOT_FOUND;
    1644            }
    1645            if (startIndex < 0) {
    1646                return INDEX_NOT_FOUND;
    1647            } else if (startIndex >= array.length) {
    1648                startIndex = array.length - 1;
    1649            }
    1650            if (objectToFind == null) {
    1651                for (int i = startIndex; i >= 0; i--) {
    1652                    if (array[i] == null) {
    1653                        return i;
    1654                    }
    1655                }
    1656            } else if (array.getClass().getComponentType().isInstance(objectToFind)) {
    1657                for (int i = startIndex; i >= 0; i--) {
    1658                    if (objectToFind.equals(array[i])) {
    1659                        return i;
    1660                    }
    1661                }
    1662            }
    1663            return INDEX_NOT_FOUND;
    1664        }
    1665
    1666        /**
    1667         * <p>Checks if the object is in the given array.</p>
    1668         *
    1669         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    1670         *
    1671         * @param array  the array to search through
    1672         * @param objectToFind  the object to find
    1673         * @return <code>true</code> if the array contains the object
    1674         */
    1675        public static boolean contains(Object[] array, Object objectToFind) {
    1676            return indexOf(array, objectToFind) != INDEX_NOT_FOUND;
    1677        }
    1678
    1679        // long IndexOf
    1680        //-----------------------------------------------------------------------
    1681        /**
    1682         * <p>Finds the index of the given value in the array.</p>
    1683         *
    1684         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1685         *
    1686         * @param array  the array to search through for the object, may be <code>null</code>
    1687         * @param valueToFind  the value to find
    1688         * @return the index of the value within the array,
    1689         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1690         */
    1691        public static int indexOf(long[] array, long valueToFind) {
    1692            return indexOf(array, valueToFind, 0);
    1693        }
    1694
    1695        /**
    1696         * <p>Finds the index of the given value in the array starting at the given index.</p>
    1697         *
    1698         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1699         *
    1700         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    1701         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    1702         *
    1703         * @param array  the array to search through for the object, may be <code>null</code>
    1704         * @param valueToFind  the value to find
    1705         * @param startIndex  the index to start searching at
    1706         * @return the index of the value within the array,
    1707         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1708         */
    1709        public static int indexOf(long[] array, long valueToFind, int startIndex) {
    1710            if (array == null) {
    1711                return INDEX_NOT_FOUND;
    1712            }
    1713            if (startIndex < 0) {
    1714                startIndex = 0;
    1715            }
    1716            for (int i = startIndex; i < array.length; i++) {
    1717                if (valueToFind == array[i]) {
    1718                    return i;
    1719                }
    1720            }
    1721            return INDEX_NOT_FOUND;
    1722        }
    1723
    1724        /**
    1725         * <p>Finds the last index of the given value within the array.</p>
    1726         *
    1727         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1728         *
    1729         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    1730         * @param valueToFind  the object to find
    1731         * @return the last index of the value within the array,
    1732         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1733         */
    1734        public static int lastIndexOf(long[] array, long valueToFind) {
    1735            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    1736        }
    1737
    1738        /**
    1739         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    1740         *
    1741         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1742         *
    1743         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    1744         * array length will search from the end of the array.</p>
    1745         *
    1746         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    1747         * @param valueToFind  the value to find
    1748         * @param startIndex  the start index to travers backwards from
    1749         * @return the last index of the value within the array,
    1750         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1751         */
    1752        public static int lastIndexOf(long[] array, long valueToFind, int startIndex) {
    1753            if (array == null) {
    1754                return INDEX_NOT_FOUND;
    1755            }
    1756            if (startIndex < 0) {
    1757                return INDEX_NOT_FOUND;
    1758            } else if (startIndex >= array.length) {
    1759                startIndex = array.length - 1;
    1760            }
    1761            for (int i = startIndex; i >= 0; i--) {
    1762                if (valueToFind == array[i]) {
    1763                    return i;
    1764                }
    1765            }
    1766            return INDEX_NOT_FOUND;
    1767        }
    1768
    1769        /**
    1770         * <p>Checks if the value is in the given array.</p>
    1771         *
    1772         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    1773         *
    1774         * @param array  the array to search through
    1775         * @param valueToFind  the value to find
    1776         * @return <code>true</code> if the array contains the object
    1777         */
    1778        public static boolean contains(long[] array, long valueToFind) {
    1779            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    1780        }
    1781
    1782        // int IndexOf
    1783        //-----------------------------------------------------------------------
    1784        /**
    1785         * <p>Finds the index of the given value in the array.</p>
    1786         *
    1787         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1788         *
    1789         * @param array  the array to search through for the object, may be <code>null</code>
    1790         * @param valueToFind  the value to find
    1791         * @return the index of the value within the array,
    1792         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1793         */
    1794        public static int indexOf(int[] array, int valueToFind) {
    1795            return indexOf(array, valueToFind, 0);
    1796        }
    1797
    1798        /**
    1799         * <p>Finds the index of the given value in the array starting at the given index.</p>
    1800         *
    1801         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1802         *
    1803         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    1804         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    1805         *
    1806         * @param array  the array to search through for the object, may be <code>null</code>
    1807         * @param valueToFind  the value to find
    1808         * @param startIndex  the index to start searching at
    1809         * @return the index of the value within the array,
    1810         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1811         */
    1812        public static int indexOf(int[] array, int valueToFind, int startIndex) {
    1813            if (array == null) {
    1814                return INDEX_NOT_FOUND;
    1815            }
    1816            if (startIndex < 0) {
    1817                startIndex = 0;
    1818            }
    1819            for (int i = startIndex; i < array.length; i++) {
    1820                if (valueToFind == array[i]) {
    1821                    return i;
    1822                }
    1823            }
    1824            return INDEX_NOT_FOUND;
    1825        }
    1826
    1827        /**
    1828         * <p>Finds the last index of the given value within the array.</p>
    1829         *
    1830         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1831         *
    1832         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    1833         * @param valueToFind  the object to find
    1834         * @return the last index of the value within the array,
    1835         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1836         */
    1837        public static int lastIndexOf(int[] array, int valueToFind) {
    1838            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    1839        }
    1840
    1841        /**
    1842         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    1843         *
    1844         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1845         *
    1846         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    1847         * array length will search from the end of the array.</p>
    1848         *
    1849         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    1850         * @param valueToFind  the value to find
    1851         * @param startIndex  the start index to travers backwards from
    1852         * @return the last index of the value within the array,
    1853         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1854         */
    1855        public static int lastIndexOf(int[] array, int valueToFind, int startIndex) {
    1856            if (array == null) {
    1857                return INDEX_NOT_FOUND;
    1858            }
    1859            if (startIndex < 0) {
    1860                return INDEX_NOT_FOUND;
    1861            } else if (startIndex >= array.length) {
    1862                startIndex = array.length - 1;
    1863            }
    1864            for (int i = startIndex; i >= 0; i--) {
    1865                if (valueToFind == array[i]) {
    1866                    return i;
    1867                }
    1868            }
    1869            return INDEX_NOT_FOUND;
    1870        }
    1871
    1872        /**
    1873         * <p>Checks if the value is in the given array.</p>
    1874         *
    1875         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    1876         *
    1877         * @param array  the array to search through
    1878         * @param valueToFind  the value to find
    1879         * @return <code>true</code> if the array contains the object
    1880         */
    1881        public static boolean contains(int[] array, int valueToFind) {
    1882            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    1883        }
    1884
    1885        // short IndexOf
    1886        //-----------------------------------------------------------------------
    1887        /**
    1888         * <p>Finds the index of the given value in the array.</p>
    1889         *
    1890         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1891         *
    1892         * @param array  the array to search through for the object, may be <code>null</code>
    1893         * @param valueToFind  the value to find
    1894         * @return the index of the value within the array,
    1895         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1896         */
    1897        public static int indexOf(short[] array, short valueToFind) {
    1898            return indexOf(array, valueToFind, 0);
    1899        }
    1900
    1901        /**
    1902         * <p>Finds the index of the given value in the array starting at the given index.</p>
    1903         *
    1904         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1905         *
    1906         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    1907         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    1908         *
    1909         * @param array  the array to search through for the object, may be <code>null</code>
    1910         * @param valueToFind  the value to find
    1911         * @param startIndex  the index to start searching at
    1912         * @return the index of the value within the array,
    1913         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1914         */
    1915        public static int indexOf(short[] array, short valueToFind, int startIndex) {
    1916            if (array == null) {
    1917                return INDEX_NOT_FOUND;
    1918            }
    1919            if (startIndex < 0) {
    1920                startIndex = 0;
    1921            }
    1922            for (int i = startIndex; i < array.length; i++) {
    1923                if (valueToFind == array[i]) {
    1924                    return i;
    1925                }
    1926            }
    1927            return INDEX_NOT_FOUND;
    1928        }
    1929
    1930        /**
    1931         * <p>Finds the last index of the given value within the array.</p>
    1932         *
    1933         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1934         *
    1935         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    1936         * @param valueToFind  the object to find
    1937         * @return the last index of the value within the array,
    1938         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1939         */
    1940        public static int lastIndexOf(short[] array, short valueToFind) {
    1941            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    1942        }
    1943
    1944        /**
    1945         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    1946         *
    1947         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1948         *
    1949         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    1950         * array length will search from the end of the array.</p>
    1951         *
    1952         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    1953         * @param valueToFind  the value to find
    1954         * @param startIndex  the start index to travers backwards from
    1955         * @return the last index of the value within the array,
    1956         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1957         */
    1958        public static int lastIndexOf(short[] array, short valueToFind, int startIndex) {
    1959            if (array == null) {
    1960                return INDEX_NOT_FOUND;
    1961            }
    1962            if (startIndex < 0) {
    1963                return INDEX_NOT_FOUND;
    1964            } else if (startIndex >= array.length) {
    1965                startIndex = array.length - 1;
    1966            }
    1967            for (int i = startIndex; i >= 0; i--) {
    1968                if (valueToFind == array[i]) {
    1969                    return i;
    1970                }
    1971            }
    1972            return INDEX_NOT_FOUND;
    1973        }
    1974
    1975        /**
    1976         * <p>Checks if the value is in the given array.</p>
    1977         *
    1978         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    1979         *
    1980         * @param array  the array to search through
    1981         * @param valueToFind  the value to find
    1982         * @return <code>true</code> if the array contains the object
    1983         */
    1984        public static boolean contains(short[] array, short valueToFind) {
    1985            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    1986        }
    1987
    1988        // char IndexOf
    1989        //-----------------------------------------------------------------------
    1990        /**
    1991         * <p>Finds the index of the given value in the array.</p>
    1992         *
    1993         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    1994         *
    1995         * @param array  the array to search through for the object, may be <code>null</code>
    1996         * @param valueToFind  the value to find
    1997         * @return the index of the value within the array,
    1998         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    1999         * @since 2.1
    2000         */
    2001        public static int indexOf(char[] array, char valueToFind) {
    2002            return indexOf(array, valueToFind, 0);
    2003        }
    2004
    2005        /**
    2006         * <p>Finds the index of the given value in the array starting at the given index.</p>
    2007         *
    2008         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2009         *
    2010         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    2011         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    2012         *
    2013         * @param array  the array to search through for the object, may be <code>null</code>
    2014         * @param valueToFind  the value to find
    2015         * @param startIndex  the index to start searching at
    2016         * @return the index of the value within the array,
    2017         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2018         * @since 2.1
    2019         */
    2020        public static int indexOf(char[] array, char valueToFind, int startIndex) {
    2021            if (array == null) {
    2022                return INDEX_NOT_FOUND;
    2023            }
    2024            if (startIndex < 0) {
    2025                startIndex = 0;
    2026            }
    2027            for (int i = startIndex; i < array.length; i++) {
    2028                if (valueToFind == array[i]) {
    2029                    return i;
    2030                }
    2031            }
    2032            return INDEX_NOT_FOUND;
    2033        }
    2034
    2035        /**
    2036         * <p>Finds the last index of the given value within the array.</p>
    2037         *
    2038         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2039         *
    2040         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    2041         * @param valueToFind  the object to find
    2042         * @return the last index of the value within the array,
    2043         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2044         * @since 2.1
    2045         */
    2046        public static int lastIndexOf(char[] array, char valueToFind) {
    2047            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    2048        }
    2049
    2050        /**
    2051         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    2052         *
    2053         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2054         *
    2055         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    2056         * array length will search from the end of the array.</p>
    2057         *
    2058         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    2059         * @param valueToFind  the value to find
    2060         * @param startIndex  the start index to travers backwards from
    2061         * @return the last index of the value within the array,
    2062         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2063         * @since 2.1
    2064         */
    2065        public static int lastIndexOf(char[] array, char valueToFind, int startIndex) {
    2066            if (array == null) {
    2067                return INDEX_NOT_FOUND;
    2068            }
    2069            if (startIndex < 0) {
    2070                return INDEX_NOT_FOUND;
    2071            } else if (startIndex >= array.length) {
    2072                startIndex = array.length - 1;
    2073            }
    2074            for (int i = startIndex; i >= 0; i--) {
    2075                if (valueToFind == array[i]) {
    2076                    return i;
    2077                }
    2078            }
    2079            return INDEX_NOT_FOUND;
    2080        }
    2081
    2082        /**
    2083         * <p>Checks if the value is in the given array.</p>
    2084         *
    2085         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    2086         *
    2087         * @param array  the array to search through
    2088         * @param valueToFind  the value to find
    2089         * @return <code>true</code> if the array contains the object
    2090         * @since 2.1
    2091         */
    2092        public static boolean contains(char[] array, char valueToFind) {
    2093            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    2094        }
    2095
    2096        // byte IndexOf
    2097        //-----------------------------------------------------------------------
    2098        /**
    2099         * <p>Finds the index of the given value in the array.</p>
    2100         *
    2101         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2102         *
    2103         * @param array  the array to search through for the object, may be <code>null</code>
    2104         * @param valueToFind  the value to find
    2105         * @return the index of the value within the array,
    2106         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2107         */
    2108        public static int indexOf(byte[] array, byte valueToFind) {
    2109            return indexOf(array, valueToFind, 0);
    2110        }
    2111
    2112        /**
    2113         * <p>Finds the index of the given value in the array starting at the given index.</p>
    2114         *
    2115         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2116         *
    2117         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    2118         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    2119         *
    2120         * @param array  the array to search through for the object, may be <code>null</code>
    2121         * @param valueToFind  the value to find
    2122         * @param startIndex  the index to start searching at
    2123         * @return the index of the value within the array,
    2124         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2125         */
    2126        public static int indexOf(byte[] array, byte valueToFind, int startIndex) {
    2127            if (array == null) {
    2128                return INDEX_NOT_FOUND;
    2129            }
    2130            if (startIndex < 0) {
    2131                startIndex = 0;
    2132            }
    2133            for (int i = startIndex; i < array.length; i++) {
    2134                if (valueToFind == array[i]) {
    2135                    return i;
    2136                }
    2137            }
    2138            return INDEX_NOT_FOUND;
    2139        }
    2140
    2141        /**
    2142         * <p>Finds the last index of the given value within the array.</p>
    2143         *
    2144         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2145         *
    2146         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    2147         * @param valueToFind  the object to find
    2148         * @return the last index of the value within the array,
    2149         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2150         */
    2151        public static int lastIndexOf(byte[] array, byte valueToFind) {
    2152            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    2153        }
    2154
    2155        /**
    2156         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    2157         *
    2158         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2159         *
    2160         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    2161         * array length will search from the end of the array.</p>
    2162         *
    2163         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    2164         * @param valueToFind  the value to find
    2165         * @param startIndex  the start index to travers backwards from
    2166         * @return the last index of the value within the array,
    2167         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2168         */
    2169        public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
    2170            if (array == null) {
    2171                return INDEX_NOT_FOUND;
    2172            }
    2173            if (startIndex < 0) {
    2174                return INDEX_NOT_FOUND;
    2175            } else if (startIndex >= array.length) {
    2176                startIndex = array.length - 1;
    2177            }
    2178            for (int i = startIndex; i >= 0; i--) {
    2179                if (valueToFind == array[i]) {
    2180                    return i;
    2181                }
    2182            }
    2183            return INDEX_NOT_FOUND;
    2184        }
    2185
    2186        /**
    2187         * <p>Checks if the value is in the given array.</p>
    2188         *
    2189         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    2190         *
    2191         * @param array  the array to search through
    2192         * @param valueToFind  the value to find
    2193         * @return <code>true</code> if the array contains the object
    2194         */
    2195        public static boolean contains(byte[] array, byte valueToFind) {
    2196            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    2197        }
    2198
    2199        // double IndexOf
    2200        //-----------------------------------------------------------------------
    2201        /**
    2202         * <p>Finds the index of the given value in the array.</p>
    2203         *
    2204         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2205         *
    2206         * @param array  the array to search through for the object, may be <code>null</code>
    2207         * @param valueToFind  the value to find
    2208         * @return the index of the value within the array,
    2209         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2210         */
    2211        public static int indexOf(double[] array, double valueToFind) {
    2212            return indexOf(array, valueToFind, 0);
    2213        }
    2214
    2215        /**
    2216         * <p>Finds the index of the given value within a given tolerance in the array.
    2217         * This method will return the index of the first value which falls between the region
    2218         * defined by valueToFind - tolerance and valueToFind + tolerance.</p>
    2219         *
    2220         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2221         *
    2222         * @param array  the array to search through for the object, may be <code>null</code>
    2223         * @param valueToFind  the value to find
    2224         * @param tolerance tolerance of the search
    2225         * @return the index of the value within the array,
    2226         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2227         */
    2228        public static int indexOf(double[] array, double valueToFind, double tolerance) {
    2229            return indexOf(array, valueToFind, 0, tolerance);
    2230        }
    2231
    2232        /**
    2233         * <p>Finds the index of the given value in the array starting at the given index.</p>
    2234         *
    2235         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2236         *
    2237         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    2238         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    2239         *
    2240         * @param array  the array to search through for the object, may be <code>null</code>
    2241         * @param valueToFind  the value to find
    2242         * @param startIndex  the index to start searching at
    2243         * @return the index of the value within the array,
    2244         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2245         */
    2246        public static int indexOf(double[] array, double valueToFind, int startIndex) {
    2247            if (ArrayUtils.isEmpty(array)) {
    2248                return INDEX_NOT_FOUND;
    2249            }
    2250            if (startIndex < 0) {
    2251                startIndex = 0;
    2252            }
    2253            for (int i = startIndex; i < array.length; i++) {
    2254                if (valueToFind == array[i]) {
    2255                    return i;
    2256                }
    2257            }
    2258            return INDEX_NOT_FOUND;
    2259        }
    2260
    2261        /**
    2262         * <p>Finds the index of the given value in the array starting at the given index.
    2263         * This method will return the index of the first value which falls between the region
    2264         * defined by valueToFind - tolerance and valueToFind + tolerance.</p>
    2265         *
    2266         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2267         *
    2268         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    2269         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    2270         *
    2271         * @param array  the array to search through for the object, may be <code>null</code>
    2272         * @param valueToFind  the value to find
    2273         * @param startIndex  the index to start searching at
    2274         * @param tolerance tolerance of the search
    2275         * @return the index of the value within the array,
    2276         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2277         */
    2278        public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
    2279            if (ArrayUtils.isEmpty(array)) {
    2280                return INDEX_NOT_FOUND;
    2281            }
    2282            if (startIndex < 0) {
    2283                startIndex = 0;
    2284            }
    2285            double min = valueToFind - tolerance;
    2286            double max = valueToFind + tolerance;
    2287            for (int i = startIndex; i < array.length; i++) {
    2288                if (array[i] >= min && array[i] <= max) {
    2289                    return i;
    2290                }
    2291            }
    2292            return INDEX_NOT_FOUND;
    2293        }
    2294
    2295        /**
    2296         * <p>Finds the last index of the given value within the array.</p>
    2297         *
    2298         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2299         *
    2300         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    2301         * @param valueToFind  the object to find
    2302         * @return the last index of the value within the array,
    2303         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2304         */
    2305        public static int lastIndexOf(double[] array, double valueToFind) {
    2306            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    2307        }
    2308
    2309        /**
    2310         * <p>Finds the last index of the given value within a given tolerance in the array.
    2311         * This method will return the index of the last value which falls between the region
    2312         * defined by valueToFind - tolerance and valueToFind + tolerance.</p>
    2313         *
    2314         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2315         *
    2316         * @param array  the array to search through for the object, may be <code>null</code>
    2317         * @param valueToFind  the value to find
    2318         * @param tolerance tolerance of the search
    2319         * @return the index of the value within the array,
    2320         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2321         */
    2322        public static int lastIndexOf(double[] array, double valueToFind, double tolerance) {
    2323            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance);
    2324        }
    2325
    2326        /**
    2327         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    2328         *
    2329         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2330         *
    2331         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    2332         * array length will search from the end of the array.</p>
    2333         *
    2334         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    2335         * @param valueToFind  the value to find
    2336         * @param startIndex  the start index to travers backwards from
    2337         * @return the last index of the value within the array,
    2338         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2339         */
    2340        public static int lastIndexOf(double[] array, double valueToFind, int startIndex) {
    2341            if (ArrayUtils.isEmpty(array)) {
    2342                return INDEX_NOT_FOUND;
    2343            }
    2344            if (startIndex < 0) {
    2345                return INDEX_NOT_FOUND;
    2346            } else if (startIndex >= array.length) {
    2347                startIndex = array.length - 1;
    2348            }
    2349            for (int i = startIndex; i >= 0; i--) {
    2350                if (valueToFind == array[i]) {
    2351                    return i;
    2352                }
    2353            }
    2354            return INDEX_NOT_FOUND;
    2355        }
    2356
    2357        /**
    2358         * <p>Finds the last index of the given value in the array starting at the given index.
    2359         * This method will return the index of the last value which falls between the region
    2360         * defined by valueToFind - tolerance and valueToFind + tolerance.</p>
    2361         *
    2362         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2363         *
    2364         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    2365         * array length will search from the end of the array.</p>
    2366         *
    2367         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    2368         * @param valueToFind  the value to find
    2369         * @param startIndex  the start index to travers backwards from
    2370         * @param tolerance  search for value within plus/minus this amount
    2371         * @return the last index of the value within the array,
    2372         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2373         */
    2374        public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
    2375            if (ArrayUtils.isEmpty(array)) {
    2376                return INDEX_NOT_FOUND;
    2377            }
    2378            if (startIndex < 0) {
    2379                return INDEX_NOT_FOUND;
    2380            } else if (startIndex >= array.length) {
    2381                startIndex = array.length - 1;
    2382            }
    2383            double min = valueToFind - tolerance;
    2384            double max = valueToFind + tolerance;
    2385            for (int i = startIndex; i >= 0; i--) {
    2386                if (array[i] >= min && array[i] <= max) {
    2387                    return i;
    2388                }
    2389            }
    2390            return INDEX_NOT_FOUND;
    2391        }
    2392
    2393        /**
    2394         * <p>Checks if the value is in the given array.</p>
    2395         *
    2396         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    2397         *
    2398         * @param array  the array to search through
    2399         * @param valueToFind  the value to find
    2400         * @return <code>true</code> if the array contains the object
    2401         */
    2402        public static boolean contains(double[] array, double valueToFind) {
    2403            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    2404        }
    2405
    2406        /**
    2407         * <p>Checks if a value falling within the given tolerance is in the
    2408         * given array.  If the array contains a value within the inclusive range
    2409         * defined by (value - tolerance) to (value + tolerance).</p>
    2410         *
    2411         * <p>The method returns <code>false</code> if a <code>null</code> array
    2412         * is passed in.</p>
    2413         *
    2414         * @param array  the array to search
    2415         * @param valueToFind  the value to find
    2416         * @param tolerance  the array contains the tolerance of the search
    2417         * @return true if value falling within tolerance is in array
    2418         */
    2419        public static boolean contains(double[] array, double valueToFind, double tolerance) {
    2420            return indexOf(array, valueToFind, 0, tolerance) != INDEX_NOT_FOUND;
    2421        }
    2422
    2423        // float IndexOf
    2424        //-----------------------------------------------------------------------
    2425        /**
    2426         * <p>Finds the index of the given value in the array.</p>
    2427         *
    2428         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2429         *
    2430         * @param array  the array to search through for the object, may be <code>null</code>
    2431         * @param valueToFind  the value to find
    2432         * @return the index of the value within the array,
    2433         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2434         */
    2435        public static int indexOf(float[] array, float valueToFind) {
    2436            return indexOf(array, valueToFind, 0);
    2437        }
    2438
    2439        /**
    2440         * <p>Finds the index of the given value in the array starting at the given index.</p>
    2441         *
    2442         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2443         *
    2444         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    2445         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    2446         *
    2447         * @param array  the array to search through for the object, may be <code>null</code>
    2448         * @param valueToFind  the value to find
    2449         * @param startIndex  the index to start searching at
    2450         * @return the index of the value within the array,
    2451         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2452         */
    2453        public static int indexOf(float[] array, float valueToFind, int startIndex) {
    2454            if (ArrayUtils.isEmpty(array)) {
    2455                return INDEX_NOT_FOUND;
    2456            }
    2457            if (startIndex < 0) {
    2458                startIndex = 0;
    2459            }
    2460            for (int i = startIndex; i < array.length; i++) {
    2461                if (valueToFind == array[i]) {
    2462                    return i;
    2463                }
    2464            }
    2465            return INDEX_NOT_FOUND;
    2466        }
    2467
    2468        /**
    2469         * <p>Finds the last index of the given value within the array.</p>
    2470         *
    2471         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2472         *
    2473         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    2474         * @param valueToFind  the object to find
    2475         * @return the last index of the value within the array,
    2476         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2477         */
    2478        public static int lastIndexOf(float[] array, float valueToFind) {
    2479            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    2480        }
    2481
    2482        /**
    2483         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    2484         *
    2485         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2486         *
    2487         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
    2488         * array length will search from the end of the array.</p>
    2489         *
    2490         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    2491         * @param valueToFind  the value to find
    2492         * @param startIndex  the start index to travers backwards from
    2493         * @return the last index of the value within the array,
    2494         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2495         */
    2496        public static int lastIndexOf(float[] array, float valueToFind, int startIndex) {
    2497            if (ArrayUtils.isEmpty(array)) {
    2498                return INDEX_NOT_FOUND;
    2499            }
    2500            if (startIndex < 0) {
    2501                return INDEX_NOT_FOUND;
    2502            } else if (startIndex >= array.length) {
    2503                startIndex = array.length - 1;
    2504            }
    2505            for (int i = startIndex; i >= 0; i--) {
    2506                if (valueToFind == array[i]) {
    2507                    return i;
    2508                }
    2509            }
    2510            return INDEX_NOT_FOUND;
    2511        }
    2512
    2513        /**
    2514         * <p>Checks if the value is in the given array.</p>
    2515         *
    2516         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    2517         *
    2518         * @param array  the array to search through
    2519         * @param valueToFind  the value to find
    2520         * @return <code>true</code> if the array contains the object
    2521         */
    2522        public static boolean contains(float[] array, float valueToFind) {
    2523            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    2524        }
    2525
    2526        // boolean IndexOf
    2527        //-----------------------------------------------------------------------
    2528        /**
    2529         * <p>Finds the index of the given value in the array.</p>
    2530         *
    2531         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2532         *
    2533         * @param array  the array to search through for the object, may be <code>null</code>
    2534         * @param valueToFind  the value to find
    2535         * @return the index of the value within the array,
    2536         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2537         */
    2538        public static int indexOf(boolean[] array, boolean valueToFind) {
    2539            return indexOf(array, valueToFind, 0);
    2540        }
    2541
    2542        /**
    2543         * <p>Finds the index of the given value in the array starting at the given index.</p>
    2544         *
    2545         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2546         *
    2547         * <p>A negative startIndex is treated as zero. A startIndex larger than the array
    2548         * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
    2549         *
    2550         * @param array  the array to search through for the object, may be <code>null</code>
    2551         * @param valueToFind  the value to find
    2552         * @param startIndex  the index to start searching at
    2553         * @return the index of the value within the array,
    2554         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code>
    2555         *  array input
    2556         */
    2557        public static int indexOf(boolean[] array, boolean valueToFind, int startIndex) {
    2558            if (ArrayUtils.isEmpty(array)) {
    2559                return INDEX_NOT_FOUND;
    2560            }
    2561            if (startIndex < 0) {
    2562                startIndex = 0;
    2563            }
    2564            for (int i = startIndex; i < array.length; i++) {
    2565                if (valueToFind == array[i]) {
    2566                    return i;
    2567                }
    2568            }
    2569            return INDEX_NOT_FOUND;
    2570        }
    2571
    2572        /**
    2573         * <p>Finds the last index of the given value within the array.</p>
    2574         *
    2575         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) if
    2576         * <code>null</code> array input.</p>
    2577         *
    2578         * @param array  the array to travers backwords looking for the object, may be <code>null</code>
    2579         * @param valueToFind  the object to find
    2580         * @return the last index of the value within the array,
    2581         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2582         */
    2583        public static int lastIndexOf(boolean[] array, boolean valueToFind) {
    2584            return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    2585        }
    2586
    2587        /**
    2588         * <p>Finds the last index of the given value in the array starting at the given index.</p>
    2589         *
    2590         * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
    2591         *
    2592         * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than
    2593         * the array length will search from the end of the array.</p>
    2594         *
    2595         * @param array  the array to traverse for looking for the object, may be <code>null</code>
    2596         * @param valueToFind  the value to find
    2597         * @param startIndex  the start index to travers backwards from
    2598         * @return the last index of the value within the array,
    2599         *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
    2600         */
    2601        public static int lastIndexOf(boolean[] array, boolean valueToFind, int startIndex) {
    2602            if (ArrayUtils.isEmpty(array)) {
    2603                return INDEX_NOT_FOUND;
    2604            }
    2605            if (startIndex < 0) {
    2606                return INDEX_NOT_FOUND;
    2607            } else if (startIndex >= array.length) {
    2608                startIndex = array.length - 1;
    2609            }
    2610            for (int i = startIndex; i >= 0; i--) {
    2611                if (valueToFind == array[i]) {
    2612                    return i;
    2613                }
    2614            }
    2615            return INDEX_NOT_FOUND;
    2616        }
    2617
    2618        /**
    2619         * <p>Checks if the value is in the given array.</p>
    2620         *
    2621         * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
    2622         *
    2623         * @param array  the array to search through
    2624         * @param valueToFind  the value to find
    2625         * @return <code>true</code> if the array contains the object
    2626         */
    2627        public static boolean contains(boolean[] array, boolean valueToFind) {
    2628            return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    2629        }
    2630
    2631        // Primitive/Object array converters
    2632        // ----------------------------------------------------------------------
    2633
    2634        // Character array converters
    2635        // ----------------------------------------------------------------------
    2636        /**
    2637         * <p>Converts an array of object Characters to primitives.</p>
    2638         *
    2639         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2640         *
    2641         * @param array  a <code>Character</code> array, may be <code>null</code>
    2642         * @return a <code>char</code> array, <code>null</code> if null array input
    2643         * @throws NullPointerException if array content is <code>null</code>
    2644         */
    2645        public static char[] toPrimitive(Character[] array) {
    2646            if (array == null) {
    2647                return null;
    2648            } else if (array.length == 0) {
    2649                return EMPTY_CHAR_ARRAY;
    2650            }
    2651            final char[] result = new char[array.length];
    2652            for (int i = 0; i < array.length; i++) {
    2653                result[i] = array[i].charValue();
    2654            }
    2655            return result;
    2656        }
    2657
    2658        /**
    2659         * <p>Converts an array of object Character to primitives handling <code>null</code>.</p>
    2660         *
    2661         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2662         *
    2663         * @param array  a <code>Character</code> array, may be <code>null</code>
    2664         * @param valueForNull  the value to insert if <code>null</code> found
    2665         * @return a <code>char</code> array, <code>null</code> if null array input
    2666         */
    2667        public static char[] toPrimitive(Character[] array, char valueForNull) {
    2668            if (array == null) {
    2669                return null;
    2670            } else if (array.length == 0) {
    2671                return EMPTY_CHAR_ARRAY;
    2672            }
    2673            final char[] result = new char[array.length];
    2674            for (int i = 0; i < array.length; i++) {
    2675                Character b = array[i];
    2676                result[i] = (b == null ? valueForNull : b.charValue());
    2677            }
    2678            return result;
    2679        }
    2680
    2681        /**
    2682         * <p>Converts an array of primitive chars to objects.</p>
    2683         *
    2684         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2685         *
    2686         * @param array a <code>char</code> array
    2687         * @return a <code>Character</code> array, <code>null</code> if null array input
    2688         */
    2689        public static Character[] toObject(char[] array) {
    2690            if (array == null) {
    2691                return null;
    2692            } else if (array.length == 0) {
    2693                return EMPTY_CHARACTER_OBJECT_ARRAY;
    2694            }
    2695            final Character[] result = new Character[array.length];
    2696            for (int i = 0; i < array.length; i++) {
    2697                result[i] = new Character(array[i]);
    2698            }
    2699            return result;
    2700         }
    2701
    2702        // Long array converters
    2703        // ----------------------------------------------------------------------
    2704        /**
    2705         * <p>Converts an array of object Longs to primitives.</p>
    2706         *
    2707         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2708         *
    2709         * @param array  a <code>Long</code> array, may be <code>null</code>
    2710         * @return a <code>long</code> array, <code>null</code> if null array input
    2711         * @throws NullPointerException if array content is <code>null</code>
    2712         */
    2713        public static long[] toPrimitive(Long[] array) {
    2714            if (array == null) {
    2715                return null;
    2716            } else if (array.length == 0) {
    2717                return EMPTY_LONG_ARRAY;
    2718            }
    2719            final long[] result = new long[array.length];
    2720            for (int i = 0; i < array.length; i++) {
    2721                result[i] = array[i].longValue();
    2722            }
    2723            return result;
    2724        }
    2725
    2726        /**
    2727         * <p>Converts an array of object Long to primitives handling <code>null</code>.</p>
    2728         *
    2729         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2730         *
    2731         * @param array  a <code>Long</code> array, may be <code>null</code>
    2732         * @param valueForNull  the value to insert if <code>null</code> found
    2733         * @return a <code>long</code> array, <code>null</code> if null array input
    2734         */
    2735        public static long[] toPrimitive(Long[] array, long valueForNull) {
    2736            if (array == null) {
    2737                return null;
    2738            } else if (array.length == 0) {
    2739                return EMPTY_LONG_ARRAY;
    2740            }
    2741            final long[] result = new long[array.length];
    2742            for (int i = 0; i < array.length; i++) {
    2743                Long b = array[i];
    2744                result[i] = (b == null ? valueForNull : b.longValue());
    2745            }
    2746            return result;
    2747        }
    2748
    2749        /**
    2750         * <p>Converts an array of primitive longs to objects.</p>
    2751         *
    2752         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2753         *
    2754         * @param array  a <code>long</code> array
    2755         * @return a <code>Long</code> array, <code>null</code> if null array input
    2756         */
    2757        public static Long[] toObject(long[] array) {
    2758            if (array == null) {
    2759                return null;
    2760            } else if (array.length == 0) {
    2761                return EMPTY_LONG_OBJECT_ARRAY;
    2762            }
    2763            final Long[] result = new Long[array.length];
    2764            for (int i = 0; i < array.length; i++) {
    2765                result[i] = new Long(array[i]);
    2766            }
    2767            return result;
    2768        }
    2769
    2770        // Int array converters
    2771        // ----------------------------------------------------------------------
    2772        /**
    2773         * <p>Converts an array of object Integers to primitives.</p>
    2774         *
    2775         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2776         *
    2777         * @param array  a <code>Integer</code> array, may be <code>null</code>
    2778         * @return an <code>int</code> array, <code>null</code> if null array input
    2779         * @throws NullPointerException if array content is <code>null</code>
    2780         */
    2781        public static int[] toPrimitive(Integer[] array) {
    2782            if (array == null) {
    2783                return null;
    2784            } else if (array.length == 0) {
    2785                return EMPTY_INT_ARRAY;
    2786            }
    2787            final int[] result = new int[array.length];
    2788            for (int i = 0; i < array.length; i++) {
    2789                result[i] = array[i].intValue();
    2790            }
    2791            return result;
    2792        }
    2793
    2794        /**
    2795         * <p>Converts an array of object Integer to primitives handling <code>null</code>.</p>
    2796         *
    2797         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2798         *
    2799         * @param array  a <code>Integer</code> array, may be <code>null</code>
    2800         * @param valueForNull  the value to insert if <code>null</code> found
    2801         * @return an <code>int</code> array, <code>null</code> if null array input
    2802         */
    2803        public static int[] toPrimitive(Integer[] array, int valueForNull) {
    2804            if (array == null) {
    2805                return null;
    2806            } else if (array.length == 0) {
    2807                return EMPTY_INT_ARRAY;
    2808            }
    2809            final int[] result = new int[array.length];
    2810            for (int i = 0; i < array.length; i++) {
    2811                Integer b = array[i];
    2812                result[i] = (b == null ? valueForNull : b.intValue());
    2813            }
    2814            return result;
    2815        }
    2816
    2817        /**
    2818         * <p>Converts an array of primitive ints to objects.</p>
    2819         *
    2820         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2821         *
    2822         * @param array  an <code>int</code> array
    2823         * @return an <code>Integer</code> array, <code>null</code> if null array input
    2824         */
    2825        public static Integer[] toObject(int[] array) {
    2826            if (array == null) {
    2827                return null;
    2828            } else if (array.length == 0) {
    2829                return EMPTY_INTEGER_OBJECT_ARRAY;
    2830            }
    2831            final Integer[] result = new Integer[array.length];
    2832            for (int i = 0; i < array.length; i++) {
    2833                result[i] = new Integer(array[i]);
    2834            }
    2835            return result;
    2836        }
    2837
    2838        // Short array converters
    2839        // ----------------------------------------------------------------------
    2840        /**
    2841         * <p>Converts an array of object Shorts to primitives.</p>
    2842         *
    2843         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2844         *
    2845         * @param array  a <code>Short</code> array, may be <code>null</code>
    2846         * @return a <code>byte</code> array, <code>null</code> if null array input
    2847         * @throws NullPointerException if array content is <code>null</code>
    2848         */
    2849        public static short[] toPrimitive(Short[] array) {
    2850            if (array == null) {
    2851                return null;
    2852            } else if (array.length == 0) {
    2853                return EMPTY_SHORT_ARRAY;
    2854            }
    2855            final short[] result = new short[array.length];
    2856            for (int i = 0; i < array.length; i++) {
    2857                result[i] = array[i].shortValue();
    2858            }
    2859            return result;
    2860        }
    2861
    2862        /**
    2863         * <p>Converts an array of object Short to primitives handling <code>null</code>.</p>
    2864         *
    2865         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2866         *
    2867         * @param array  a <code>Short</code> array, may be <code>null</code>
    2868         * @param valueForNull  the value to insert if <code>null</code> found
    2869         * @return a <code>byte</code> array, <code>null</code> if null array input
    2870         */
    2871        public static short[] toPrimitive(Short[] array, short valueForNull) {
    2872            if (array == null) {
    2873                return null;
    2874            } else if (array.length == 0) {
    2875                return EMPTY_SHORT_ARRAY;
    2876            }
    2877            final short[] result = new short[array.length];
    2878            for (int i = 0; i < array.length; i++) {
    2879                Short b = array[i];
    2880                result[i] = (b == null ? valueForNull : b.shortValue());
    2881            }
    2882            return result;
    2883        }
    2884
    2885        /**
    2886         * <p>Converts an array of primitive shorts to objects.</p>
    2887         *
    2888         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2889         *
    2890         * @param array  a <code>short</code> array
    2891         * @return a <code>Short</code> array, <code>null</code> if null array input
    2892         */
    2893        public static Short[] toObject(short[] array) {
    2894            if (array == null) {
    2895                return null;
    2896            } else if (array.length == 0) {
    2897                return EMPTY_SHORT_OBJECT_ARRAY;
    2898            }
    2899            final Short[] result = new Short[array.length];
    2900            for (int i = 0; i < array.length; i++) {
    2901                result[i] = new Short(array[i]);
    2902            }
    2903            return result;
    2904        }
    2905
    2906        // Byte array converters
    2907        // ----------------------------------------------------------------------
    2908        /**
    2909         * <p>Converts an array of object Bytes to primitives.</p>
    2910         *
    2911         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2912         *
    2913         * @param array  a <code>Byte</code> array, may be <code>null</code>
    2914         * @return a <code>byte</code> array, <code>null</code> if null array input
    2915         * @throws NullPointerException if array content is <code>null</code>
    2916         */
    2917        public static byte[] toPrimitive(Byte[] array) {
    2918            if (array == null) {
    2919                return null;
    2920            } else if (array.length == 0) {
    2921                return EMPTY_BYTE_ARRAY;
    2922            }
    2923            final byte[] result = new byte[array.length];
    2924            for (int i = 0; i < array.length; i++) {
    2925                result[i] = array[i].byteValue();
    2926            }
    2927            return result;
    2928        }
    2929
    2930        /**
    2931         * <p>Converts an array of object Bytes to primitives handling <code>null</code>.</p>
    2932         *
    2933         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2934         *
    2935         * @param array  a <code>Byte</code> array, may be <code>null</code>
    2936         * @param valueForNull  the value to insert if <code>null</code> found
    2937         * @return a <code>byte</code> array, <code>null</code> if null array input
    2938         */
    2939        public static byte[] toPrimitive(Byte[] array, byte valueForNull) {
    2940            if (array == null) {
    2941                return null;
    2942            } else if (array.length == 0) {
    2943                return EMPTY_BYTE_ARRAY;
    2944            }
    2945            final byte[] result = new byte[array.length];
    2946            for (int i = 0; i < array.length; i++) {
    2947                Byte b = array[i];
    2948                result[i] = (b == null ? valueForNull : b.byteValue());
    2949            }
    2950            return result;
    2951        }
    2952
    2953        /**
    2954         * <p>Converts an array of primitive bytes to objects.</p>
    2955         *
    2956         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2957         *
    2958         * @param array  a <code>byte</code> array
    2959         * @return a <code>Byte</code> array, <code>null</code> if null array input
    2960         */
    2961        public static Byte[] toObject(byte[] array) {
    2962            if (array == null) {
    2963                return null;
    2964            } else if (array.length == 0) {
    2965                return EMPTY_BYTE_OBJECT_ARRAY;
    2966            }
    2967            final Byte[] result = new Byte[array.length];
    2968            for (int i = 0; i < array.length; i++) {
    2969                result[i] = new Byte(array[i]);
    2970            }
    2971            return result;
    2972        }
    2973
    2974        // Double array converters
    2975        // ----------------------------------------------------------------------
    2976        /**
    2977         * <p>Converts an array of object Doubles to primitives.</p>
    2978         *
    2979         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    2980         *
    2981         * @param array  a <code>Double</code> array, may be <code>null</code>
    2982         * @return a <code>double</code> array, <code>null</code> if null array input
    2983         * @throws NullPointerException if array content is <code>null</code>
    2984         */
    2985        public static double[] toPrimitive(Double[] array) {
    2986            if (array == null) {
    2987                return null;
    2988            } else if (array.length == 0) {
    2989                return EMPTY_DOUBLE_ARRAY;
    2990            }
    2991            final double[] result = new double[array.length];
    2992            for (int i = 0; i < array.length; i++) {
    2993                result[i] = array[i].doubleValue();
    2994            }
    2995            return result;
    2996        }
    2997
    2998        /**
    2999         * <p>Converts an array of object Doubles to primitives handling <code>null</code>.</p>
    3000         *
    3001         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3002         *
    3003         * @param array  a <code>Double</code> array, may be <code>null</code>
    3004         * @param valueForNull  the value to insert if <code>null</code> found
    3005         * @return a <code>double</code> array, <code>null</code> if null array input
    3006         */
    3007        public static double[] toPrimitive(Double[] array, double valueForNull) {
    3008            if (array == null) {
    3009                return null;
    3010            } else if (array.length == 0) {
    3011                return EMPTY_DOUBLE_ARRAY;
    3012            }
    3013            final double[] result = new double[array.length];
    3014            for (int i = 0; i < array.length; i++) {
    3015                Double b = array[i];
    3016                result[i] = (b == null ? valueForNull : b.doubleValue());
    3017            }
    3018            return result;
    3019        }
    3020
    3021        /**
    3022         * <p>Converts an array of primitive doubles to objects.</p>
    3023         *
    3024         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3025         *
    3026         * @param array  a <code>double</code> array
    3027         * @return a <code>Double</code> array, <code>null</code> if null array input
    3028         */
    3029        public static Double[] toObject(double[] array) {
    3030            if (array == null) {
    3031                return null;
    3032            } else if (array.length == 0) {
    3033                return EMPTY_DOUBLE_OBJECT_ARRAY;
    3034            }
    3035            final Double[] result = new Double[array.length];
    3036            for (int i = 0; i < array.length; i++) {
    3037                result[i] = new Double(array[i]);
    3038            }
    3039            return result;
    3040        }
    3041
    3042        //   Float array converters
    3043        // ----------------------------------------------------------------------
    3044        /**
    3045         * <p>Converts an array of object Floats to primitives.</p>
    3046         *
    3047         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3048         *
    3049         * @param array  a <code>Float</code> array, may be <code>null</code>
    3050         * @return a <code>float</code> array, <code>null</code> if null array input
    3051         * @throws NullPointerException if array content is <code>null</code>
    3052         */
    3053        public static float[] toPrimitive(Float[] array) {
    3054            if (array == null) {
    3055                return null;
    3056            } else if (array.length == 0) {
    3057                return EMPTY_FLOAT_ARRAY;
    3058            }
    3059            final float[] result = new float[array.length];
    3060            for (int i = 0; i < array.length; i++) {
    3061                result[i] = array[i].floatValue();
    3062            }
    3063            return result;
    3064        }
    3065
    3066        /**
    3067         * <p>Converts an array of object Floats to primitives handling <code>null</code>.</p>
    3068         *
    3069         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3070         *
    3071         * @param array  a <code>Float</code> array, may be <code>null</code>
    3072         * @param valueForNull  the value to insert if <code>null</code> found
    3073         * @return a <code>float</code> array, <code>null</code> if null array input
    3074         */
    3075        public static float[] toPrimitive(Float[] array, float valueForNull) {
    3076            if (array == null) {
    3077                return null;
    3078            } else if (array.length == 0) {
    3079                return EMPTY_FLOAT_ARRAY;
    3080            }
    3081            final float[] result = new float[array.length];
    3082            for (int i = 0; i < array.length; i++) {
    3083                Float b = array[i];
    3084                result[i] = (b == null ? valueForNull : b.floatValue());
    3085            }
    3086            return result;
    3087        }
    3088
    3089        /**
    3090         * <p>Converts an array of primitive floats to objects.</p>
    3091         *
    3092         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3093         *
    3094         * @param array  a <code>float</code> array
    3095         * @return a <code>Float</code> array, <code>null</code> if null array input
    3096         */
    3097        public static Float[] toObject(float[] array) {
    3098            if (array == null) {
    3099                return null;
    3100            } else if (array.length == 0) {
    3101                return EMPTY_FLOAT_OBJECT_ARRAY;
    3102            }
    3103            final Float[] result = new Float[array.length];
    3104            for (int i = 0; i < array.length; i++) {
    3105                result[i] = new Float(array[i]);
    3106            }
    3107            return result;
    3108        }
    3109
    3110        // Boolean array converters
    3111        // ----------------------------------------------------------------------
    3112        /**
    3113         * <p>Converts an array of object Booleans to primitives.</p>
    3114         *
    3115         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3116         *
    3117         * @param array  a <code>Boolean</code> array, may be <code>null</code>
    3118         * @return a <code>boolean</code> array, <code>null</code> if null array input
    3119         * @throws NullPointerException if array content is <code>null</code>
    3120         */
    3121        public static boolean[] toPrimitive(Boolean[] array) {
    3122            if (array == null) {
    3123                return null;
    3124            } else if (array.length == 0) {
    3125                return EMPTY_BOOLEAN_ARRAY;
    3126            }
    3127            final boolean[] result = new boolean[array.length];
    3128            for (int i = 0; i < array.length; i++) {
    3129                result[i] = array[i].booleanValue();
    3130            }
    3131            return result;
    3132        }
    3133
    3134        /**
    3135         * <p>Converts an array of object Booleans to primitives handling <code>null</code>.</p>
    3136         *
    3137         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3138         *
    3139         * @param array  a <code>Boolean</code> array, may be <code>null</code>
    3140         * @param valueForNull  the value to insert if <code>null</code> found
    3141         * @return a <code>boolean</code> array, <code>null</code> if null array input
    3142         */
    3143        public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull) {
    3144            if (array == null) {
    3145                return null;
    3146            } else if (array.length == 0) {
    3147                return EMPTY_BOOLEAN_ARRAY;
    3148            }
    3149            final boolean[] result = new boolean[array.length];
    3150            for (int i = 0; i < array.length; i++) {
    3151                Boolean b = array[i];
    3152                result[i] = (b == null ? valueForNull : b.booleanValue());
    3153            }
    3154            return result;
    3155        }
    3156
    3157        /**
    3158         * <p>Converts an array of primitive booleans to objects.</p>
    3159         *
    3160         * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
    3161         *
    3162         * @param array  a <code>boolean</code> array
    3163         * @return a <code>Boolean</code> array, <code>null</code> if null array input
    3164         */
    3165        public static Boolean[] toObject(boolean[] array) {
    3166            if (array == null) {
    3167                return null;
    3168            } else if (array.length == 0) {
    3169                return EMPTY_BOOLEAN_OBJECT_ARRAY;
    3170            }
    3171            final Boolean[] result = new Boolean[array.length];
    3172            for (int i = 0; i < array.length; i++) {
    3173                result[i] = (array[i] ? Boolean.TRUE : Boolean.FALSE);
    3174            }
    3175            return result;
    3176        }
    3177
    3178        // ----------------------------------------------------------------------
    3179        /**
    3180         * <p>Checks if an array of Objects is empty or <code>null</code>.</p>
    3181         *
    3182         * @param array  the array to test
    3183         * @return <code>true</code> if the array is empty or <code>null</code>
    3184         * @since 2.1
    3185         */
    3186        public static boolean isEmpty(Object[] array) {
    3187            return array == null || array.length == 0;
    3188        }
    3189
    3190        /**
    3191         * <p>Checks if an array of primitive longs is empty or <code>null</code>.</p>
    3192         *
    3193         * @param array  the array to test
    3194         * @return <code>true</code> if the array is empty or <code>null</code>
    3195         * @since 2.1
    3196         */
    3197        public static boolean isEmpty(long[] array) {
    3198            return array == null || array.length == 0;
    3199        }
    3200
    3201        /**
    3202         * <p>Checks if an array of primitive ints is empty or <code>null</code>.</p>
    3203         *
    3204         * @param array  the array to test
    3205         * @return <code>true</code> if the array is empty or <code>null</code>
    3206         * @since 2.1
    3207         */
    3208        public static boolean isEmpty(int[] array) {
    3209            return array == null || array.length == 0;
    3210        }
    3211
    3212        /**
    3213         * <p>Checks if an array of primitive shorts is empty or <code>null</code>.</p>
    3214         *
    3215         * @param array  the array to test
    3216         * @return <code>true</code> if the array is empty or <code>null</code>
    3217         * @since 2.1
    3218         */
    3219        public static boolean isEmpty(short[] array) {
    3220            return array == null || array.length == 0;
    3221        }
    3222
    3223        /**
    3224         * <p>Checks if an array of primitive chars is empty or <code>null</code>.</p>
    3225         *
    3226         * @param array  the array to test
    3227         * @return <code>true</code> if the array is empty or <code>null</code>
    3228         * @since 2.1
    3229         */
    3230        public static boolean isEmpty(char[] array) {
    3231            return array == null || array.length == 0;
    3232        }
    3233
    3234        /**
    3235         * <p>Checks if an array of primitive bytes is empty or <code>null</code>.</p>
    3236         *
    3237         * @param array  the array to test
    3238         * @return <code>true</code> if the array is empty or <code>null</code>
    3239         * @since 2.1
    3240         */
    3241        public static boolean isEmpty(byte[] array) {
    3242            return array == null || array.length == 0;
    3243        }
    3244
    3245        /**
    3246         * <p>Checks if an array of primitive doubles is empty or <code>null</code>.</p>
    3247         *
    3248         * @param array  the array to test
    3249         * @return <code>true</code> if the array is empty or <code>null</code>
    3250         * @since 2.1
    3251         */
    3252        public static boolean isEmpty(double[] array) {
    3253            return array == null || array.length == 0;
    3254        }
    3255
    3256        /**
    3257         * <p>Checks if an array of primitive floats is empty or <code>null</code>.</p>
    3258         *
    3259         * @param array  the array to test
    3260         * @return <code>true</code> if the array is empty or <code>null</code>
    3261         * @since 2.1
    3262         */
    3263        public static boolean isEmpty(float[] array) {
    3264            return array == null || array.length == 0;
    3265        }
    3266
    3267        /**
    3268         * <p>Checks if an array of primitive booleans is empty or <code>null</code>.</p>
    3269         *
    3270         * @param array  the array to test
    3271         * @return <code>true</code> if the array is empty or <code>null</code>
    3272         * @since 2.1
    3273         */
    3274        public static boolean isEmpty(boolean[] array) {
    3275            return array == null || array.length == 0;
    3276        }
    3277
    3278        // ----------------------------------------------------------------------
    3279        /**
    3280         * <p>Checks if an array of Objects is not empty or not <code>null</code>.</p>
    3281         *
    3282         * @param array  the array to test
    3283         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3284         * @since 2.5
    3285         */
    3286         public static boolean isNotEmpty(Object[] array) {
    3287             return (array != null && array.length != 0);
    3288         }
    3289
    3290        /**
    3291         * <p>Checks if an array of primitive longs is not empty or not <code>null</code>.</p>
    3292         *
    3293         * @param array  the array to test
    3294         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3295         * @since 2.5
    3296         */
    3297        public static boolean isNotEmpty(long[] array) {
    3298            return (array != null && array.length != 0);
    3299        }
    3300
    3301        /**
    3302         * <p>Checks if an array of primitive ints is not empty or not <code>null</code>.</p>
    3303         *
    3304         * @param array  the array to test
    3305         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3306         * @since 2.5
    3307         */
    3308        public static boolean isNotEmpty(int[] array) {
    3309            return (array != null && array.length != 0);
    3310        }
    3311
    3312        /**
    3313         * <p>Checks if an array of primitive shorts is not empty or not <code>null</code>.</p>
    3314         *
    3315         * @param array  the array to test
    3316         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3317         * @since 2.5
    3318         */
    3319        public static boolean isNotEmpty(short[] array) {
    3320            return (array != null && array.length != 0);
    3321        }
    3322
    3323        /**
    3324         * <p>Checks if an array of primitive chars is not empty or not <code>null</code>.</p>
    3325         *
    3326         * @param array  the array to test
    3327         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3328         * @since 2.5
    3329         */
    3330        public static boolean isNotEmpty(char[] array) {
    3331            return (array != null && array.length != 0);
    3332        }
    3333
    3334        /**
    3335         * <p>Checks if an array of primitive bytes is not empty or not <code>null</code>.</p>
    3336         *
    3337         * @param array  the array to test
    3338         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3339         * @since 2.5
    3340         */
    3341        public static boolean isNotEmpty(byte[] array) {
    3342            return (array != null && array.length != 0);
    3343        }
    3344
    3345        /**
    3346         * <p>Checks if an array of primitive doubles is not empty or not <code>null</code>.</p>
    3347         *
    3348         * @param array  the array to test
    3349         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3350         * @since 2.5
    3351         */
    3352        public static boolean isNotEmpty(double[] array) {
    3353            return (array != null && array.length != 0);
    3354        }
    3355
    3356        /**
    3357         * <p>Checks if an array of primitive floats is not empty or not <code>null</code>.</p>
    3358         *
    3359         * @param array  the array to test
    3360         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3361         * @since 2.5
    3362         */
    3363        public static boolean isNotEmpty(float[] array) {
    3364            return (array != null && array.length != 0);
    3365        }
    3366
    3367        /**
    3368         * <p>Checks if an array of primitive booleans is not empty or not <code>null</code>.</p>
    3369         *
    3370         * @param array  the array to test
    3371         * @return <code>true</code> if the array is not empty or not <code>null</code>
    3372         * @since 2.5
    3373         */
    3374        public static boolean isNotEmpty(boolean[] array) {
    3375            return (array != null && array.length != 0);
    3376        }
    3377
    3378        /**
    3379         * <p>Adds all the elements of the given arrays into a new array.</p>
    3380         * <p>The new array contains all of the element of <code>array1</code> followed
    3381         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3382         * a new array.</p>
    3383         *
    3384         * <pre>
    3385         * ArrayUtils.addAll(null, null)     = null
    3386         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3387         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3388         * ArrayUtils.addAll([], [])         = []
    3389         * ArrayUtils.addAll([null], [null]) = [null, null]
    3390         * ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
    3391         * </pre>
    3392         *
    3393         * @param array1  the first array whose elements are added to the new array, may be <code>null</code>
    3394         * @param array2  the second array whose elements are added to the new array, may be <code>null</code>
    3395         * @return The new array, <code>null</code> if both arrays are <code>null</code>.
    3396         *      The type of the new array is the type of the first array,
    3397         *      unless the first array is null, in which case the type is the same as the second array.
    3398         * @since 2.1
    3399         * @throws IllegalArgumentException if the array types are incompatible
    3400         */
    3401        public static Object[] addAll(Object[] array1, Object[] array2) {
    3402            if (array1 == null) {
    3403                return clone(array2);
    3404            } else if (array2 == null) {
    3405                return clone(array1);
    3406            }
    3407            Object[] joinedArray = (Object[]) Array.newInstance(array1.getClass().getComponentType(),
    3408                                                                array1.length + array2.length);
    3409            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3410            try {
    3411                System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3412            } catch (ArrayStoreException ase) {
    3413                // Check if problem was due to incompatible types
    3414                /*
    3415                 * We do this here, rather than before the copy because:
    3416                 * - it would be a wasted check most of the time
    3417                 * - safer, in case check turns out to be too strict
    3418                 */
    3419                final Class type1 = array1.getClass().getComponentType();
    3420                final Class type2 = array2.getClass().getComponentType();
    3421                if (!type1.isAssignableFrom(type2)){
    3422                    throw new IllegalArgumentException("Cannot store "+type2.getName()+" in an array of "+type1.getName());
    3423                }
    3424                throw ase; // No, so rethrow original
    3425            }
    3426            return joinedArray;
    3427        }
    3428
    3429        /**
    3430         * <p>Adds all the elements of the given arrays into a new array.</p>
    3431         * <p>The new array contains all of the element of <code>array1</code> followed
    3432         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3433         * a new array.</p>
    3434         *
    3435         * <pre>
    3436         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3437         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3438         * ArrayUtils.addAll([], [])         = []
    3439         * </pre>
    3440         *
    3441         * @param array1  the first array whose elements are added to the new array.
    3442         * @param array2  the second array whose elements are added to the new array.
    3443         * @return The new boolean[] array.
    3444         * @since 2.1
    3445         */
    3446        public static boolean[] addAll(boolean[] array1, boolean[] array2) {
    3447            if (array1 == null) {
    3448                return clone(array2);
    3449            } else if (array2 == null) {
    3450                return clone(array1);
    3451            }
    3452            boolean[] joinedArray = new boolean[array1.length + array2.length];
    3453            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3454            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3455            return joinedArray;
    3456        }
    3457
    3458        /**
    3459         * <p>Adds all the elements of the given arrays into a new array.</p>
    3460         * <p>The new array contains all of the element of <code>array1</code> followed
    3461         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3462         * a new array.</p>
    3463         *
    3464         * <pre>
    3465         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3466         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3467         * ArrayUtils.addAll([], [])         = []
    3468         * </pre>
    3469         *
    3470         * @param array1  the first array whose elements are added to the new array.
    3471         * @param array2  the second array whose elements are added to the new array.
    3472         * @return The new char[] array.
    3473         * @since 2.1
    3474         */
    3475        public static char[] addAll(char[] array1, char[] array2) {
    3476            if (array1 == null) {
    3477                return clone(array2);
    3478            } else if (array2 == null) {
    3479                return clone(array1);
    3480            }
    3481            char[] joinedArray = new char[array1.length + array2.length];
    3482            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3483            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3484            return joinedArray;
    3485        }
    3486
    3487        /**
    3488         * <p>Adds all the elements of the given arrays into a new array.</p>
    3489         * <p>The new array contains all of the element of <code>array1</code> followed
    3490         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3491         * a new array.</p>
    3492         *
    3493         * <pre>
    3494         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3495         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3496         * ArrayUtils.addAll([], [])         = []
    3497         * </pre>
    3498         *
    3499         * @param array1  the first array whose elements are added to the new array.
    3500         * @param array2  the second array whose elements are added to the new array.
    3501         * @return The new byte[] array.
    3502         * @since 2.1
    3503         */
    3504        public static byte[] addAll(byte[] array1, byte[] array2) {
    3505            if (array1 == null) {
    3506                return clone(array2);
    3507            } else if (array2 == null) {
    3508                return clone(array1);
    3509            }
    3510            byte[] joinedArray = new byte[array1.length + array2.length];
    3511            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3512            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3513            return joinedArray;
    3514        }
    3515
    3516        /**
    3517         * <p>Adds all the elements of the given arrays into a new array.</p>
    3518         * <p>The new array contains all of the element of <code>array1</code> followed
    3519         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3520         * a new array.</p>
    3521         *
    3522         * <pre>
    3523         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3524         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3525         * ArrayUtils.addAll([], [])         = []
    3526         * </pre>
    3527         *
    3528         * @param array1  the first array whose elements are added to the new array.
    3529         * @param array2  the second array whose elements are added to the new array.
    3530         * @return The new short[] array.
    3531         * @since 2.1
    3532         */
    3533        public static short[] addAll(short[] array1, short[] array2) {
    3534            if (array1 == null) {
    3535                return clone(array2);
    3536            } else if (array2 == null) {
    3537                return clone(array1);
    3538            }
    3539            short[] joinedArray = new short[array1.length + array2.length];
    3540            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3541            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3542            return joinedArray;
    3543        }
    3544
    3545        /**
    3546         * <p>Adds all the elements of the given arrays into a new array.</p>
    3547         * <p>The new array contains all of the element of <code>array1</code> followed
    3548         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3549         * a new array.</p>
    3550         *
    3551         * <pre>
    3552         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3553         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3554         * ArrayUtils.addAll([], [])         = []
    3555         * </pre>
    3556         *
    3557         * @param array1  the first array whose elements are added to the new array.
    3558         * @param array2  the second array whose elements are added to the new array.
    3559         * @return The new int[] array.
    3560         * @since 2.1
    3561         */
    3562        public static int[] addAll(int[] array1, int[] array2) {
    3563            if (array1 == null) {
    3564                return clone(array2);
    3565            } else if (array2 == null) {
    3566                return clone(array1);
    3567            }
    3568            int[] joinedArray = new int[array1.length + array2.length];
    3569            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3570            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3571            return joinedArray;
    3572        }
    3573
    3574        /**
    3575         * <p>Adds all the elements of the given arrays into a new array.</p>
    3576         * <p>The new array contains all of the element of <code>array1</code> followed
    3577         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3578         * a new array.</p>
    3579         *
    3580         * <pre>
    3581         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3582         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3583         * ArrayUtils.addAll([], [])         = []
    3584         * </pre>
    3585         *
    3586         * @param array1  the first array whose elements are added to the new array.
    3587         * @param array2  the second array whose elements are added to the new array.
    3588         * @return The new long[] array.
    3589         * @since 2.1
    3590         */
    3591        public static long[] addAll(long[] array1, long[] array2) {
    3592            if (array1 == null) {
    3593                return clone(array2);
    3594            } else if (array2 == null) {
    3595                return clone(array1);
    3596            }
    3597            long[] joinedArray = new long[array1.length + array2.length];
    3598            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3599            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3600            return joinedArray;
    3601        }
    3602
    3603        /**
    3604         * <p>Adds all the elements of the given arrays into a new array.</p>
    3605         * <p>The new array contains all of the element of <code>array1</code> followed
    3606         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3607         * a new array.</p>
    3608         *
    3609         * <pre>
    3610         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3611         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3612         * ArrayUtils.addAll([], [])         = []
    3613         * </pre>
    3614         *
    3615         * @param array1  the first array whose elements are added to the new array.
    3616         * @param array2  the second array whose elements are added to the new array.
    3617         * @return The new float[] array.
    3618         * @since 2.1
    3619         */
    3620        public static float[] addAll(float[] array1, float[] array2) {
    3621            if (array1 == null) {
    3622                return clone(array2);
    3623            } else if (array2 == null) {
    3624                return clone(array1);
    3625            }
    3626            float[] joinedArray = new float[array1.length + array2.length];
    3627            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3628            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3629            return joinedArray;
    3630        }
    3631
    3632        /**
    3633         * <p>Adds all the elements of the given arrays into a new array.</p>
    3634         * <p>The new array contains all of the element of <code>array1</code> followed
    3635         * by all of the elements <code>array2</code>. When an array is returned, it is always
    3636         * a new array.</p>
    3637         *
    3638         * <pre>
    3639         * ArrayUtils.addAll(array1, null)   = cloned copy of array1
    3640         * ArrayUtils.addAll(null, array2)   = cloned copy of array2
    3641         * ArrayUtils.addAll([], [])         = []
    3642         * </pre>
    3643         *
    3644         * @param array1  the first array whose elements are added to the new array.
    3645         * @param array2  the second array whose elements are added to the new array.
    3646         * @return The new double[] array.
    3647         * @since 2.1
    3648         */
    3649        public static double[] addAll(double[] array1, double[] array2) {
    3650            if (array1 == null) {
    3651                return clone(array2);
    3652            } else if (array2 == null) {
    3653                return clone(array1);
    3654            }
    3655            double[] joinedArray = new double[array1.length + array2.length];
    3656            System.arraycopy(array1, 0, joinedArray, 0, array1.length);
    3657            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
    3658            return joinedArray;
    3659        }
    3660
    3661        /**
    3662         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3663         *
    3664         * <p>The new array contains the same elements of the input
    3665         * array plus the given element in the last position. The component type of
    3666         * the new array is the same as that of the input array.</p>
    3667         *
    3668         * <p>If the input array is <code>null</code>, a new one element array is returned
    3669         *  whose component type is the same as the element, unless the element itself is null,
    3670         *  in which case the return type is Object[]</p>
    3671         *
    3672         * <pre>
    3673         * ArrayUtils.add(null, null)      = [null]
    3674         * ArrayUtils.add(null, "a")       = ["a"]
    3675         * ArrayUtils.add(["a"], null)     = ["a", null]
    3676         * ArrayUtils.add(["a"], "b")      = ["a", "b"]
    3677         * ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"]
    3678         * </pre>
    3679         *
    3680         * @param array  the array to "add" the element to, may be <code>null</code>
    3681         * @param element  the object to add, may be <code>null</code>
    3682         * @return A new array containing the existing elements plus the new element
    3683         * The returned array type will be that of the input array (unless null),
    3684         * in which case it will have the same type as the element.
    3685         * @since 2.1
    3686         */
    3687        public static Object[] add(Object[] array, Object element) {
    3688            Class type;
    3689            if (array != null){
    3690                type = array.getClass();
    3691            } else if (element != null) {
    3692                type = element.getClass();
    3693            } else {
    3694                type = Object.class;
    3695            }
    3696            Object[] newArray = (Object[]) copyArrayGrow1(array, type);
    3697            newArray[newArray.length - 1] = element;
    3698            return newArray;
    3699        }
    3700
    3701        /**
    3702         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3703         *
    3704         * <p>The new array contains the same elements of the input
    3705         * array plus the given element in the last position. The component type of
    3706         * the new array is the same as that of the input array.</p>
    3707         *
    3708         * <p>If the input array is <code>null</code>, a new one element array is returned
    3709         *  whose component type is the same as the element.</p>
    3710         *
    3711         * <pre>
    3712         * ArrayUtils.add(null, true)          = [true]
    3713         * ArrayUtils.add([true], false)       = [true, false]
    3714         * ArrayUtils.add([true, false], true) = [true, false, true]
    3715         * </pre>
    3716         *
    3717         * @param array  the array to copy and add the element to, may be <code>null</code>
    3718         * @param element  the object to add at the last index of the new array
    3719         * @return A new array containing the existing elements plus the new element
    3720         * @since 2.1
    3721         */
    3722        public static boolean[] add(boolean[] array, boolean element) {
    3723            boolean[] newArray = (boolean[])copyArrayGrow1(array, Boolean.TYPE);
    3724            newArray[newArray.length - 1] = element;
    3725            return newArray;
    3726        }
    3727
    3728        /**
    3729         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3730         *
    3731         * <p>The new array contains the same elements of the input
    3732         * array plus the given element in the last position. The component type of
    3733         * the new array is the same as that of the input array.</p>
    3734         *
    3735         * <p>If the input array is <code>null</code>, a new one element array is returned
    3736         *  whose component type is the same as the element.</p>
    3737         *
    3738         * <pre>
    3739         * ArrayUtils.add(null, 0)   = [0]
    3740         * ArrayUtils.add([1], 0)    = [1, 0]
    3741         * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
    3742         * </pre>
    3743         *
    3744         * @param array  the array to copy and add the element to, may be <code>null</code>
    3745         * @param element  the object to add at the last index of the new array
    3746         * @return A new array containing the existing elements plus the new element
    3747         * @since 2.1
    3748         */
    3749        public static byte[] add(byte[] array, byte element) {
    3750            byte[] newArray = (byte[])copyArrayGrow1(array, Byte.TYPE);
    3751            newArray[newArray.length - 1] = element;
    3752            return newArray;
    3753        }
    3754
    3755        /**
    3756         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3757         *
    3758         * <p>The new array contains the same elements of the input
    3759         * array plus the given element in the last position. The component type of
    3760         * the new array is the same as that of the input array.</p>
    3761         *
    3762         * <p>If the input array is <code>null</code>, a new one element array is returned
    3763         *  whose component type is the same as the element.</p>
    3764         *
    3765         * <pre>
    3766         * ArrayUtils.add(null, '0')       = ['0']
    3767         * ArrayUtils.add(['1'], '0')      = ['1', '0']
    3768         * ArrayUtils.add(['1', '0'], '1') = ['1', '0', '1']
    3769         * </pre>
    3770         *
    3771         * @param array  the array to copy and add the element to, may be <code>null</code>
    3772         * @param element  the object to add at the last index of the new array
    3773         * @return A new array containing the existing elements plus the new element
    3774         * @since 2.1
    3775         */
    3776        public static char[] add(char[] array, char element) {
    3777            char[] newArray = (char[])copyArrayGrow1(array, Character.TYPE);
    3778            newArray[newArray.length - 1] = element;
    3779            return newArray;
    3780        }
    3781
    3782        /**
    3783         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3784         *
    3785         * <p>The new array contains the same elements of the input
    3786         * array plus the given element in the last position. The component type of
    3787         * the new array is the same as that of the input array.</p>
    3788         *
    3789         * <p>If the input array is <code>null</code>, a new one element array is returned
    3790         *  whose component type is the same as the element.</p>
    3791         *
    3792         * <pre>
    3793         * ArrayUtils.add(null, 0)   = [0]
    3794         * ArrayUtils.add([1], 0)    = [1, 0]
    3795         * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
    3796         * </pre>
    3797         *
    3798         * @param array  the array to copy and add the element to, may be <code>null</code>
    3799         * @param element  the object to add at the last index of the new array
    3800         * @return A new array containing the existing elements plus the new element
    3801         * @since 2.1
    3802         */
    3803        public static double[] add(double[] array, double element) {
    3804            double[] newArray = (double[])copyArrayGrow1(array, Double.TYPE);
    3805            newArray[newArray.length - 1] = element;
    3806            return newArray;
    3807        }
    3808
    3809        /**
    3810         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3811         *
    3812         * <p>The new array contains the same elements of the input
    3813         * array plus the given element in the last position. The component type of
    3814         * the new array is the same as that of the input array.</p>
    3815         *
    3816         * <p>If the input array is <code>null</code>, a new one element array is returned
    3817         *  whose component type is the same as the element.</p>
    3818         *
    3819         * <pre>
    3820         * ArrayUtils.add(null, 0)   = [0]
    3821         * ArrayUtils.add([1], 0)    = [1, 0]
    3822         * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
    3823         * </pre>
    3824         *
    3825         * @param array  the array to copy and add the element to, may be <code>null</code>
    3826         * @param element  the object to add at the last index of the new array
    3827         * @return A new array containing the existing elements plus the new element
    3828         * @since 2.1
    3829         */
    3830        public static float[] add(float[] array, float element) {
    3831            float[] newArray = (float[])copyArrayGrow1(array, Float.TYPE);
    3832            newArray[newArray.length - 1] = element;
    3833            return newArray;
    3834        }
    3835
    3836        /**
    3837         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3838         *
    3839         * <p>The new array contains the same elements of the input
    3840         * array plus the given element in the last position. The component type of
    3841         * the new array is the same as that of the input array.</p>
    3842         *
    3843         * <p>If the input array is <code>null</code>, a new one element array is returned
    3844         *  whose component type is the same as the element.</p>
    3845         *
    3846         * <pre>
    3847         * ArrayUtils.add(null, 0)   = [0]
    3848         * ArrayUtils.add([1], 0)    = [1, 0]
    3849         * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
    3850         * </pre>
    3851         *
    3852         * @param array  the array to copy and add the element to, may be <code>null</code>
    3853         * @param element  the object to add at the last index of the new array
    3854         * @return A new array containing the existing elements plus the new element
    3855         * @since 2.1
    3856         */
    3857        public static int[] add(int[] array, int element) {
    3858            int[] newArray = (int[])copyArrayGrow1(array, Integer.TYPE);
    3859            newArray[newArray.length - 1] = element;
    3860            return newArray;
    3861        }
    3862
    3863        /**
    3864         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3865         *
    3866         * <p>The new array contains the same elements of the input
    3867         * array plus the given element in the last position. The component type of
    3868         * the new array is the same as that of the input array.</p>
    3869         *
    3870         * <p>If the input array is <code>null</code>, a new one element array is returned
    3871         *  whose component type is the same as the element.</p>
    3872         *
    3873         * <pre>
    3874         * ArrayUtils.add(null, 0)   = [0]
    3875         * ArrayUtils.add([1], 0)    = [1, 0]
    3876         * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
    3877         * </pre>
    3878         *
    3879         * @param array  the array to copy and add the element to, may be <code>null</code>
    3880         * @param element  the object to add at the last index of the new array
    3881         * @return A new array containing the existing elements plus the new element
    3882         * @since 2.1
    3883         */
    3884        public static long[] add(long[] array, long element) {
    3885            long[] newArray = (long[])copyArrayGrow1(array, Long.TYPE);
    3886            newArray[newArray.length - 1] = element;
    3887            return newArray;
    3888        }
    3889
    3890        /**
    3891         * <p>Copies the given array and adds the given element at the end of the new array.</p>
    3892         *
    3893         * <p>The new array contains the same elements of the input
    3894         * array plus the given element in the last position. The component type of
    3895         * the new array is the same as that of the input array.</p>
    3896         *
    3897         * <p>If the input array is <code>null</code>, a new one element array is returned
    3898         *  whose component type is the same as the element.</p>
    3899         *
    3900         * <pre>
    3901         * ArrayUtils.add(null, 0)   = [0]
    3902         * ArrayUtils.add([1], 0)    = [1, 0]
    3903         * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
    3904         * </pre>
    3905         *
    3906         * @param array  the array to copy and add the element to, may be <code>null</code>
    3907         * @param element  the object to add at the last index of the new array
    3908         * @return A new array containing the existing elements plus the new element
    3909         * @since 2.1
    3910         */
    3911        public static short[] add(short[] array, short element) {
    3912            short[] newArray = (short[])copyArrayGrow1(array, Short.TYPE);
    3913            newArray[newArray.length - 1] = element;
    3914            return newArray;
    3915        }
    3916
    3917        /**
    3918         * Returns a copy of the given array of size 1 greater than the argument.
    3919         * The last value of the array is left to the default value.
    3920         *
    3921         * @param array The array to copy, must not be <code>null</code>.
    3922         * @param newArrayComponentType If <code>array</code> is <code>null</code>, create a
    3923         * size 1 array of this type.
    3924         * @return A new copy of the array of size 1 greater than the input.
    3925         */
    3926        private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
    3927            if (array != null) {
    3928                int arrayLength = Array.getLength(array);
    3929                Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
    3930                System.arraycopy(array, 0, newArray, 0, arrayLength);
    3931                return newArray;
    3932            }
    3933            return Array.newInstance(newArrayComponentType, 1);
    3934        }
    3935
    3936        /**
    3937         * <p>Inserts the specified element at the specified position in the array.
    3938         * Shifts the element currently at that position (if any) and any subsequent
    3939         * elements to the right (adds one to their indices).</p>
    3940         *
    3941         * <p>This method returns a new array with the same elements of the input
    3942         * array plus the given element on the specified position. The component
    3943         * type of the returned array is always the same as that of the input
    3944         * array.</p>
    3945         *
    3946         * <p>If the input array is <code>null</code>, a new one element array is returned
    3947         *  whose component type is the same as the element.</p>
    3948         *
    3949         * <pre>
    3950         * ArrayUtils.add(null, 0, null)      = [null]
    3951         * ArrayUtils.add(null, 0, "a")       = ["a"]
    3952         * ArrayUtils.add(["a"], 1, null)     = ["a", null]
    3953         * ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
    3954         * ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
    3955         * </pre>
    3956         *
    3957         * @param array  the array to add the element to, may be <code>null</code>
    3958         * @param index  the position of the new object
    3959         * @param element  the object to add
    3960         * @return A new array containing the existing elements and the new element
    3961         * @throws IndexOutOfBoundsException if the index is out of range
    3962         * (index < 0 || index > array.length).
    3963         */
    3964        public static Object[] add(Object[] array, int index, Object element) {
    3965            Class clss = null;
    3966            if (array != null) {
    3967                clss = array.getClass().getComponentType();
    3968            } else if (element != null) {
    3969                clss = element.getClass();
    3970            } else {
    3971                return new Object[]{null};
    3972            }
    3973            return (Object[]) add(array, index, element, clss);
    3974        }
    3975
    3976        /**
    3977         * <p>Inserts the specified element at the specified position in the array.
    3978         * Shifts the element currently at that position (if any) and any subsequent
    3979         * elements to the right (adds one to their indices).</p>
    3980         *
    3981         * <p>This method returns a new array with the same elements of the input
    3982         * array plus the given element on the specified position. The component
    3983         * type of the returned array is always the same as that of the input
    3984         * array.</p>
    3985         *
    3986         * <p>If the input array is <code>null</code>, a new one element array is returned
    3987         *  whose component type is the same as the element.</p>
    3988         *
    3989         * <pre>
    3990         * ArrayUtils.add(null, 0, true)          = [true]
    3991         * ArrayUtils.add([true], 0, false)       = [false, true]
    3992         * ArrayUtils.add([false], 1, true)       = [false, true]
    3993         * ArrayUtils.add([true, false], 1, true) = [true, true, false]
    3994         * </pre>
    3995         *
    3996         * @param array  the array to add the element to, may be <code>null</code>
    3997         * @param index  the position of the new object
    3998         * @param element  the object to add
    3999         * @return A new array containing the existing elements and the new element
    4000         * @throws IndexOutOfBoundsException if the index is out of range
    4001         * (index < 0 || index > array.length).
    4002         */
    4003        public static boolean[] add(boolean[] array, int index, boolean element) {
    4004            return (boolean[]) add(array, index, BooleanUtils.toBooleanObject(element), Boolean.TYPE);
    4005        }
    4006
    4007        /**
    4008         * <p>Inserts the specified element at the specified position in the array.
    4009         * Shifts the element currently at that position (if any) and any subsequent
    4010         * elements to the right (adds one to their indices).</p>
    4011         *
    4012         * <p>This method returns a new array with the same elements of the input
    4013         * array plus the given element on the specified position. The component
    4014         * type of the returned array is always the same as that of the input
    4015         * array.</p>
    4016         *
    4017         * <p>If the input array is <code>null</code>, a new one element array is returned
    4018         *  whose component type is the same as the element.</p>
    4019         *
    4020         * <pre>
    4021         * ArrayUtils.add(null, 0, 'a')            = ['a']
    4022         * ArrayUtils.add(['a'], 0, 'b')           = ['b', 'a']
    4023         * ArrayUtils.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']
    4024         * ArrayUtils.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']
    4025         * ArrayUtils.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
    4026         * </pre>
    4027         *
    4028         * @param array  the array to add the element to, may be <code>null</code>
    4029         * @param index  the position of the new object
    4030         * @param element  the object to add
    4031         * @return A new array containing the existing elements and the new element
    4032         * @throws IndexOutOfBoundsException if the index is out of range
    4033         * (index < 0 || index > array.length).
    4034         */
    4035        public static char[] add(char[] array, int index, char element) {
    4036            return (char[]) add(array, index, new Character(element), Character.TYPE);
    4037        }
    4038
    4039        /**
    4040         * <p>Inserts the specified element at the specified position in the array.
    4041         * Shifts the element currently at that position (if any) and any subsequent
    4042         * elements to the right (adds one to their indices).</p>
    4043         *
    4044         * <p>This method returns a new array with the same elements of the input
    4045         * array plus the given element on the specified position. The component
    4046         * type of the returned array is always the same as that of the input
    4047         * array.</p>
    4048         *
    4049         * <p>If the input array is <code>null</code>, a new one element array is returned
    4050         *  whose component type is the same as the element.</p>
    4051         *
    4052         * <pre>
    4053         * ArrayUtils.add([1], 0, 2)         = [2, 1]
    4054         * ArrayUtils.add([2, 6], 2, 3)      = [2, 6, 3]
    4055         * ArrayUtils.add([2, 6], 0, 1)      = [1, 2, 6]
    4056         * ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
    4057         * </pre>
    4058         *
    4059         * @param array  the array to add the element to, may be <code>null</code>
    4060         * @param index  the position of the new object
    4061         * @param element  the object to add
    4062         * @return A new array containing the existing elements and the new element
    4063         * @throws IndexOutOfBoundsException if the index is out of range
    4064         * (index < 0 || index > array.length).
    4065         */
    4066        public static byte[] add(byte[] array, int index, byte element) {
    4067            return (byte[]) add(array, index, new Byte(element), Byte.TYPE);
    4068        }
    4069
    4070        /**
    4071         * <p>Inserts the specified element at the specified position in the array.
    4072         * Shifts the element currently at that position (if any) and any subsequent
    4073         * elements to the right (adds one to their indices).</p>
    4074         *
    4075         * <p>This method returns a new array with the same elements of the input
    4076         * array plus the given element on the specified position. The component
    4077         * type of the returned array is always the same as that of the input
    4078         * array.</p>
    4079         *
    4080         * <p>If the input array is <code>null</code>, a new one element array is returned
    4081         *  whose component type is the same as the element.</p>
    4082         *
    4083         * <pre>
    4084         * ArrayUtils.add([1], 0, 2)         = [2, 1]
    4085         * ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
    4086         * ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
    4087         * ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
    4088         * </pre>
    4089         *
    4090         * @param array  the array to add the element to, may be <code>null</code>
    4091         * @param index  the position of the new object
    4092         * @param element  the object to add
    4093         * @return A new array containing the existing elements and the new element
    4094         * @throws IndexOutOfBoundsException if the index is out of range
    4095         * (index < 0 || index > array.length).
    4096         */
    4097        public static short[] add(short[] array, int index, short element) {
    4098            return (short[]) add(array, index, new Short(element), Short.TYPE);
    4099        }
    4100
    4101        /**
    4102         * <p>Inserts the specified element at the specified position in the array.
    4103         * Shifts the element currently at that position (if any) and any subsequent
    4104         * elements to the right (adds one to their indices).</p>
    4105         *
    4106         * <p>This method returns a new array with the same elements of the input
    4107         * array plus the given element on the specified position. The component
    4108         * type of the returned array is always the same as that of the input
    4109         * array.</p>
    4110         *
    4111         * <p>If the input array is <code>null</code>, a new one element array is returned
    4112         *  whose component type is the same as the element.</p>
    4113         *
    4114         * <pre>
    4115         * ArrayUtils.add([1], 0, 2)         = [2, 1]
    4116         * ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
    4117         * ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
    4118         * ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
    4119         * </pre>
    4120         *
    4121         * @param array  the array to add the element to, may be <code>null</code>
    4122         * @param index  the position of the new object
    4123         * @param element  the object to add
    4124         * @return A new array containing the existing elements and the new element
    4125         * @throws IndexOutOfBoundsException if the index is out of range
    4126         * (index < 0 || index > array.length).
    4127         */
    4128        public static int[] add(int[] array, int index, int element) {
    4129            return (int[]) add(array, index, new Integer(element), Integer.TYPE);
    4130        }
    4131
    4132        /**
    4133         * <p>Inserts the specified element at the specified position in the array.
    4134         * Shifts the element currently at that position (if any) and any subsequent
    4135         * elements to the right (adds one to their indices).</p>
    4136         *
    4137         * <p>This method returns a new array with the same elements of the input
    4138         * array plus the given element on the specified position. The component
    4139         * type of the returned array is always the same as that of the input
    4140         * array.</p>
    4141         *
    4142         * <p>If the input array is <code>null</code>, a new one element array is returned
    4143         *  whose component type is the same as the element.</p>
    4144         *
    4145         * <pre>
    4146         * ArrayUtils.add([1L], 0, 2L)           = [2L, 1L]
    4147         * ArrayUtils.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
    4148         * ArrayUtils.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
    4149         * ArrayUtils.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
    4150         * </pre>
    4151         *
    4152         * @param array  the array to add the element to, may be <code>null</code>
    4153         * @param index  the position of the new object
    4154         * @param element  the object to add
    4155         * @return A new array containing the existing elements and the new element
    4156         * @throws IndexOutOfBoundsException if the index is out of range
    4157         * (index < 0 || index > array.length).
    4158         */
    4159        public static long[] add(long[] array, int index, long element) {
    4160            return (long[]) add(array, index, new Long(element), Long.TYPE);
    4161        }
    4162
    4163        /**
    4164         * <p>Inserts the specified element at the specified position in the array.
    4165         * Shifts the element currently at that position (if any) and any subsequent
    4166         * elements to the right (adds one to their indices).</p>
    4167         *
    4168         * <p>This method returns a new array with the same elements of the input
    4169         * array plus the given element on the specified position. The component
    4170         * type of the returned array is always the same as that of the input
    4171         * array.</p>
    4172         *
    4173         * <p>If the input array is <code>null</code>, a new one element array is returned
    4174         *  whose component type is the same as the element.</p>
    4175         *
    4176         * <pre>
    4177         * ArrayUtils.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
    4178         * ArrayUtils.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
    4179         * ArrayUtils.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
    4180         * ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
    4181         * </pre>
    4182         *
    4183         * @param array  the array to add the element to, may be <code>null</code>
    4184         * @param index  the position of the new object
    4185         * @param element  the object to add
    4186         * @return A new array containing the existing elements and the new element
    4187         * @throws IndexOutOfBoundsException if the index is out of range
    4188         * (index < 0 || index > array.length).
    4189         */
    4190        public static float[] add(float[] array, int index, float element) {
    4191            return (float[]) add(array, index, new Float(element), Float.TYPE);
    4192        }
    4193
    4194        /**
    4195         * <p>Inserts the specified element at the specified position in the array.
    4196         * Shifts the element currently at that position (if any) and any subsequent
    4197         * elements to the right (adds one to their indices).</p>
    4198         *
    4199         * <p>This method returns a new array with the same elements of the input
    4200         * array plus the given element on the specified position. The component
    4201         * type of the returned array is always the same as that of the input
    4202         * array.</p>
    4203         *
    4204         * <p>If the input array is <code>null</code>, a new one element array is returned
    4205         *  whose component type is the same as the element.</p>
    4206         *
    4207         * <pre>
    4208         * ArrayUtils.add([1.1], 0, 2.2)              = [2.2, 1.1]
    4209         * ArrayUtils.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
    4210         * ArrayUtils.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
    4211         * ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
    4212         * </pre>
    4213         *
    4214         * @param array  the array to add the element to, may be <code>null</code>
    4215         * @param index  the position of the new object
    4216         * @param element  the object to add
    4217         * @return A new array containing the existing elements and the new element
    4218         * @throws IndexOutOfBoundsException if the index is out of range
    4219         * (index < 0 || index > array.length).
    4220         */
    4221        public static double[] add(double[] array, int index, double element) {
    4222            return (double[]) add(array, index, new Double(element), Double.TYPE);
    4223        }
    4224
    4225        /**
    4226         * Underlying implementation of add(array, index, element) methods.
    4227         * The last parameter is the class, which may not equal element.getClass
    4228         * for primitives.
    4229         *
    4230         * @param array  the array to add the element to, may be <code>null</code>
    4231         * @param index  the position of the new object
    4232         * @param element  the object to add
    4233         * @param clss the type of the element being added
    4234         * @return A new array containing the existing elements and the new element
    4235         */
    4236        private static Object add(Object array, int index, Object element, Class clss) {
    4237            if (array == null) {
    4238                if (index != 0) {
    4239                    throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
    4240                }
    4241                Object joinedArray = Array.newInstance(clss, 1);
    4242                Array.set(joinedArray, 0, element);
    4243                return joinedArray;
    4244            }
    4245            int length = Array.getLength(array);
    4246            if (index > length || index < 0) {
    4247                throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
    4248            }
    4249            Object result = Array.newInstance(clss, length + 1);
    4250            System.arraycopy(array, 0, result, 0, index);
    4251            Array.set(result, index, element);
    4252            if (index < length) {
    4253                System.arraycopy(array, index, result, index + 1, length - index);
    4254            }
    4255            return result;
    4256        }
    4257
    4258        /**
    4259         * <p>Removes the element at the specified position from the specified array.
    4260         * All subsequent elements are shifted to the left (substracts one from
    4261         * their indices).</p>
    4262         *
    4263         * <p>This method returns a new array with the same elements of the input
    4264         * array except the element on the specified position. The component
    4265         * type of the returned array is always the same as that of the input
    4266         * array.</p>
    4267         *
    4268         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4269         * will be thrown, because in that case no valid index can be specified.</p>
    4270         *
    4271         * <pre>
    4272         * ArrayUtils.remove(["a"], 0)           = []
    4273         * ArrayUtils.remove(["a", "b"], 0)      = ["b"]
    4274         * ArrayUtils.remove(["a", "b"], 1)      = ["a"]
    4275         * ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]
    4276         * </pre>
    4277         *
    4278         * @param array  the array to remove the element from, may not be <code>null</code>
    4279         * @param index  the position of the element to be removed
    4280         * @return A new array containing the existing elements except the element
    4281         *         at the specified position.
    4282         * @throws IndexOutOfBoundsException if the index is out of range
    4283         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4284         * @since 2.1
    4285         */
    4286        public static Object[] remove(Object[] array, int index) {
    4287            return (Object[]) remove((Object) array, index);
    4288        }
    4289
    4290        /**
    4291         * <p>Removes the first occurrence of the specified element from the
    4292         * specified array. All subsequent elements are shifted to the left
    4293         * (substracts one from their indices). If the array doesn't contains
    4294         * such an element, no elements are removed from the array.</p>
    4295         *
    4296         * <p>This method returns a new array with the same elements of the input
    4297         * array except the first occurrence of the specified element. The component
    4298         * type of the returned array is always the same as that of the input
    4299         * array.</p>
    4300         *
    4301         * <pre>
    4302         * ArrayUtils.removeElement(null, "a")            = null
    4303         * ArrayUtils.removeElement([], "a")              = []
    4304         * ArrayUtils.removeElement(["a"], "b")           = ["a"]
    4305         * ArrayUtils.removeElement(["a", "b"], "a")      = ["b"]
    4306         * ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"]
    4307         * </pre>
    4308         *
    4309         * @param array  the array to remove the element from, may be <code>null</code>
    4310         * @param element  the element to be removed
    4311         * @return A new array containing the existing elements except the first
    4312         *         occurrence of the specified element.
    4313         * @since 2.1
    4314         */
    4315        public static Object[] removeElement(Object[] array, Object element) {
    4316            int index = indexOf(array, element);
    4317            if (index == INDEX_NOT_FOUND) {
    4318                return clone(array);
    4319            }
    4320            return remove(array, index);
    4321        }
    4322
    4323        /**
    4324         * <p>Removes the element at the specified position from the specified array.
    4325         * All subsequent elements are shifted to the left (substracts one from
    4326         * their indices).</p>
    4327         *
    4328         * <p>This method returns a new array with the same elements of the input
    4329         * array except the element on the specified position. The component
    4330         * type of the returned array is always the same as that of the input
    4331         * array.</p>
    4332         *
    4333         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4334         * will be thrown, because in that case no valid index can be specified.</p>
    4335         *
    4336         * <pre>
    4337         * ArrayUtils.remove([true], 0)              = []
    4338         * ArrayUtils.remove([true, false], 0)       = [false]
    4339         * ArrayUtils.remove([true, false], 1)       = [true]
    4340         * ArrayUtils.remove([true, true, false], 1) = [true, false]
    4341         * </pre>
    4342         *
    4343         * @param array  the array to remove the element from, may not be <code>null</code>
    4344         * @param index  the position of the element to be removed
    4345         * @return A new array containing the existing elements except the element
    4346         *         at the specified position.
    4347         * @throws IndexOutOfBoundsException if the index is out of range
    4348         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4349         * @since 2.1
    4350         */
    4351        public static boolean[] remove(boolean[] array, int index) {
    4352            return (boolean[]) remove((Object) array, index);
    4353        }
    4354
    4355        /**
    4356         * <p>Removes the first occurrence of the specified element from the
    4357         * specified array. All subsequent elements are shifted to the left
    4358         * (substracts one from their indices). If the array doesn't contains
    4359         * such an element, no elements are removed from the array.</p>
    4360         *
    4361         * <p>This method returns a new array with the same elements of the input
    4362         * array except the first occurrence of the specified element. The component
    4363         * type of the returned array is always the same as that of the input
    4364         * array.</p>
    4365         *
    4366         * <pre>
    4367         * ArrayUtils.removeElement(null, true)                = null
    4368         * ArrayUtils.removeElement([], true)                  = []
    4369         * ArrayUtils.removeElement([true], false)             = [true]
    4370         * ArrayUtils.removeElement([true, false], false)      = [true]
    4371         * ArrayUtils.removeElement([true, false, true], true) = [false, true]
    4372         * </pre>
    4373         *
    4374         * @param array  the array to remove the element from, may be <code>null</code>
    4375         * @param element  the element to be removed
    4376         * @return A new array containing the existing elements except the first
    4377         *         occurrence of the specified element.
    4378         * @since 2.1
    4379         */
    4380        public static boolean[] removeElement(boolean[] array, boolean element) {
    4381            int index = indexOf(array, element);
    4382            if (index == INDEX_NOT_FOUND) {
    4383                return clone(array);
    4384            }
    4385            return remove(array, index);
    4386        }
    4387
    4388        /**
    4389         * <p>Removes the element at the specified position from the specified array.
    4390         * All subsequent elements are shifted to the left (substracts one from
    4391         * their indices).</p>
    4392         *
    4393         * <p>This method returns a new array with the same elements of the input
    4394         * array except the element on the specified position. The component
    4395         * type of the returned array is always the same as that of the input
    4396         * array.</p>
    4397         *
    4398         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4399         * will be thrown, because in that case no valid index can be specified.</p>
    4400         *
    4401         * <pre>
    4402         * ArrayUtils.remove([1], 0)          = []
    4403         * ArrayUtils.remove([1, 0], 0)       = [0]
    4404         * ArrayUtils.remove([1, 0], 1)       = [1]
    4405         * ArrayUtils.remove([1, 0, 1], 1)    = [1, 1]
    4406         * </pre>
    4407         *
    4408         * @param array  the array to remove the element from, may not be <code>null</code>
    4409         * @param index  the position of the element to be removed
    4410         * @return A new array containing the existing elements except the element
    4411         *         at the specified position.
    4412         * @throws IndexOutOfBoundsException if the index is out of range
    4413         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4414         * @since 2.1
    4415         */
    4416        public static byte[] remove(byte[] array, int index) {
    4417            return (byte[]) remove((Object) array, index);
    4418        }
    4419
    4420        /**
    4421         * <p>Removes the first occurrence of the specified element from the
    4422         * specified array. All subsequent elements are shifted to the left
    4423         * (substracts one from their indices). If the array doesn't contains
    4424         * such an element, no elements are removed from the array.</p>
    4425         *
    4426         * <p>This method returns a new array with the same elements of the input
    4427         * array except the first occurrence of the specified element. The component
    4428         * type of the returned array is always the same as that of the input
    4429         * array.</p>
    4430         *
    4431         * <pre>
    4432         * ArrayUtils.removeElement(null, 1)        = null
    4433         * ArrayUtils.removeElement([], 1)          = []
    4434         * ArrayUtils.removeElement([1], 0)         = [1]
    4435         * ArrayUtils.removeElement([1, 0], 0)      = [1]
    4436         * ArrayUtils.removeElement([1, 0, 1], 1)   = [0, 1]
    4437         * </pre>
    4438         *
    4439         * @param array  the array to remove the element from, may be <code>null</code>
    4440         * @param element  the element to be removed
    4441         * @return A new array containing the existing elements except the first
    4442         *         occurrence of the specified element.
    4443         * @since 2.1
    4444         */
    4445        public static byte[] removeElement(byte[] array, byte element) {
    4446            int index = indexOf(array, element);
    4447            if (index == INDEX_NOT_FOUND) {
    4448                return clone(array);
    4449            }
    4450            return remove(array, index);
    4451        }
    4452
    4453        /**
    4454         * <p>Removes the element at the specified position from the specified array.
    4455         * All subsequent elements are shifted to the left (substracts one from
    4456         * their indices).</p>
    4457         *
    4458         * <p>This method returns a new array with the same elements of the input
    4459         * array except the element on the specified position. The component
    4460         * type of the returned array is always the same as that of the input
    4461         * array.</p>
    4462         *
    4463         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4464         * will be thrown, because in that case no valid index can be specified.</p>
    4465         *
    4466         * <pre>
    4467         * ArrayUtils.remove(['a'], 0)           = []
    4468         * ArrayUtils.remove(['a', 'b'], 0)      = ['b']
    4469         * ArrayUtils.remove(['a', 'b'], 1)      = ['a']
    4470         * ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c']
    4471         * </pre>
    4472         *
    4473         * @param array  the array to remove the element from, may not be <code>null</code>
    4474         * @param index  the position of the element to be removed
    4475         * @return A new array containing the existing elements except the element
    4476         *         at the specified position.
    4477         * @throws IndexOutOfBoundsException if the index is out of range
    4478         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4479         * @since 2.1
    4480         */
    4481        public static char[] remove(char[] array, int index) {
    4482            return (char[]) remove((Object) array, index);
    4483        }
    4484
    4485        /**
    4486         * <p>Removes the first occurrence of the specified element from the
    4487         * specified array. All subsequent elements are shifted to the left
    4488         * (substracts one from their indices). If the array doesn't contains
    4489         * such an element, no elements are removed from the array.</p>
    4490         *
    4491         * <p>This method returns a new array with the same elements of the input
    4492         * array except the first occurrence of the specified element. The component
    4493         * type of the returned array is always the same as that of the input
    4494         * array.</p>
    4495         *
    4496         * <pre>
    4497         * ArrayUtils.removeElement(null, 'a')            = null
    4498         * ArrayUtils.removeElement([], 'a')              = []
    4499         * ArrayUtils.removeElement(['a'], 'b')           = ['a']
    4500         * ArrayUtils.removeElement(['a', 'b'], 'a')      = ['b']
    4501         * ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
    4502         * </pre>
    4503         *
    4504         * @param array  the array to remove the element from, may be <code>null</code>
    4505         * @param element  the element to be removed
    4506         * @return A new array containing the existing elements except the first
    4507         *         occurrence of the specified element.
    4508         * @since 2.1
    4509         */
    4510        public static char[] removeElement(char[] array, char element) {
    4511            int index = indexOf(array, element);
    4512            if (index == INDEX_NOT_FOUND) {
    4513                return clone(array);
    4514            }
    4515            return remove(array, index);
    4516        }
    4517
    4518        /**
    4519         * <p>Removes the element at the specified position from the specified array.
    4520         * All subsequent elements are shifted to the left (substracts one from
    4521         * their indices).</p>
    4522         *
    4523         * <p>This method returns a new array with the same elements of the input
    4524         * array except the element on the specified position. The component
    4525         * type of the returned array is always the same as that of the input
    4526         * array.</p>
    4527         *
    4528         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4529         * will be thrown, because in that case no valid index can be specified.</p>
    4530         *
    4531         * <pre>
    4532         * ArrayUtils.remove([1.1], 0)           = []
    4533         * ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]
    4534         * ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]
    4535         * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
    4536         * </pre>
    4537         *
    4538         * @param array  the array to remove the element from, may not be <code>null</code>
    4539         * @param index  the position of the element to be removed
    4540         * @return A new array containing the existing elements except the element
    4541         *         at the specified position.
    4542         * @throws IndexOutOfBoundsException if the index is out of range
    4543         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4544         * @since 2.1
    4545         */
    4546        public static double[] remove(double[] array, int index) {
    4547            return (double[]) remove((Object) array, index);
    4548        }
    4549
    4550        /**
    4551         * <p>Removes the first occurrence of the specified element from the
    4552         * specified array. All subsequent elements are shifted to the left
    4553         * (substracts one from their indices). If the array doesn't contains
    4554         * such an element, no elements are removed from the array.</p>
    4555         *
    4556         * <p>This method returns a new array with the same elements of the input
    4557         * array except the first occurrence of the specified element. The component
    4558         * type of the returned array is always the same as that of the input
    4559         * array.</p>
    4560         *
    4561         * <pre>
    4562         * ArrayUtils.removeElement(null, 1.1)            = null
    4563         * ArrayUtils.removeElement([], 1.1)              = []
    4564         * ArrayUtils.removeElement([1.1], 1.2)           = [1.1]
    4565         * ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]
    4566         * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
    4567         * </pre>
    4568         *
    4569         * @param array  the array to remove the element from, may be <code>null</code>
    4570         * @param element  the element to be removed
    4571         * @return A new array containing the existing elements except the first
    4572         *         occurrence of the specified element.
    4573         * @since 2.1
    4574         */
    4575        public static double[] removeElement(double[] array, double element) {
    4576            int index = indexOf(array, element);
    4577            if (index == INDEX_NOT_FOUND) {
    4578                return clone(array);
    4579            }
    4580            return remove(array, index);
    4581        }
    4582
    4583        /**
    4584         * <p>Removes the element at the specified position from the specified array.
    4585         * All subsequent elements are shifted to the left (substracts one from
    4586         * their indices).</p>
    4587         *
    4588         * <p>This method returns a new array with the same elements of the input
    4589         * array except the element on the specified position. The component
    4590         * type of the returned array is always the same as that of the input
    4591         * array.</p>
    4592         *
    4593         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4594         * will be thrown, because in that case no valid index can be specified.</p>
    4595         *
    4596         * <pre>
    4597         * ArrayUtils.remove([1.1], 0)           = []
    4598         * ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]
    4599         * ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]
    4600         * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
    4601         * </pre>
    4602         *
    4603         * @param array  the array to remove the element from, may not be <code>null</code>
    4604         * @param index  the position of the element to be removed
    4605         * @return A new array containing the existing elements except the element
    4606         *         at the specified position.
    4607         * @throws IndexOutOfBoundsException if the index is out of range
    4608         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4609         * @since 2.1
    4610         */
    4611        public static float[] remove(float[] array, int index) {
    4612            return (float[]) remove((Object) array, index);
    4613        }
    4614
    4615        /**
    4616         * <p>Removes the first occurrence of the specified element from the
    4617         * specified array. All subsequent elements are shifted to the left
    4618         * (substracts one from their indices). If the array doesn't contains
    4619         * such an element, no elements are removed from the array.</p>
    4620         *
    4621         * <p>This method returns a new array with the same elements of the input
    4622         * array except the first occurrence of the specified element. The component
    4623         * type of the returned array is always the same as that of the input
    4624         * array.</p>
    4625         *
    4626         * <pre>
    4627         * ArrayUtils.removeElement(null, 1.1)            = null
    4628         * ArrayUtils.removeElement([], 1.1)              = []
    4629         * ArrayUtils.removeElement([1.1], 1.2)           = [1.1]
    4630         * ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]
    4631         * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
    4632         * </pre>
    4633         *
    4634         * @param array  the array to remove the element from, may be <code>null</code>
    4635         * @param element  the element to be removed
    4636         * @return A new array containing the existing elements except the first
    4637         *         occurrence of the specified element.
    4638         * @since 2.1
    4639         */
    4640        public static float[] removeElement(float[] array, float element) {
    4641            int index = indexOf(array, element);
    4642            if (index == INDEX_NOT_FOUND) {
    4643                return clone(array);
    4644            }
    4645            return remove(array, index);
    4646        }
    4647
    4648        /**
    4649         * <p>Removes the element at the specified position from the specified array.
    4650         * All subsequent elements are shifted to the left (substracts one from
    4651         * their indices).</p>
    4652         *
    4653         * <p>This method returns a new array with the same elements of the input
    4654         * array except the element on the specified position. The component
    4655         * type of the returned array is always the same as that of the input
    4656         * array.</p>
    4657         *
    4658         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4659         * will be thrown, because in that case no valid index can be specified.</p>
    4660         *
    4661         * <pre>
    4662         * ArrayUtils.remove([1], 0)         = []
    4663         * ArrayUtils.remove([2, 6], 0)      = [6]
    4664         * ArrayUtils.remove([2, 6], 1)      = [2]
    4665         * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
    4666         * </pre>
    4667         *
    4668         * @param array  the array to remove the element from, may not be <code>null</code>
    4669         * @param index  the position of the element to be removed
    4670         * @return A new array containing the existing elements except the element
    4671         *         at the specified position.
    4672         * @throws IndexOutOfBoundsException if the index is out of range
    4673         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4674         * @since 2.1
    4675         */
    4676        public static int[] remove(int[] array, int index) {
    4677            return (int[]) remove((Object) array, index);
    4678        }
    4679
    4680        /**
    4681         * <p>Removes the first occurrence of the specified element from the
    4682         * specified array. All subsequent elements are shifted to the left
    4683         * (substracts one from their indices). If the array doesn't contains
    4684         * such an element, no elements are removed from the array.</p>
    4685         *
    4686         * <p>This method returns a new array with the same elements of the input
    4687         * array except the first occurrence of the specified element. The component
    4688         * type of the returned array is always the same as that of the input
    4689         * array.</p>
    4690         *
    4691         * <pre>
    4692         * ArrayUtils.removeElement(null, 1)      = null
    4693         * ArrayUtils.removeElement([], 1)        = []
    4694         * ArrayUtils.removeElement([1], 2)       = [1]
    4695         * ArrayUtils.removeElement([1, 3], 1)    = [3]
    4696         * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
    4697         * </pre>
    4698         *
    4699         * @param array  the array to remove the element from, may be <code>null</code>
    4700         * @param element  the element to be removed
    4701         * @return A new array containing the existing elements except the first
    4702         *         occurrence of the specified element.
    4703         * @since 2.1
    4704         */
    4705        public static int[] removeElement(int[] array, int element) {
    4706            int index = indexOf(array, element);
    4707            if (index == INDEX_NOT_FOUND) {
    4708                return clone(array);
    4709            }
    4710            return remove(array, index);
    4711        }
    4712
    4713        /**
    4714         * <p>Removes the element at the specified position from the specified array.
    4715         * All subsequent elements are shifted to the left (substracts one from
    4716         * their indices).</p>
    4717         *
    4718         * <p>This method returns a new array with the same elements of the input
    4719         * array except the element on the specified position. The component
    4720         * type of the returned array is always the same as that of the input
    4721         * array.</p>
    4722         *
    4723         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4724         * will be thrown, because in that case no valid index can be specified.</p>
    4725         *
    4726         * <pre>
    4727         * ArrayUtils.remove([1], 0)         = []
    4728         * ArrayUtils.remove([2, 6], 0)      = [6]
    4729         * ArrayUtils.remove([2, 6], 1)      = [2]
    4730         * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
    4731         * </pre>
    4732         *
    4733         * @param array  the array to remove the element from, may not be <code>null</code>
    4734         * @param index  the position of the element to be removed
    4735         * @return A new array containing the existing elements except the element
    4736         *         at the specified position.
    4737         * @throws IndexOutOfBoundsException if the index is out of range
    4738         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4739         * @since 2.1
    4740         */
    4741        public static long[] remove(long[] array, int index) {
    4742            return (long[]) remove((Object) array, index);
    4743        }
    4744
    4745        /**
    4746         * <p>Removes the first occurrence of the specified element from the
    4747         * specified array. All subsequent elements are shifted to the left
    4748         * (substracts one from their indices). If the array doesn't contains
    4749         * such an element, no elements are removed from the array.</p>
    4750         *
    4751         * <p>This method returns a new array with the same elements of the input
    4752         * array except the first occurrence of the specified element. The component
    4753         * type of the returned array is always the same as that of the input
    4754         * array.</p>
    4755         *
    4756         * <pre>
    4757         * ArrayUtils.removeElement(null, 1)      = null
    4758         * ArrayUtils.removeElement([], 1)        = []
    4759         * ArrayUtils.removeElement([1], 2)       = [1]
    4760         * ArrayUtils.removeElement([1, 3], 1)    = [3]
    4761         * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
    4762         * </pre>
    4763         *
    4764         * @param array  the array to remove the element from, may be <code>null</code>
    4765         * @param element  the element to be removed
    4766         * @return A new array containing the existing elements except the first
    4767         *         occurrence of the specified element.
    4768         * @since 2.1
    4769         */
    4770        public static long[] removeElement(long[] array, long element) {
    4771            int index = indexOf(array, element);
    4772            if (index == INDEX_NOT_FOUND) {
    4773                return clone(array);
    4774            }
    4775            return remove(array, index);
    4776        }
    4777
    4778        /**
    4779         * <p>Removes the element at the specified position from the specified array.
    4780         * All subsequent elements are shifted to the left (substracts one from
    4781         * their indices).</p>
    4782         *
    4783         * <p>This method returns a new array with the same elements of the input
    4784         * array except the element on the specified position. The component
    4785         * type of the returned array is always the same as that of the input
    4786         * array.</p>
    4787         *
    4788         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4789         * will be thrown, because in that case no valid index can be specified.</p>
    4790         *
    4791         * <pre>
    4792         * ArrayUtils.remove([1], 0)         = []
    4793         * ArrayUtils.remove([2, 6], 0)      = [6]
    4794         * ArrayUtils.remove([2, 6], 1)      = [2]
    4795         * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
    4796         * </pre>
    4797         *
    4798         * @param array  the array to remove the element from, may not be <code>null</code>
    4799         * @param index  the position of the element to be removed
    4800         * @return A new array containing the existing elements except the element
    4801         *         at the specified position.
    4802         * @throws IndexOutOfBoundsException if the index is out of range
    4803         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4804         * @since 2.1
    4805         */
    4806        public static short[] remove(short[] array, int index) {
    4807            return (short[]) remove((Object) array, index);
    4808        }
    4809
    4810        /**
    4811         * <p>Removes the first occurrence of the specified element from the
    4812         * specified array. All subsequent elements are shifted to the left
    4813         * (substracts one from their indices). If the array doesn't contains
    4814         * such an element, no elements are removed from the array.</p>
    4815         *
    4816         * <p>This method returns a new array with the same elements of the input
    4817         * array except the first occurrence of the specified element. The component
    4818         * type of the returned array is always the same as that of the input
    4819         * array.</p>
    4820         *
    4821         * <pre>
    4822         * ArrayUtils.removeElement(null, 1)      = null
    4823         * ArrayUtils.removeElement([], 1)        = []
    4824         * ArrayUtils.removeElement([1], 2)       = [1]
    4825         * ArrayUtils.removeElement([1, 3], 1)    = [3]
    4826         * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
    4827         * </pre>
    4828         *
    4829         * @param array  the array to remove the element from, may be <code>null</code>
    4830         * @param element  the element to be removed
    4831         * @return A new array containing the existing elements except the first
    4832         *         occurrence of the specified element.
    4833         * @since 2.1
    4834         */
    4835        public static short[] removeElement(short[] array, short element) {
    4836            int index = indexOf(array, element);
    4837            if (index == INDEX_NOT_FOUND) {
    4838                return clone(array);
    4839            }
    4840            return remove(array, index);
    4841        }
    4842
    4843        /**
    4844         * <p>Removes the element at the specified position from the specified array.
    4845         * All subsequent elements are shifted to the left (substracts one from
    4846         * their indices).</p>
    4847         *
    4848         * <p>This method returns a new array with the same elements of the input
    4849         * array except the element on the specified position. The component
    4850         * type of the returned array is always the same as that of the input
    4851         * array.</p>
    4852         *
    4853         * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
    4854         * will be thrown, because in that case no valid index can be specified.</p>
    4855         *
    4856         * @param array  the array to remove the element from, may not be <code>null</code>
    4857         * @param index  the position of the element to be removed
    4858         * @return A new array containing the existing elements except the element
    4859         *         at the specified position.
    4860         * @throws IndexOutOfBoundsException if the index is out of range
    4861         * (index < 0 || index >= array.length), or if the array is <code>null</code>.
    4862         * @since 2.1
    4863         */
    4864        private static Object remove(Object array, int index) {
    4865            int length = getLength(array);
    4866            if (index < 0 || index >= length) {
    4867                throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
    4868            }
    4869
    4870            Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
    4871            System.arraycopy(array, 0, result, 0, index);
    4872            if (index < length - 1) {
    4873                System.arraycopy(array, index + 1, result, index, length - index - 1);
    4874            }
    4875
    4876            return result;
    4877        }
    4878
    4879    }