原文地址：http://c.biancheng.net/view/919.html

（一）java中两个数组的比较

相等的条件：

1. 元素个数相等；
2. 对应位置对应的元素也相等

比较方法：equals(arrayA, arrayB)

arrayA 是用于比较的第一个数组，arrayB 是用于比较的第二个数组

Arrays.equals(arrayA, arrayB);

例1：定义 3 个数组，分别为 score1、score2 和 score3。第一个数组直接给出了数组的值；第二个数组先定义数组的长度，然后为每个元素赋值；第三个数组中的元素和第一个数组中的元素相同，但是顺序不同。分别将 score1 数组与 score2 和 score3 数组进行比较，并输出比较的结果。

public static void main(String[] args) {
    double[] score1 = { 99, 100, 98.5, 96.5, 72 };
    double[] score2 = new double[5];
    score2[0] = 99;
    score2[1] = 100;
    score2[2] = 98.5;
    score2[3] = 96.5;
    score2[4] = 72;
    double[] score3 = { 99, 96.5, 98.5, 100, 72 };
    if (Arrays.equals(score1, score2)) {
        System.out.println("score1 数组和 score2 数组相等");
    } else {
        System.out.println("score1 数组和 score2 数组不等");
    }
    if (Arrays.equals(score1, score3)) {
        System.out.println("score1 数组和 score3 数组相等");
    } else {
        System.out.println("score1 数组和 score3 数组不等");
    }
}

运行输出结果如下：

score1 数组和 score2 数组相等
score1 数组和 score3 数组不等


（二）java中数组的填充（fill()）

java中 使用fill() 方法可以在指定位置进行数值填充，但只能使用同一个数值进行填充

Arrays.fill(array,value);

例1：声明一个 int 类型的 number 数组，然后通过 for 语句进行遍历，在该语句中调用 Arrays 类的 fill() 方法来填充数组，并输出数组中元素的值。

public static void main(String[] args) {
    int[] number = new int[5];
    System.out.println("number —共有 " + number.length + " 个元素，它们分别是：");
    for (int i = 0; i < number.length; i++) {
        Arrays.fill(number, i);
        System.out.println("number[" + i + "]=" + i);
    }
}

执行上述代码，输出结果如下所示。

number 一共有 5 个元素，它们分别是：
number[0]=0
number[1]=1
number[2]=2
number[3]=3
number[4]=4

（三）java中数组的查找指定元素（binarySearch()）

查找数组是指从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置。
binarySearch() 方法可以实现数组的查找，该方法可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。
binarySearch() 方法有多种重载形式来满足不同类型数组的查找需要，常用的重载形式有两种。
(1) 第一种形式如下：a 表示要搜索的数组，key 表示要搜索的值。如果 key 包含在数组中，则返回搜索值的索引；否则返回 -1 或“-插入点”。
插入点指搜索键将要插入数组的位置，即第一个大于此键的元素索引。

binarySearch(Object[] a,Object key);

例1：声明 double 类型的 score 数组，接着调用 Arrays 类的 sort() 方法对 score 数组排序，排序后分别查找数组中值为 100 和 60 的元素，分别将结果保存到 index1 和 index2 变量中，最后输出变量的值。代码如下：

public static void main(String[] args) {
    double[] score = { 99.5, 100, 98, 97.5, 100, 95, 85.5, 100 };
    Arrays.sort(score);
    int index1 = Arrays.binarySearch(score, 100);
    int index2 = Arrays.binarySearch(score, 60);
    System.out.println("查找到 100 的位置是：" + index1);
    System.out.println("查找到 60 的位置是：" + index2);
}

执行上述代码，输出结果如下：

查找到 100 的位置是：5
查找到 60 的位置是：-1

(2) 除了上述形式外，binarySearch() 还有另一种常用的形式，这种形式用于在指定的范围内查找某一元素。语法如下：

binarySearch(Object[] a,int fromIndex,int toIndex,Object key);

其中，a表示要进行查找的数组，fromIndex 指定范围的开始处索引（包含开始处），toIndex 指定范围的结束处索引（不包含结束处），key 表示要搜索的元素。

在使用 binarySearch()方法的上述重载形式时，也需要对数组进行排序，以便获取准确的索引值。如果要查找的元素 key 在指定的范围内，则返回搜索键的索引；否则返回 -1 或 “-插入点”。插入点指要将键插入数组的位置，即范围内第一个大于此键的元素索引。

例 2 ：对例 1 中创建的 score 数组进行查找元素，指定开始位置为 2，结束位置为 6。代码如下:

public static void main(String[] args) {
    double[] score = {99.5,100,98,97.5,100,95,85.5,100};
    Arrays.sort(score);
    int index1 = Arrays.binarySearch(score,2,6,100);
    int index2 = Arrays.binarySearch(score,2,6,60);
    System.out.println("查找到 100 的位置是："+index1);
    System.out.println("查找到 60 的位置是："+ index2);
}

执行上述代码，输出结果如下：

查找到 100 的位置是：5
查找到 60 的位置是：-3

注意：实现对数组进行查找的方法很多，但是使用 Arrays 对象的 binarySearch() 方法是最简单、最方便的一种，因此该方法经常被应用。

（四）java中数组的复制（arraycopy()方法、clone() 方法、copyOf()和copyOfRan）

概念：复制数组，是指将一个数组中的元素在另一个数组中进行复制。
在 Java 中实现数组复制分别有以下 4 种方法：

1. Arrays 类的 copyOf() 方法
2. Arrays 类的 copyOfRange() 方法
3. System 类的 arraycopy() 方法
4. Object 类的 clone() 方法

copyOf() 方法是复制数组至指定长度，copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中

1. Arrays 类的 copyOf() 方法

格式：

Arrays.copyOf(dataType[] srcArray,int length);

srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度。

使用这种方法复制数组时，默认从原数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。
如果 length 大于 srcArray.length，则目标数组中采用默认值填充；
如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。

注意：目标数组如果已经存在，将会被重构。
例1：假设有一个数组中保存了 5 个成绩，现在需要在一个新数组中保存这 5 个成绩，同时留 3 个空余的元素供后期开发使用。

import java.util.Arrays;
public class Test19{
    public static void main(String[] args) {
        // 定义长度为 5 的数组
        int scores[] = new int[]{57,81,68,75,91};
        // 输出原数组
        System.out.println("原数组内容如下：");
        // 循环遍历原数组
        for(int i=0;i<scores.length;i++) {
            // 将数组元素输出
            System.out.print(scores[i]+"\t");
        }
        // 定义一个新的数组，将 scores 数组中的 5 个元素复制过来
        // 同时留 3 个内存空间供以后开发使用
        int[] newScores = (int[])Arrays.copyOf(scores,8);
        System.out.println("\n复制的新数组内容如下：");
        // 循环遍历复制后的新数组
        for(int j=0;j<newScores.length;j++) {
            // 将新数组的元素输出
            System.out.print(newScores[j]+"\t");
        }
    }
}

因为原数组 scores 的数据类型为 int，而使用 Arrays.copyOf(scores,8) 方法复制数组之后返回的是 Object[] 类型，因此需要将 Object[] 数据类型强制转换为 int[] 类型。同时，也正因为 scores 的数据类型为 int，因此默认值为 0。

运行的结果如下所示。

原数组内容如下：
57    81    68    75    91   
复制的新数组内容如下：
57    81    68    75    91    0    0    0

2. Arrays 类的 copyOfRange() 方法

语法：

• srcArray 表示原数组。
• startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，另外，startIndex 必须在 0 到 srcArray.length 之间。
• endIndex 表示终止索引，目标数组中将不包含终止索引对应的元素，endIndex 必须大于等于 startIndex，可以大于 srcArray.length，如果大于 srcArray.length，则目标数组中使用默认值填充。
• 注意：目标数组如果已经存在，将会被重构。

Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)

3.  System 类的 arraycopy() 方法

语法

System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)

srcArray 表示原数组；
srcIndex 表示原数组中的起始索引；
destArray 表示目标数组；
destIndex 表示目标数组中的起始索引；
length 表示要复制的数组长度。

使用此方法复制数组时，length+srcIndex 必须小于等于 srcArray.length，
同时 length+destIndex 必须小于等于 destArray.length。

注意：目标数组必须已经存在，且不会被重构，相当于替换目标数组中的部分元素。

4.使用 clone() 方法

clone() 方法也可以实现复制数组。该方法是类 Object 中的方法，可以创建一个有单独内存空间的对象。
因为数组也是一个 Object 类，因此也可以使用数组对象的 clone() 方法来复制数组。

clone() 方法的返回值是 Object 类型，要使用强制类型转换为适当的类型。
语法：

array_name.clone()

示例语句如下：

int[] targetArray=(int[])sourceArray.clone();

注意：目标数组如果已经存在，将会被重构。