Java tutorial
//package com.java2s; /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import java.lang.reflect.Array; public class Main { /** * <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</code> followed * by all of the elements <code>array2</code>. 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 array1 the first array whose elements are added to the new array, may be <code>null</code> * @param array2 the second array whose elements are added to the new array, may be <code>null</code> * @return The new array, <code>null</code> if both arrays are <code>null</code>. * 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 */ public static Object[] addAll(Object[] array1, Object[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } Object[] joinedArray = (Object[]) Array.newInstance(array1.getClass().getComponentType(), 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 type1 = array1.getClass().getComponentType(); final Class type2 = array2.getClass().getComponentType(); if (!type1.isAssignableFrom(type2)) { throw new IllegalArgumentException( "Cannot store " + type2.getName() + " in an array of " + type1.getName()); } 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new boolean[] array. * @since 2.1 */ public static boolean[] addAll(boolean[] array1, boolean[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } boolean[] joinedArray = new boolean[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new char[] array. * @since 2.1 */ public static char[] addAll(char[] array1, char[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } char[] joinedArray = new char[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new byte[] array. * @since 2.1 */ public static byte[] addAll(byte[] array1, byte[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } byte[] joinedArray = new byte[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new short[] array. * @since 2.1 */ public static short[] addAll(short[] array1, short[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } short[] joinedArray = new short[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new int[] array. * @since 2.1 */ public static int[] addAll(int[] array1, int[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } int[] joinedArray = new int[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new long[] array. * @since 2.1 */ public static long[] addAll(long[] array1, long[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } long[] joinedArray = new long[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new float[] array. * @since 2.1 */ public static float[] addAll(float[] array1, float[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } float[] joinedArray = new float[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 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</code> followed * by all of the elements <code>array2</code>. When an array is returned, it is always * a new array.</p> * * <pre> * ArrayUtils.addAll(array1, null) = cloned copy of array1 * ArrayUtils.addAll(null, array2) = cloned copy of array2 * ArrayUtils.addAll([], []) = [] * </pre> * * @param array1 the first array whose elements are added to the new array. * @param array2 the second array whose elements are added to the new array. * @return The new double[] array. * @since 2.1 */ public static double[] addAll(double[] array1, double[] array2) { if (array1 == null) { return clone(array2); } else if (array2 == null) { return clone(array1); } double[] joinedArray = new double[array1.length + array2.length]; System.arraycopy(array1, 0, joinedArray, 0, array1.length); System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); return joinedArray; } /** * <p>Shallow clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to shallow clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static Object[] clone(Object[] array) { if (array == null) { return null; } return (Object[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static long[] clone(long[] array) { if (array == null) { return null; } return (long[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static int[] clone(int[] array) { if (array == null) { return null; } return (int[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static short[] clone(short[] array) { if (array == null) { return null; } return (short[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static char[] clone(char[] array) { if (array == null) { return null; } return (char[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static byte[] clone(byte[] array) { if (array == null) { return null; } return (byte[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static double[] clone(double[] array) { if (array == null) { return null; } return (double[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static float[] clone(float[] array) { if (array == null) { return null; } return (float[]) array.clone(); } /** * <p>Clones an array returning a typecast result and handling * <code>null</code>.</p> * * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> * * @param array the array to clone, may be <code>null</code> * @return the cloned array, <code>null</code> if <code>null</code> input */ public static boolean[] clone(boolean[] array) { if (array == null) { return null; } return (boolean[]) array.clone(); } }