java学习--工具类学习之Arrays（1）

Integer[] array = new Integer[]{1,2,3};
int[] array2 = new int[]{1,2,3};
List list1 = Arrays.asList(1,2,3);
List list2 = Arrays.asList(array);
Listint[]> list3 = Arrays.asList(array2);

int[] array = new int[]{1,2,3};
Arrays.fill(array, 1);
Arrays.fill(array, 0, 2, 1);//  {1,1,3}
String[] str = {"123"};
Arrays.fill(str, "1");

    /**
     * Assigns the specified double value to each element of the specified
     * range of the specified array of doubles.  The range to be filled
     * extends from index fromIndex, inclusive, to index
     * toIndex, exclusive.  (If fromIndex==toIndex, the
     * range to be filled is empty.)
     *
     * @param a the array to be filled
     * @param fromIndex the index of the first element (inclusive) to be
     *        filled with the specified value
     * @param toIndex the index of the last element (exclusive) to be
     *        filled with the specified value
     * @param val the value to be stored in all elements of the array
     * @throws IllegalArgumentException if fromIndex > toIndex
     * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or
     *         toIndex > a.length
     */
    public static void fill(double[] a, int fromIndex, int toIndex,double val){
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i )
            a[i] = val;
    }

    /**
     * Assigns the specified float value to each element of the specified array
     * of floats.
     *
     * @param a the array to be filled
     * @param val the value to be stored in all elements of the array
     */
    public static void fill(float[] a, float val) {
        for (int i = 0, len = a.length; i )
            a[i] = val;
    }

    /**
     * Checks that {@code fromIndex} and {@code toIndex} are in
     * the range and throws an exception if they aren‘t.
     */
    private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
        }
        if (fromIndex ) {
            throw new ArrayIndexOutOfBoundsException(fromIndex);
        }
        if (toIndex > arrayLength) {
            throw new ArrayIndexOutOfBoundsException(toIndex);
        }
    }

int[] array = new int[]{1,2,3};
int[] array2 = Arrays.copyOf(array, 4);

    public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

int[] array = new int[]{1,2,3,4,5,6,7,8,9};
int[] array2 = Arrays.copyOfRange(array, 3, 6);
int[] array3 = Arrays.copyOfRange(array, 3, 10);

    /**
     * Copies the specified range of the specified array into a new array.
     * The initial index of the range (from) must lie between zero
     * and original.length, inclusive.  The value at
     * original[from] is placed into the initial element of the copy
     * (unless from == original.length or from == to).
     * Values from subsequent elements in the original array are placed into
     * subsequent elements in the copy.  The final index of the range
     * (to), which must be greater than or equal to from,
     * may be greater than original.length, in which case
     * 0 is placed in all elements of the copy whose index is
     * greater than or equal to original.length - from.  The length
     * of the returned array will be to - from.
     *
     * @param original the array from which a range is to be copied
     * @param from the initial index of the range to be copied, inclusive
     * @param to the final index of the range to be copied, exclusive.
     *     (This index may lie outside the array.)
     * @return a new array containing the specified range from the original array,
     *     truncated or padded with zeros to obtain the required length
     * @throws ArrayIndexOutOfBoundsException if {@code from @code from > original.length}
     * @throws IllegalArgumentException if from > to
     * @throws NullPointerException if original is null
     * @since 1.6
     */
    public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength )
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i)
            if (a[i] != a2[i])
                return false;

        return true;
    }

    public static boolean equals(Object[] a, Object[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i) {
            Object o1 = a[i];
            Object o2 = a2[i];
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }

        return true;
    }

    public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append(‘[‘);
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(‘]‘).toString();
            b.append(", ");
        }
    }