几个数组方法搞的我头晕， 记不住，就直接写下来了。
1、 先来一个底层方法：
System.arraycory(源数组，源数组开始位置，目标数组，目标数组开始位置， 复制的长度)
*这个方法，每次看着看着就有晕了过去，参数太多，类型又差不多，总是会看偏，理解错。 其实，System类的源码，解释的还是很清楚的*
源码+注释：
/**
* @param src the source array. 源数组
* @param srcPos starting position in the source array. 源数组复制的开始位置
* @param dest the destination array. 目标数组
* @param destPos starting position in the destination data. 目标数组接收的开始位置
* @param length the number of array elements to be copied. 被复制的元素的长度
* @exception IndexOutOfBoundsException if copying would cause
* access of data outside array bounds. 下标越界
* @exception ArrayStoreException if an element in the <code>src</code>
* array could not be stored into the <code>dest</code> array
* because of a type mismatch. 两数组类型不匹配
* @exception NullPointerException if either <code>src</code> or
* <code>dest</code> is <code>null</code>.
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);，看到这里应该有个七八分的理解了， 下面直接上示例代码，进一步说明一下 示例1：
public class ArrayCopy {
public static void main(String[] args) {
//源数组
int[] arr = {10,30,40,20,80};
//调用复制方法
int[] newArr = arrcopy(arr,10);
System.out.println(Arrays.toString(newArr));
}
public static int[] arrcopy(int[] original, int newLength ){
int [] newArr = new int[newLength];
System.arraycopy(original, 0,newArr, 0, Math.min(original.length,newLength));
return newArr;
}
}结果：[10, 30, 40, 20, 80, 0, 0, 0, 0, 0]。
这里可以看到， System.arraycopy(), 方法的最后一个参数，用到了Math,min(), 方法；Math.min(A,B),表示取两者中最小的那个数。 为什么会添加这个方法呢？
因为会存在这样的情况：当被复制的元素的长度 ，大于目标数组时，会报错：java.lang.ArrayIndexOutOfBoundsException
数组下标越界。 所以为了避免这样的情况，就添加了Math.min()，方法。 示例2：
//定义 两个数组,(这里为了方便观察，就用int型数组了)
int[] int1 = {1,2,4,5,6,7,8,9,10};
int[] int2 = new int[3];
//调用方法
System.arraycopy(int1,0,int2,0,int1.length);目标数组的长度只有3， 源数组的长度是10， 如上面，如果被复制的元素长度是整个源数组的长度，那么，目标数组容量肯定不够的。
然而： 当添加了Math.min(), 方法后，示例1，也变成了一个截取数组的方法了：
public class ArrayCopy {
public static void main(String[] args) {
//源数组
int[] arr = {10,30,40,20,80};
//调用复制方法,新数组length=4
int[] newArr = arrcopy(arr,4);
System.out.println(Arrays.toString(newArr));
}
public static int[] arrcopy(int[] original, int newLength ){
int [] newArr = new int[newLength];
System.arraycopy(original, 0,newArr, 0, Math.min(original.length,newLength));
return newArr;
}
}结果： [10, 30, 40, 20]。 **变成了截取源数组的方法了**
===================================================================
2、数组工具类Arrays.copyof(Object [] array, int length);
如果理解了上面的那个底层方法后， 我想，看一下这个方法的源码，肯定就知道怎么回事了。
源码：
/**
*
* @param original the array to be copied 被复制数组
* @param newLength the length of the copy to be returned 反对的数组的长度
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
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;
}是不是很惊喜， 它的底层实现竟然是 system.arraycopy(), 方法。 同时也运用了Math.min(), 也就是说可以实现扩容和缩容两种操作。
示例：
public class ArrayCopyTwo {
public static void main(String[] args) {
int[] arr = {10,20,30,40,50,60};
arr = Arrays.copyOf(arr,10);
System.out.println("第一次扩容，arr: "+Arrays.toString(arr));
//结果： 第一次扩容，arr: [10, 20, 30, 40, 50, 60, 0, 0, 0, 0]
arr = Arrays.copyOf(arr,3);
System.out.println("第二次缩容，arr:"+Arrays.toString(arr));
//结果： 第二次缩容，arr:[10, 20, 30]
}
}========================================================================
3、数组截取方法: Arrays.copyOfRang(int[] arr, int from, int to );
这个方法是截取（或者叫复制） 源数组 arr, 在 [from,to) 范围内的元素。 同样先来看源码：
/**
* @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 < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if <tt>from > to</tt>
* @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static int[] copyOfRange(int[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
int[] copy = new int[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}正如你看到的， 它的底层又是这个方法：System.arraycopy(). 不同的只是参数的值。这里就不再讲了。
示例：
public class ArrayCopyTwo {
public static void main(String[] args) {
int[] arr2 = {10,20,30,40,50,60};
arr2 = Arrays.copyOfRange(arr2,2,5);
System.out.println("范围内复制："+Arrays.toString(arr2));
// 结果： 范围内复制：[30, 40, 50]
}
}=========================================================================================================================更多方法，请直接看Arrays 类的源码。。。