4.4数组的基本操作

java.util包的Arrays类包含了用来操作数组(如排序和搜索)的各种方法，本节就将讲解数组的基本操作。

4.4.1遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历一维数组很简单，也很好理解，下面详细介绍遍历二维数组的方法。

遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

【例1】呈梯形输出二维数组中的元素

在项目中创建Trap类，在主方法中编写代码，定义二维数组，将二维数组中的元素呈梯形输出。实例代码如下：

public class Trap{    //创建类
    public static void main(String[] args){    //主方法
        int b[][] = new int[][]{{1},{2,3},{4,5,6}};    //定义二维数组
        for(int k = 0;k < b.length;k++){
            for (int c = 0;c < b[k].length;c++){    //循环遍历二维数组中的每个元素    
                System.out.print(b[k][c]);    //将数组中的元素输出
            }
            System.out.println();    //输出空格
        }
    }
}

运行结果如下：

1

23

456

在遍历数组时，使用foreach语句可能会更简单。下面的实例就是通过foreach语句遍历二维数组。

【例2】使用foreach语句遍历二维数组

在项目中创建Tautog类，在主方法中定义二维数组，使用foreach语句遍历二维数组。实例代码如下：

public class Tautog{    //创建类
    public static void main(String[] args){    //主方法
        int arr2[][] = {{4,3},{1,2}};    //定义二维数组
        System.out.println("数组中的元素是：");    //提示信息
        int i = 0;    //外层循环计数器变量
        for(int x[] : arr2){    //外层循环变量为一维数组
            i++;    //外层计数器递增
            int j = 0;    //内层循环计数器变量
            for (int e : x){    //循环遍历每一个数组元素
                j++;    //内层计数器递增
                if(i == arr2.length && j == x.length){   //判断变量是二维数组中的最后一个元素
                    System.out.print(e);    //输出二维数组的最后一个元素
                }else    //如果不是二维数组中的最后一个元素
                    System.out.print(e+"、");    //输出信息
            }
        }
    }
}

运行结果如下：

数组中的元素是：

4、3、1、2

4.4.2填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型，下面以int型数组为例讲解fill()方法的使用方法。

1.fill(int[] a,int value)

该方法可将指定的int值分配给int型数组的每个元素。语法如下：

fill(int[] a,int value)

☑ a：要进行元素替换的数组。

☑ value：要存储数组中所有元素的值。

【例3】使用fill()方法填充数组元素

在项目中创建Swap类，在主方法中创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中的各个元素输出。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Swap{    //创建类
    public static void main(String[] args){    //主方法
        int arr[] = new int[5];    //创建int型数组
        Arrays.fill(arr,8);    //使用同一个值对数组进行填充
        for(int i = 0;i < arr.length;i++){    //循环遍历数组中的元素
            System.out.println("第"+i+"个元素是："+arr[i]);    //将数组中的元素依次输出
        }
    }
}

运行结果如下：

第0个元素是：8

第1个元素是：8

第2个元素是：8

第3个元素是：8

第4个元素是：8

2.fill(int[] a,int fromlndex,int tolndex,int value)

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex(包括)一直到索引toIndex(不包括)。如果fromIndex==toIndex,则填充范围为空。语法如下：

fill[int[] a,int fromlndex,int tolndex,int value)

☑ a：要进行填充的数组。

☑ fromIndex：要使用指定值填充的第一个元素的索引(包括)。

☑ toIndex：要使用指定值填充的最后一个元素的索引(不包括)。

☑ value：要分配给数组指定范围中的每个元素的值。

误区警示：

如果指定的索引位置大于或等于要进行填充的数组的长度，则会报出ArrayIndexOutOf-BoundsException异常。

【例4】使用fill()方法替换数组中的元素

在项目中创建Displace类，创建一维数组，并通过fill()方法替换数组元素，最后将数组中的各个元素输出。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Displace{    //创建类
    public static void main(String[] args){    //主方法
        int arr[] = new int[]{45,12,2,10};    //定义并初始化int型数组arr
        Arrays.fill(arr,1,2,8);    //使用fill()方法替换数组指定范围内的元素
        for(int i = 0;i < arr.length;i++){    //循环遍历数组中的元素
            System.out.println("第"+i+"个元素是："+arr[i]);    //将数组中的每个元素输出
        }
    }
}

运行结果如下：

第0个元素是：45

第1个元素是：8

第2个元素是：2

第3个元素是：10

4.4.3对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

Arrays.sort(object)

其中，object是指进行排序的数组名称。

【例5】使用sort()方法将数组排序后输出

在项目中创建Taxis类，在主方法中创建一维数组，将数组排序后输出。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Taxis {    //创建类
    public static void main(String[] args){    //主方法
        int arr[] = new int[]{23,42,12,8};    //声明数组
        Arrays.sort(arr);    //将数组进行排序
        for (int i = 0;i < arr.length;i++){    //循环遍历排序后的数组
            System.out.println(arr[i]);    //将排序后数组中的各个元素输出
        }
    }
}

运行结果如下：

8

12

23

42

上述实例是对整型数组进行排序。Java中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

4.4.4 复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

1.copyOf()方法

该方法提供了多种重载形式，用于满足不同类型数组的复制。语法如下：

copyOf(arr,int newlength)

☑ arr：要进行复制的数组。

☑ newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则用0填充(根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充);如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。

【例6】复制数组

在项目中创建Cope类，在主方法中创建一维数组，实现将此数组复制得到一个长度为5的新数组，并将新数组输出。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Cope{    //创建类
    public static void main(String[] args){    //主方法
        int arr[] = new int[]{23,42,12};    //定义数组
        int newarr[] = Arrays.copyOf(arr,5);    //复制数组arr
        for(int i = 0;i < newarr.length;i++){    //循环遍历复制后的新数组
            System.out.println(newarr[i]);    //将新数组输出
        }
    }
}

运行结果如下：

23

42

12

0

0

2.copyOfRange()方法

该方法同样提供了多种重载形式。语法如下：

copyOfRange(arr,int formlndex,int tolndex)

☑ arr：要进行复制的数组对象

☑ formIndex：指定开始复制数组的索引位置。formIndex必须在0至整个数组的长度之间。新数组包括索引是formIndex的元素。

☑ toIndex：要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex的元素。

【例7】按照索引复制数组

在项目中创建Repeat类，在主方法中创建一维数组，并将数组中索引位置是0～3的元素复制到新数组中，最后将新数组输出。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Repeat {    //创建类
    public static void main(String[] args){    //主方法
        int arr[] = new int[]{23,42,12,84,10};    //定义数组
        int newarr[] = Arrays.copyOfRange(arr,0,3);    //复制数组
        for(int i = 0;i < newarr.length;i++){    //循环遍历复制后的新数组
            System.out.println(newarr[i]);    //将新数组中的每个元素输出
        }
    }
}

运行结果如下：

23

42

12

4.4.5查询数组

Arrays类的binarySearch()方法可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

1.binarySearch(Object[] a,Object key)

语法如下：

binarySearch(Object[] a,Object key)

☑ a：要搜索的数组。

☑ key：要搜索的值。

如果key包含在数组中，则返回搜索值的索引：否则返回-1或"-"(插入点)。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。

查询数组元素，代码如下：

int arr[] = new int[]{4,25,10}; //创建并初始化数组

Arrays.sort(arr); //将数组进行排序

int index = Arrays.binarySearch(arr,8);

上面的代码中变量index的值是元素"8"在数组arr中索引在0～1内的索引位置。由于在指定的范围内并不存在元素"8"，index的值是"-"(插入点)。如果对数组进行排序，元素"8"应该在"25"的前面，因此插入点应是元素"25"的索引值2，所以index的值是-2。

如果数组中的所有元素都小于指定的键，则为a.length(注意，这保证了当且仅当此键被找到时，返回的值将大于等于0)。

误区警示：

必须在调用binarySearch(Object[] a,Object key)之前对数组进行排序(通过sort()方法)。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

【例8】查找元素在数组中的索引位置

在项目中创建Reference类，在主方法中创建一维数组ia,实现查找元素4在数组ia中的索引位置。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Reference{    //创建类
    public static void main(String[] args){    //主方法
        int ia[] = new int[]{1,8,9,4,5};    //定义int型数组ia
        Arrays.sort(ia);    //将数组进行排序
        int index = Arrays.binarySearch(ia,4);    //查找数组ia中元素4的索引位置
        System.out.println("4的索引位置是："+index);    //将索引输出
    }
}

运行结果如下：

4的索引位置是：1
说明：

返回值"1"是对数组ia进行排序后元素4的索引位置。

2.binarySearch(Object[] a,int fromlndex,int tolndex,Object key)

该方法在指定的范围内检索某一元素。语法如下：

binarySearch(Object[] a,int fromlndex,int tolndex,Object key)

☑ a：要进行检索的数组。

☑ fromIndex：指定范围的开始处索引(包含)。

☑ toIndex：指定范围的结束处索引(不包含)。

☑ key：要搜索的元素。

在使用该方法前，同样要对数组进行排序，这样才能获得准确的索引值。如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或"-"(插入点)。如果范围中的所有元素都小于指定的键，则插入点为toIndex(注意，这保证了当且仅当此键被找到时，返回的值将大于等于0)。

误区警示：

如果指定的范围大于或等于数组的长度，则会报出AraylndexOutOfBoundsException异常。

【例9】在指定范围内查找元素在数组中的索引位置

在项目中创建Rakel类，在主方法中创建String数组，实现查找元素"cd"在指定范围的数组str中的索引位置。实例代码如下：

import java.util.Arrays;    //导入java.util.Arrays类
public class Rakel{    //创建类
    public static void main(String[] args){    //主方法
        String str[] = new String[]{"ab","cd","ef","yz"};    //定义String型数组str
        Arrays.sort(str);    //将数组进行排序
        int index = Arrays.binarySearch(str,0,2,"cd");    //在指定范围内搜索元素"cd"的索引位置
        System.out.println("cd的索引位置是："+index);    //将索引输出
    }
}

运行结果如下：

cd的索引位置是：1