Java数组详解

程序员桔子
179 阅读8分钟

数组是具有相同数据类型的一组数据的集合。在程序的设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在 Java 中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。在程序的设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为一维数组、二维数组 ⋯⋯

1.一维数组

创建一维数组

  1. 先声明，再用new关键字进行内存分配。
    数组元素类型决定了数组的数据类型，它可以是 Java 中任意的数据类型，包括简单类型和组合类型。数组名字为一个合法的标识符，符号 []指明该变量是一个数组类型变量。单个[]表示要创建的数组是一个一维数组。
int arr[];  // 先声明：数组元素类型 数组名字[];
arr=new int[5]; // 后分配内存


int[] arr1;// 先声明：数组元素类型[] 数组名字;
arr1=new int[5]; // 后分配内存
  1. 声明的同时为数组分配内存。
// 数据元素的类型 数组名=new 数组元素的类型[数组元素的个数]
int month[]=new int[12];

tips：使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为 0。

初始化一维数组

数组的初始化就是包括在大括号之内用逗号分开的表达式列表。用逗号,分割数组中的各个元素，系统自动为数组分配一定的空间。

int arr2[]=new int[]{1,2,3,4,5};

使用一维数组

方括号[]中的值为数组的下标，数组通过下标来区分数组中的不同元素。数组的下标是从 0 开始的。

  public static void main(String[] args) {
        int day[]=new int[]{1,2,3,4,5};
        for (int i = 0; i < 5; i++) {
            System.out.println(day[i]);
        }
    }
//    输出结果：
//        1
//        2
//        3
//        4
//        5

2.二维数组

创建二维数组

  1. 先声明，再用new关键字进行内存分配。
    同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用new关键字来分配内存，然后才可以访问每个元素。
//先声明：数组元素类型 数组名字[][];
    int a[][];
    int b[][];
//第一种内存分配方式：直接为每一维分配内存空间
    a=new int[2][4];
//第二种内存分配方式：分别为每一维分配内存空间
    b=new int[2][];
    b[0]=new int[2];
    b[1]=new int[3];

详解：
第一种内存分配方式：创建了二维数组 a，二维数组 a 中包括两个长度为 4 的一维数组。
第二种内存分配方式：创建了二维数组 b，但是只声明了 a 第一维的长度，也就是“行数”，第二维的长度也就是“列数”，则是为每一行单独声明的，因此创建的数组 a 是“不定长数组”。

  1. 声明的同时为数组分配内存。
    声明与赋值被合并到同一行代码中。
int a=new int[2][4];

初始化二维数组

同样可以使用大括号完成：

int arr[][]={{1,2},{3,4}};

初始化二维数组后，要明确数组的下标都是从 0 开始的。例如，上面的代码中 arr[1][1]的值为 4。int 型二维数组是以 int a[][]来定义的，所以可以直接给 a[x][y]赋值。例如，给 a[1]的第 2 个元素賦值的语句如下:

a[1][1] = 20;

使用二维数组

对于整型二维数组，创建成功后系统会给数组中每个元素赋予初始值 0。

 public static void main(String[] args) {
        int arr[][]=new int[3][4];
        for (int i = 0; i < arr.length; i++) {
            for (int i1 = 0; i1 < arr[i].length; i1++) {
                System.out.print(arr[i][i1]);
            }
            System.out.println();
        }

    }
//    输出结果：
//        0000
//        0000
//        0000

3.数组的基本操作

遍历数组

  1. for 循环遍历：一维数组用单层 for 循环，二维数组用双层 for 循环（举例见相应使用数组处），idea 中的快捷键：arr.fori+enter。
  2. foreach 语句遍历二维数组：idea 中的快捷键：arr.for+enter。
public static void main(String[] args) {
    int arr[][] = {{1, 2}, {3, 4}};
    for (int[] x : arr) {
        for (int i : x) {
            System.out.println(i);
        }
    }
}
//输出：
//1
//2
//3
//4

填充替换数组元素

  1. fill(int[] a,int value), 该方法可以将指定的 int 值分配给 int 型数组的每个元素。
public static void main(String[] args) {
    int arr[]=new int[5];
    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
  1. fill(int[] a,int fromIndex,int toIndex,int value)
    该方法将指定的 int 值分配给 int 型数组指定范围中的每个元素。填充的范围从索引 fromlndex（包括）一直到索引 toIndex（不包括）。如果 fromIndex=toIndex，则填充范围为空。
 public static void main(String[] args) {
        int arr[]=new int[]{1,2,3,4,5};
        Arrays.fill(arr,1,2,8);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("第" + i + "个元素是：" + arr[i]);
        }
    }
//    输出结果：
//    第0个元素是：1
//    第1个元素是：8
//    第2个元素是：3
//    第3个元素是：4
//    第4个元素是：5

对数组进行排序

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

Arrays.sort(object)

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

    public static void main(String[] args) {
        int arr[]=new int[]{1,7,5,4,3};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
//    输出结果：
//        1
//        3
//        4
//        5
//        7

复制数组

  1. copyOf()方法：copyOf(arr,int newlength)
    arr：要进行复制的数组。
    newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组 arr 的长度，则用 0 填充（根据复制数组的类型来决定填充的值，整型数组用 0 填充，char型数组则使用 null 来填充）：如果新数组长度小于数组 arr 的长度，则会从数组 arr 的第一个元素开始截取至满足新数组长度为止。
public static void main(String[] args) {
        int arr[]=new int[]{1,7,5,4,3};
        int[] newArray = Arrays.copyOf(arr, 7);
        for (int i = 0; i < newArray.length; i++) {
            System.out.println(newArray[i]);
        }

    }
//    输出结果：
//        1
//        7
//        5
//        4
//        3
//        0
//        0
  1. copyOfRange()方法：copyOfRange(arr,int fromIndex,int toIndex)
    arr：要进行复制的数组对象。
    fromlndex：指定开始复制数组的索引位置。fromlndex 必须在 0 至整个数组的长度之间。新数组包括索引是 formlndex 的元素。
    tolndex：要复制范围的最后索引位置。可大于数组 arr 的长度。新数组不包括索引是 tolndex 的元素。
    public static void main(String[] args) {
        int arr[]=new int[]{1,7,5,4,3};
        int[] newArray = Arrays.copyOfRange(arr, 0,3);
        for (int i = 0; i < newArray.length; i++) {
            System.out.println(newArray[i]);
        }

    }
//    输出结果：
//        1
//        7
//        5

查询数组

Arrays 类的 binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。
binarySearch()方法有两种参数类型，需要注意的是必须在调用 binarySearch()之前对数组进行排序（通过 sort()方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

  1. binarySearch(Object[] a, Object key)
    a：要搜索的数组。
    key：要搜索的值。
    如果 key 被包含在数组中，则返回搜索值的索引；否则返回-1 或“-”（插入点）。插入点是搜索键将要被插入数组中的那一点，即第一个大于此键的元素索引。
public static void main(String[] args) {
    int arr[]=new int[]{1,7,5,4,3};
    Arrays.sort(arr);
    int index=Arrays.binarySearch(arr,4);
    System.out.println("4的索引在：" + index);
}
//    输出结果：4的索引在：2
  1. binarySearch(Object[] a, int fromIndex,int toIndex，Object key)
    a：要进行检索的数组。
    fromlndex：指定范围的开始处索引（包含）。
    tolndex：指定范围的结束处索引（不包含）。
    key：要搜索的元素。
    在使用该方法前，同样要对数组进行排序，这样才能获得准确的索引值。如果要搜索的元素 key 在指定的范围内，则返回搜索键的索引：否则返回-1 或“”（插入点）。如果范围中的所有元素都小于指定的键，则插入点为 toIndex（注意，这保证了当且仅当此键被找到时，返回的值将大于或等于 0）。注意：如果指定的范围大于或等于数组的长度，则会报 ArrayIndexOutOfBoundsException 异常。
public static void main(String[] args) {
    int arr[]=new int[]{1,7,5,4,3};
    Arrays.sort(arr);
    int index=Arrays.binarySearch(arr,1,5,4);
    System.out.println("4的索引在：" + index);
}
//    输出结果：4的索引在：2
avatar
文章
阅读
粉丝