JAVA开发之 39-JAVA数组知识点（二）

Bertha 。 2022-06-13 04:58 118阅读 0赞

**四.数组的基本操作**  
java.util包的Arrays类包含了用来操作数组（如排序和搜索）的各种方法。  
**1.遍历数组**  
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历一维数组很简单，也很好理解，下面详细介绍遍历二维数组的方法。  
遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度。  
例如：  
在项目中创建类，在主方法中编写代码，定义二维数组，实现将二维数组中的元素呈梯形输出。

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语句遍历二维数组。  
例如：在项目中创建类，在主方法中定义二维数组，使用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

--------------------

**2.填充替换数组元素**  
数组中的元素定义完成后，可通过***Arrays类的静态方法fill()***来对数组中的元素进行替换。该方法通过对各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型，下面以int类型数组为例介绍fill()方法的使用方法。  
**（1）fill(int\[\] a,int value)**  
该方法可将指定的int值分配给int型数组的每个元素。  
语法如下：

fill(int[]a, int value);

a:要进行元素替换的数组；  
value:要存储数组中所有元素的值；  
例如：  
在项目中创建类，在主方法中创建一维数组，并实现通过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 fromIndex,int toIndex,int value)**  
该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引 fromIndex （包括）一直到索引 toIndex（不包括）。如果fromIndex == toIndex, 则填充范围为空。  
语法如下：

fill( int[] a ,int fromIndex,int toIndex,int value);

a:要进行填充的数组；  
fromIndex:要使用指定值填充的第一个元素的索引（包括）；  
toIndex:要使用指定值填充的最后一个元素的索引（不包括）；  
value:要存储在数组所有元素中的值。  
注意:  
如果指定的索引的位置大于或等于要进行填充的数组的长度，则会报ArrayIndexOutOfBoundsException（数组越界异常）。  
例如：  
在项目中创建类，创建一维数组，并通过fill()方法替换数组元素，最后将数组中的各个元素输出。

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

输出结果：  
![这里写图片描述][SouthEast]

--------------------

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

Arrays.sort(object);

其中，object是指进行排序的数组名称。  
例如：  
在项目中创建类，在主方法中创建一维数组，将数组排序后输出。

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.复制数组**  
Arrays类的copyOf()方法与copyOfRange()方法可以对数组的复制；  
copyof()方法是复制数组至指定长度；  
copyOfRange()方法则将指定数组的长度复制到一个新数组中。  
**（1）copyOf()方法**  
该方法提供了多种重载形式，用于满足不同类型数组的复制。  
语法如下：

copyOf(arr,int newlength);

arr:要进行复制的数组；  
newlength:int型常量，指复制后的数组长度。如果新数组的长度大于数组arr的长度，则用0填充（根据复制数组的 类型 来决定填充的值，整型数组用0填充， char型数组则用null填充）；如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。  
例如：  
在项目中创建类，在主方法中创建一维数组，实现将此数组复制得到一个长度为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); //复制数组
            for(int i = 0; i <newarr.length; i++){
       //循环变量复制后的新数组
                System.out.println(newarr[i]); //将新数组输出
                    }
             }
     }

输出结果：  
23  
42  
12  
0  
0  
（2）copyOfRange()方法  
该方法同样提供了多种重载形式。  
语法如下：

copyOfRange(arr,int fromIndex,toIndex);

arr:要进行复制的数组对象；  
fromIndex:指定开始复制数组的索引位置。fromIndex必须在0至整个数组的长度之间。新数组包括索引是fromIndex的元素。  
toIndex:要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引为toIndex的元素。  
例如：  
在项目中创建类，在主方法中创建一个数组，并将数组中的索引位置是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

--------------------

**5.数组查询**  
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型.  
**（1）binarySearch(Object\[\],Object key)**  
语法如下：

binarySearch(Object[] a,Object key);

a:要搜索的数组；  
key:要搜索的值。  
如果key包含在数组中， 则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引 。  
例如：  
查询数组元素，代码如下：

int arr[] = new int[]{
       4,25,10}; 
    Arrays.sort(arr);
    int index = Arrays.binarSearch(arr,0,1,8);

index的值为 -2  
上面的代码中变量index 的值是元素“8”在数组arr中索引在0-1内的索引位置。由于在指定的范围内并不存在元素“8”，index的值是“-”（插入点）。如果对数组进行排序，元素“8”应该在“25”的前面，因此插入点应是元素“25”的索引值，所以index的值为-2.  
如果数组中的所有元素都小于指定的键，则为a.length（注意，这保证了当且仅当此键被找到时，返回的值将大于等于0）。  
**注意：**  
必须在进行此调用之前对数组进行排序（通过sort()方法）。如果没有对数组进行排序，则结果是不确定的。如果数组中包含多个带有指定值的元素，则无法保证找到的是哪一个。  
例如：  
在项目中创建类，在主方法中创建一维数组ia,实现查找元素4在数组ia中的索引位置。

import java.util.Arrays; 
    public class Example{
        public static void main(String[] args){
            int ia[] = new int[]{
       1,8,9,4,5}; 
            Arrays.sort(ia);
            int index = Arrays.binarySearch(ia,4); 
            System.out.println("4的索引位置是："+index); 
         }
    }

输出结果：  
4的索引位置是：1  
说明：  
返回值“1”是对数组ia进行排序后元素4的索引位置。  
**（2）binarySearch(Object\[\], int fromIndex,int toIndex,Object key)**  
该方法在指定的范围内检索某一元素。  
语法如下：

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

a:表示要进行检索的数组；  
fromIndex:指定范围的开始处索引（包含）；  
toIndex:指定范围的结束处索引（不包含）；  
key:要搜索的索引。  
在使用该方法之前同样要对数组进行排序，来获得准确的索引值。如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或“-”（插入点）。如果范围中的所有元素都小于指定的键，则为toIndex(注意，这保证了当且仅当此键被找到时，返回的值将大于等于0）。  
注意：  
如果指定的范围大于或等于数组的长度，则会报出ArrayIndexOutBoundsException异常。  
例如：  
在项目中创建类，在主方法中创建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

--------------------

[SouthEast]: /images/20220613/58af0b2b005d4bfbb52fcd0e62d51998.png