Java 数组

1、一维数组

  • 一维数组是具有相同数据类型数据的一种线性组合。这里的 “数据类型” 可以是 Java 定义的任意一种数据类型,包括对象引用类型即对象的引用,数组中可以存放相同类的多个对象。

1.1 定义一维数组

  • 1)定义数组

    • 与 C、C++ 不同,Java 在定义数组时并不为数组元素分配内存,因此 [] 中无需指定数组元素的个数,即数组长度。

      1
      2
      3
      4
      5
      datatype arrayName[];



      datatype[] arrayName;
      • 这两种形式没有区别,使用效果完全一样。
      • datatype 为任意数据类型,数组中的数据元素也是 datatype 类型。
      • arrayName 是数组名称,在编写程序时该名称应该具有一定的意义。
      • [] 是数组的标识符,此时定义了一个数组,但数组中没有数据元素,也就是说 Java 允许定义一个数组但数据元素的数量为 0,通常称这样的数组为空数组。
  • 2)分配内存空间

    • 空数组没有获得内存空间,所以无法使用,必须使用 new 关键字为数据分配内存空间,在 Java 中 new 关键字的作用是产生该类的某个对象,并为该对象分配内存空间,内存空间的大小视对象大小而定。

      1
      2
      datatype[] arrayName;                               // 定义数组
      arrayName = new datatype[arraySize]; // 为数据分配内存空间
    • 通常,可以在定义的同时分配内存空间。

      1
      datatype[] arrayName = new datatype[arraySize];     // 定义数组,并为数据分配内存空间
  • 3)定义 int 类型的数组

    1
    2
    3
    4
    5
    int intArrayExample[] = new int[100];



    int[] intArrayExample = new int[100];

1.2 初始化一维数组

  • 1)初始化数组

    • 用 new 关键字为数组分配了存储空间后,对于数组中的元素 “到底是什么” 仍然无法确定,所以需要为已经分配了存储空间的数组填充相应的数据,这就是数组初始化的作用。

    • 可以在声明数组的同时进行初始化(静态初始化),也可以在声明以后进行初始化(动态初始化)。

      1
      2
      3
      // 静态初始化

      datatype[] arrayName = {value1,value2,value3};
      1
      2
      3
      4
      // 动态初始化

      datatype[] arrayName;
      arrayName = new datatype[]{value1,value2,value3};
      • 在数组标识符 [] 内是 datatype 类型的数组值,这里初始化了一个类型为 datatype 的一维数组,数组中包含 3 个 datatype 数据类型的数据元素,数据值依次是 value1、value2、value3,数据值之间使用 “,” 隔开。
  • 2)初始化 int 类型的数组

    1
    int[] intArrayExample = {23, 25, 43, 88, 99};
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    int[] intArrayExample;
    intArrayExample = new int[]{23, 25, 43, 88, 99};



    int[] intArrayExample = new int[5];
    intArrayExample[0] = 23;
    intArrayExample[1] = 25;
    intArrayExample[2] = 43;
    intArrayExample[3] = 88;
    intArrayExample[4] = 99;

1.3 使用一维数组

  • 定义和初始化数组后,就可以使用数组了,这里的“使用”主要强调对数组中数据元素的操作。
  • 数组元素是通过一种特殊的方式,即通过下标访问数组元素,如果数组的长度为 n 则可通过从 0 到 n-1 的整数索引获得相应位置的元素。
  • 数组元素的第一个值的整数索引为 0,即 intArray[0] 表示数组的第一个数据元素。

2、二维数组

  • 二维数组是多维数组中的一种。

2.1 定义二维数组

  • 1)定义数组

    • 与 C、C++ 不同,Java 在定义数组时并不为数组元素分配内存,因此 [][] 中无需指定数组元素的个数,即数组长度。

      1
      2
      3
      4
      5
      datatype arrayName[][];



      datatype[][] arrayName;
      • 这两种形式没有区别,使用效果完全一样。
      • datatype 为任意数据类型,数组中的数据元素也是 datatype 类型。
      • arrayName 是数组名称,在编写程序时该名称应该具有一定的意义。
      • [][] 是数组的标识符,此时定义了一个数组,但数组中没有数据元素,也就是说 Java 允许定义一个数组但数据元素的数量为 0,通常称这样的数组为空数组。
  • 2)分配内存空间

    • 空数组没有获得内存空间,所以无法使用,必须使用 new 关键字为数据分配内存空间,在 Java 中 new 关键字的作用是产生该类的某个对象,并为该对象分配内存空间,内存空间的大小视对象大小而定。

      1
      2
      datatype[][] arrayName;                                         // 定义数组
      arrayName = new datatype[rowSize][columnSize]; // 为数据分配内存空间
    • 通常,可以在定义的同时分配内存空间。

      1
      datatype[][] arrayName = new datatype[rowSize][columnSize];     // 定义数组,并为数据分配内存空间
      • rowSize 是二维数组的行的数量,columnSize 是二维数组的列的数量。
      • 通常二维数组的行的长度称为二维数组的长度这样为二维数组分配了 rowSize * columnSize 个内存空间。
  • 3)定义 int 类型的数组

    1
    2
    3
    4
    5
    int intArrayExample[][] = new int[2][3];



    int[][] intArrayExample = new int[2][3];
    • 定义并初始化了一个整型的二维数组 intArrayExample[][],该二维数组有 2 行 3 列,为其分配了 2 × 3 = 6 个内存空间,存放 int 类型的数据。
    • 数组中各元素通过其下标来区分,每个下标的最小值为 0,最大值为行数和列数减 1。
    • 数组包括 6 个元素,分别是 intArrayExample[0][0]、intArrayExample[0][1]、intArrayExample[0][2]、intArrayExample[1][0]、intArrayExample[1][1] 和 intArrayExample[1][2],相当于 2 行 3 列的规则矩阵。
  • 4)定义不规则的二维数组

    • 上面定义了规则的二维数组,其实 Java 并没有对规则性做强制的要求,即允许不规则的二维数组,如:

      1
      d[][]= new double[2][]
    • 表示数组 d 有 2 个元素,每个元素是数据类型为 double 的一维数组,即定义了 2 个数组变量,分别为 d[0]、d[1],这时可以用 new 运算符创建各自的数组对象,如:

      1
      2
      d[0] = new double[5]
      d[1] = new double[3]
    • 数组 d 的第一行有 5 个 double 型数据元素,第二行有 3 个 double 型数据元素,所以二维数据每行的长度可以不同。

2.2 初始化二维数组

  • 1)初始化数组

    • 二维数组的初始化是指在定义并为其分配了合适的内存空间后,为每个存储空间填充数据,使得数组有可以操作的实际数据对象。

    • 可以在声明数组的同时进行初始化(静态初始化),也可以在声明以后进行初始化(动态初始化)。

      1
      2
      3
      // 静态初始化

      datatype[][] arrayName = {{value1,value2},{value3, value4}};
      1
      2
      3
      4
      // 动态初始化

      datatype[] arrayName;
      arrayName = new datatype[][]{{value1,value2},{value3, value4}};
      • 在数组标识符 [][] 内是 datatype 类型的数组值,这里初始化了一个类型为 datatype 的二维数组,数组中包含 4 个 datatype 数据类型的数据元素,数据值依次是 value1、value2、value3,value4,数据值之间使用 “,” 隔开。
  • 2)初始化 int 类型的数组。

    1
    int[][] intArrayExample = {{23, 25}, {43, 88, 99}};
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    int[][] intArrayExample;
    intArrayExample = new int[][]{{23, 25}, {43, 88, 99}};



    int[][] intArrayExample = new int[2][3];
    intArrayExample[0][0] = 23;
    intArrayExample[0][1] = 25;
    intArrayExample[1][0] = 43;
    intArrayExample[1][1] = 88;
    intArrayExample[1][2] = 99;

2.3 使用二维数组

  • 二维数组通过两层嵌套来获得数组中的数据,再进行其他运算,当然也可以获得数组中的单独数据。

3、多维数组

  • 多维数组是指三维以上的数组。上节读者详细了解了二维数组,不难看出如果想提高数组的维数,只需要在声明数组时增加下标,再增加中括号即可,如定义四维数组可以在定义二维数组上扩展为 double d[][][][],更多维数组的声明方式依此类推。多维数组的使用与一维、二维数组相类似,但是每增加一维,则增加一层嵌套,所以对于多维数组,使用起来相对复杂。

4、数组常见操作

4.1 数组复制

  • 数组的复制是通过类 Arrays 的静态方法 copyOf(type[] original,int length) 实现的,其中 type 可以是 boolean 类型、int 类型、short 类型、char 类型、byte 类型等。

    1
    2
    3
    4
    5
    6
    7
    8
    char charArrayCopy[] = {'h', 'e', 'l', 'l', 'o'};

    // 对数组 charArrayCopy 进行复制,新数组的长度为 4,截去 charArrayCopy 中的多余元素
    char newArray1[] = Arrays.copyOf(charArrayCopy, 4);

    // 对数组 charArrayCopy 进行复制,新数组的长度为 8,以 null 字符填充,
    // 其中 charArrayCopy 的数组长度为 4,新数组的其余部分用 null 字符填充
    char newArray2[] = Arrays.copyOf(charArrayCopy, 8);
  • 数组复制方法列表

不同参数类型的方法 方法说明
copyOf(boolean[] original, int newLength) 复制 boolean 型数组,截去多余部分,或以 false 填充
copyOf(char[] original, int newLength) 复制 char 型数组,截去多余部分,或以 null 填充
copyOf(float[] original, int newLength) 复制 float 型数组,截去多余部分,或以 0 填充
copyOf(double[] original, int newLength) 复制 double 型数组,截去多余部分,或以 0 填充
copyOf(byte[] original, int newLength) 复制 byte 型数组,截去多余部分,或以 0 填充
copyOf(short[] original, int newLength) 复制 short 型数组,截去多余部分,或以 0 填充
copyOf(int[] original, int newLength) 复制 int 型数组,截去多余部分,或以 0 填充
copyOf(long[] original, int newLength) 复制 long 型数组,截去多余部分,或以 0 填充
copyOf(T[] original, int newLength) 复制 T 型数组,截去多余部分,或以 null 填充

4.2 数组填充

  • 数组的填充实现了数组部分或全部空间的填充,Java 提供了一种方法两种形式。

    • 一种形式是 fill(type[] a, type b);
    • 另一种形式是 fill(type[] a, int key1, int key2, type b);
    • 前者表示把数组 a 的全部空间填充为 b,后者表示把数组 a 从 key1 到 key2 的全部内容填充为 b,但不包含 key2 的位置。

      1
      2
      3
      4
      5
      6
      7
      8
      char charArrayOne[] = {'a', 'b', 'c', 'd', 'e', 'f'};
      char charArrayTwo[] = new char[5];

      // 把 char 类型的数组 charArrayOne 的第四和第五个位置的元素填充为 't'
      Arrays.fill(charArrayOne, 4, 6, 't');

      // 把 char 类型的数组 charArrayTwo 的所有元素填充为 'p'
      Arrays.fill(charArrayTwo, 'p');
  • 数组填充方法列表

不同参数类型的方法 方法说明
fill(boolean[] a, boolean b) 填充 boolean 型数据
fill(char[] a, char b) 填充 char 型数据
fill(float[] a, float b) 填充 float 型数据
fill(double[] a, double b) 填充 double 型数据
fill(byte[] a, byte b) 填充 byte 型数据
fill(short[] a, short b) 填充 short 型数据
fill(int[] a, int b) 填充 int 型数据
fill(long[] a, long b) 填充 long 型数据
fill(Object[] a, Object b) 填充 Object 型数据
fill(boolean[] a, int key1, int key2, boolean b) 部分填充 boolean 型数据
fill(char[] a, int key1, int key2, char b) 部分填充 char 型数据
fill(float[] a, int key1, int key2, float b) 部分填充 float 型数据
fill(double[] a, int key1, int key2, double b) 部分填充 double 型数据
fill(byte[] a, int key1, int key2, byte b) 部分填充 byte 型数据
fill(short[] a, int key1, int key2, short b) 部分填充 short 型数据
fill(int[] a, int key1, int key2, int b) 部分填充 int 型数据
fill(long[] a, int key1, int key2, long b) 部分填充 long 型数据
fill(Object[] a, int key1, int key2, Object b) 部分填充 Object 型数据

4.3 数组比较

  • 数组的比较是对两个数据类型相同的数组而言的,实现比较的函数为 equals(数组 1, 数组 2)。如果两个数组的数据元素数量相同,相同位置上的数据元素又相等,则这两个数组相等,函数返回 boolean 值 true,否则不相等,函数返回 boolean 值 false。

    1
    2
    3
    4
    5
    6
    7
    8
    char charArray1[] = {'a','b','c','e','f','g','h','I','j','k'};
    char charArray2[] = {'a','b','c','e','f','g','h','I','j','k'};

    double doubleArray1[] = {12.0, 99.43, 33, 2, 22, 56.9};
    double doubleArray2[] = {12.0, 99.43, 33};

    boolean result1 = Arrays.equals(charArray1, charArray2); // 返回 true,类型和元素数量相同
    boolean result3 = Arrays.equals(doubleArray1, doubleArray2); // 返回 false,元素数量不同
  • 数组比较方法列表

不同参数类型的方法 方法说明
equals(boolean[] a, boolean[] b) 比较两个 boolean 类型的数组,返回 boolean 类型
equals(char[] a, char[] b) 比较两个 char 类型的数组,返回 boolean 类型
equals(float[] a, float[] b) 比较两个 float 类型的数组,返回 boolean 类型
equals(double[] a, double[] b) 比较两个 double 类型的数组,返回 boolean 类型
equals(byte[] a, byte[] b) 比较两个 byte 类型的数组,返回 boolean 类型
equals(short[] a, short[] b) 比较两个 short 类型的数组,返回 boolean 类型
equals(int[] a, int[] b) 比较两个 int 类型的数组,返回 boolean 类型
equals(long[] a, long[] b) 比较两个 long 类型的数组,返回 boolean 类型

4.4 数组排序

  • 数组的排序指依据数组中的数据类型升序排序,如果是整数类型则按照从小到大的顺序,如果是字符(char)类型则按照字母升序排列。数组的排序方法为静态方法,可以直接调用,Java 提供了两种参数格式。

    • 一是 sort(数组引用);
    • 二是 sort(数组引用, 参数 1, 参数 2);
    • 前者对整个数组升序排序,而后者对数组中的一个范围内的元素排序,参数 1 是起始位置,参数 2 是截止位置,但不包含该位置。

      1
      2
      3
      4
      5
      6
      7
      char charone[] = {'d', 'c', 'a', 'b'};

      // 整个数组排序
      Arrays.sort(charone); // a b c d

      // 部分排序
      Arrays.sort(charone, 0, 3); // a c d b
  • 数组排序方法列表

不同参数类型的方法 方法说明
sort(boolean[] a) 在 boolean 类型数组中排序,无返回类型
sort(char[] a) 在 char 类型数组中排序,无返回类型
sort(float[] a) 在 float 类型数组中排序,无返回类型
sort(double[] a) 在 double 类型数组中排序,无返回类型
sort(byte[] a) 在 byte 类型数组中排序,无返回类型
sort(short[] a) 在 short 类型数组中排序,无返回类型
sort(int[] a) 在 int 类型数组中排序,无返回类型
sort(long[] a) 在 long 类型数组中排序,无返回类型
sort(Object[] a) 在 Object 类型数组中排序,无返回类型
sort(boolean[] a, int key1, int key2) 在 boolean 类型数组中排序,无返回类型
sort(char[] a, int key1, int key2) 在 char 类型数组中排序,无返回类型
sort(float[] a, int key1, int key2) 在 float 类型数组中排序,无返回类型
sort(double[] a, int key1, int key2) 在 double 类型数组中排序,无返回类型
sort(byte[] a, int key1, int key2) 在 byte 类型数组中排序,无返回类型
sort(short[] a, int key1, int key2) 在 short 类型数组中排序,无返回类型
sort(int[] a, int key1, int key2) 在 int 类型数组中排序,无返回类型
sort(long[] a, int key1, int key2) 在 long 类型数组中排序,无返回类型
sort(Object[] a, int key1, int key2) 在 Object 类型数组中排序,无返回类型
sort(Object[] a, Comparator) 在 Object 类型数组中排序,无返回类型
sort(Object[] a, int key1, int key2, Comparator) 在 Object 类型数组中排序,无返回类型

4.5 数组查找

  • 数组的查找是在指定数据类型的数组中查找一个具体的元素,如在 int 型数组中查找一个整数,如果该整数存在,则输出该整数在数组中的位置。需要注意数组中元素的位置是从 0 开始记数的,如果该整数不存在则输出一个负数。在 Java 的数组(Arrays)操作中使用二分查找算法实现数组中元素的查找。

    1
    2
    3
    4
    int intone[] = {1, 2, 3, 8, 9, 12, 32, 44, 67, 89};

    int result1 = Arrays.binarySearch(intone, 12); // 5
    int result2 = Arrays.binarySearch(intone, 100); // -1
  • 数组排序方法列表

不同参数类型的方法 方法说明
binarySearch(boolean[] a, boolean key) 在 boolean 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(char[] a, char key) 在 char 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(float[] a, float key) 在 float 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(double[] a, double key) 在 double 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(byte[] a, byte key) 在 byte 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(short[] a, short key) 在 short 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(int[] a, int key) 在 int 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(long[] a, long key) 在 long 类型数组中搜索指定的类型元素,返回 int 型整数
binarySearch(Object[] a, Object key) 在 Object 类型数组中搜索指定的类型元素,返回 int 型整数
文章目录
  1. 1. 1、一维数组
    1. 1.1. 1.1 定义一维数组
    2. 1.2. 1.2 初始化一维数组
    3. 1.3. 1.3 使用一维数组
  2. 2. 2、二维数组
    1. 2.1. 2.1 定义二维数组
    2. 2.2. 2.2 初始化二维数组
    3. 2.3. 2.3 使用二维数组
  3. 3. 3、多维数组
  4. 4. 4、数组常见操作
    1. 4.1. 4.1 数组复制
    2. 4.2. 4.2 数组填充
    3. 4.3. 4.3 数组比较
    4. 4.4. 4.4 数组排序
    5. 4.5. 4.5 数组查找
隐藏目录