基本介绍

数组可以存放多个同一类型的数据。数组也是一种数据类型，在java中是引用类型

数组定义方式

动态初始化

第一种

先声明数组类型，再分配内存空间

基本语法

1
2
数据类型[] 数组名;
数组名 = new 数据类型[数组大小];

如：

1
2
double[] scores; // 声明一个double类型的一维数组
scores = new double[10];// 给这个数组分配10个double大小空间

第二种

直接定义数组，在声明的同时分配内存空间

基本语法

1
数据类型[] 数组名 = new 数据类型[数组大小];

如：

1
double[] = new double[10]; // 定义了一个10个double大小的double数组

静态初始化

在定义数组的同时，指定数组的元素个数和各元素数值

基本语法

1
数据类型[] 数组名 = {元素1,元素2,元素3,……,元素n};

如：

1
2
// 定义一个数组大小为5，元素分别为1,2,3,4,5的数组
int[] nums = {1, 2, 3, 4, 5};

细节

  1. 数组数据类型可以是基本数据类型和引用数据类型

  2. 数组括号位置允许以下几种方式，但是建议选择方式1

1
2
3
int[] nums = new int[10]; // 方式1
// 或 
int nums[] = nwe int[10]; // 方式2

  1. 动态初始化的数组元素，有默认的初始值，具体根据数组的类型而定

    数据类型 初始值
    byte 0
    short 0
    int 0
    long 0
    float 0.0L
    double 0.0
    char \u0000
    boolean false
    引用数据类型 null

获取数组长度

java可以通过数组的length属性来获取数组长度

基本用法

1
2
int[] nums = new int[10]; // 分配长度为10的数组
int length = nums.length; // length = 10

细节

  1. length是数组的一个属性，不是方法，没有括号

数组访问和遍历

访问

java中数组可以通过数组下标[]来访问数组中的元素

数组下标从0开始

基本用法

1
2
3
4
5
6
7
int[] nums = {1, 2, 3, 4, 5};
// 通过下标访问数组
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;

遍历

java中数组的遍历一般是结合循环来进行的

基本使用

1
2
3
4
5
6
7
8
9
10
11
int[] nums = {1, 2, 3, 4, 5};
// 遍历数组
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}
// 遍历结果如下：
// 1
// 2
// 3
// 4
// 5

数组赋值机制

  1. 数组名为引用数据类型，其存放的是数组内存空间的地址，数组赋值为引用传递

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
       int[] arr1 = {1, 2, 3};
       int[] arr2 = arr1;
       // 将{1, 2, 3}的内存地址赋给arr2，而不是数组的值
       // 这时arr1和arr2指向同一个数组空间，arr1和arr2都可改变数组的值

    2. 基本数据类型间赋值为值传递

    ## 二维数组

    ### 介绍

    二维数组是特殊的一维数组，二维数组的每一个元素都是一维数组

    **多维数组以此类推**

    ### 二维数组定义方式

    #### 动态初始化

    ##### 第一种

    先声明二维数组，再分配内存空间

    如

    ```java
    int[][] nums;
    nums = new int[2][3]; // 分配了一个2*3的二维数组
第二种

在声明二维数组时同时分配内存空间

如

1
int[][] nums = new int[2][3];

静态初始化

1
2
3
4
// 定义了一个3 * 3的二维数组
int[][] nums = { {1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9} };

细节

  1. 二维数组声明的形式有多种，推荐第一种

    1
    2
    3
    4
    5
    6
    // 第一种
    int[][] nums;
    // 第二种
    int [] nums[];
    // 第三种
    int nums[][];

  2. 二维数组中的一维数组的大小可以不同分配

    1
    2
    3
    int[][] nums = { {1}, 
                     {1, 2}, 
                     {1, 2, 3} };

  3. 动态分配而二维数组内存空间时，可以不指定一维数组的大小，此时二维数组的元素都为null

    1
    int[][] nums = new [3][];

获取数组长度

以下面的二维数组为例

1
2
3
4
// 定义了一个3 * 3的二维数组
int[][] nums = { {1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9} };
  1. nums.length表示二维数组中的一维数组个数，nums.length = 3
  2. nums[1].length表示第1行的一维数组{4， 5，6}的数组长度，nums[1].length = 3

访问二维数组

访问二维数组可以通过下标[][]进行访问

数组下标同样从0开始

1
2
3
4
5
6
// 定义了一个1 * 3的二维数组
int[][] nums = { {1, 2, 3 } };
// 访问
nums[0][0] = 1;
nums[0][1] = 2;
nums[0][2] = 3;

遍历二维数组

可以通过二重循环来进行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 定义了一个3 * 3的二维数组
int[][] nums = { {1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9} };
// 遍历
for (int i = 0; i < nums.length; i++) {
    for (int j = 0; j < nums.length; j++) {
        System.out.print(nums[i][j]);
    }
    System.out.println();
}
// 结果如下：
// 123 
// 456 
// 789 
//