public static <T> T[] addAll(T[] array1, T... array2) {
        if (array1 == null) {
            return clone(array2);
        } else if (array2 == null) {
            return clone(array1);
        }
        final Class<?> type1 = array1.getClass().getComponentType();
        @SuppressWarnings("unchecked") // OK, because array is of type T
        T[] joinedArray = (T[]) Array.newInstance(type1, array1.length + array2.length);
        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
        try {
            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
        } catch (ArrayStoreException ase) {
            // Check if problem was due to incompatible types
            /*
             * We do this here, rather than before the copy because:
             * - it would be a wasted check most of the time
             * - safer, in case check turns out to be too strict
             */
            final Class<?> type2 = array2.getClass().getComponentType();
            if (!type1.isAssignableFrom(type2)){
                throw new IllegalArgumentException("Cannot store "+type2.getName()+" in an array of "
                        +type1.getName(), ase);
            }
            throw ase; // No, so rethrow original
        }
        return joinedArray;
    }
<p>Adds all the elements of the given arrays into a new array.</p>
<p>The new array contains all of the element of {@code array1} followed
by all of the elements {@code array2}. When an array is returned, it is always
a new array.</p>

<pre>
ArrayUtils.addAll(null, null)     = null
ArrayUtils.addAll(array1, null)   = cloned copy of array1
ArrayUtils.addAll(null, array2)   = cloned copy of array2
ArrayUtils.addAll([], [])         = []
ArrayUtils.addAll([null], [null]) = [null, null]
ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
</pre>

@param <T> the component type of the array
@param array1  the first array whose elements are added to the new array, may be {@code null}
@param array2  the second array whose elements are added to the new array, may be {@code null}
@return The new array, {@code null} if both arrays are {@code null}.
     The type of the new array is the type of the first array,
     unless the first array is null, in which case the type is the same as the second array.
@since 2.1
@throws IllegalArgumentException if the array types are incompatible
android/android_framework/base/src/main/java/lang3/ArrayUtils.java