初识Java（Java数组-数组的基本操作)

今天药忘吃喽~ 2022-05-27 03:30 199阅读 0赞

### 一、数组的基本操作 ###

java.util 包的 Arrays 类包含了用来操作数组（如排序和搜索）的各种方法。

1.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
    2 3
    4 5 6

使用 foreach 语句遍历二维数组 ：

public class Tautog{
        public static void main(String[] args){
            int arr2[][] = { {4,3} , {1,2} };                  //定义二维数组
            System.out.println("数组中的元素是:");
            for( int x[] : arr2){                              //外层循环变量为一维数组
                for( int e : x ){                              //循环遍历每一个数组元素
                    if(e == x.length ){                        //判断变量是否是二维数组中的最后一个元素
                        System.out.printl(e);                  //输出二维数组的最后一个元素
                    }else{
                        System.out.print(e + "、");            //如果不是最后一个元素
                    }
                }
        }
    }

运行结果为 ：

数组中的元素是 :
    4 、3 、 1 、 2

1.2 填充替换数组元素

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

（ 1 ）fill(int\[\] a , int value )

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

语法 ：fill ( int\[\] a , int value )

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

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

创建一维数组，通过 fill() 方法填充数组元素。

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

运行结果为 ：

第 0 个元素是：8
    第 1 个元素是：8
    第 2 个元素是：8
    第 3 个元素是：8
    第 4 个元素是：8

1.3 对数组进行排序

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

语法 ： Arrays.sort(object)

object ：指进行排序的数组名称 。

eg： 创建一维数组，将数组排序后输出 ：

import 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 类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

1.4 复制数组

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

（ 1 ）copyOf() 方法

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

语法 ： copyOf( arr , int newlength )

arr ：要进行复制的数组 。

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

eg：实现将数组复制得到一个长度为 5 的新数组，并将新数组输出。

import 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 fromIndex , int toIndex )

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

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

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

eg ： 创建一维数组，将数组中索引位置是 0~3 之间的元素复制到新数组中，输出新数组。

import 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

1.5 数组查询

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

两种参数类型 ：

（ 1 ）binarySearch(Object\[\] , Object key)

语法 ：binarySearch(Object\[\] a , Object key)

a ：要搜索的数组 。

key ：要搜索的值 。

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

eg ：查询数组元素

int arr[] = new int[]{4,25,10};                    //创建并初始化数组
    Arrays.sort(arr);                                  //进行排序
    int index = Arrays.binarySearch(arr, 0, 1, 8);

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

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

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

eg ：创建一维数组，实现查找元素 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);              //查找数组 ia 中元素 4 的索引位置
            System.out.println("4 的索引位置是："+index);        //输出索引值
        }
    }

运行结果为 ：4 的索引位置是 1

（ 2 ）binarySearch(Object\[\] , int fromIndex , int toIndex ,Object key )

语法 ：binarySearch(Object\[\] a , int fromIndex ,int toIndex , Object key)

a ：要进行检索的数组 。

fromIndex ：指定范围的开始处索引（包含）。

toIndex ：指定范围的结束处索引（不包含）。

key ：要搜索的元素 。

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

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

eg ：创建 String 数组，实现查找元素 “ cd ”在指定范围的数组 str 中的索引位置。

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

运行结果为 ： cd 的索引位置是： 1