Java————数组

1 、数组

数组可以看成是相同类型元素的一个集合，
在内存中是一段连续的空间。

每个空间有自己的编号，其实位置的编号为0，即数组的下标。

数组是引用类型。

1. 数组的创建

T[] 数组名 = new T[N];


T：表示数组中存放元素的类型 
T[]：表示数组的类型 
N：表示数组的长度



int[] array1 = new int[10];       // 创建一个可以容纳10个int类型元素的数组 
double[] array2 = new double[5];  // 创建一个可以容纳5个double类型元素的数组 
String[] array3 = new double[3];  // 创建一个可以容纳3个字符串元素的数组
1
2
3
4
5
6
7
8
9
10
11
12

2. 数组的初始化

如果没有对数组进行初始化，数组中元素有其默认值。

如果数组中存储元素类型为引用类型，默认值为null。

如果数组中存储元素类型为基类类型，
默认值为基类类型对应的默认值，比如：

• 静态初始化：
  在创建数组时不直接指定数据元素个数，
  而直接将具体的数据内容进行指定。

  静态初始化虽然没有指定数组的长度，
  编译器在编译时会根据{}中元素个数来确定数组的长度。

  静态初始化时, {}中数据类型必须与[]前数据类型一致。

  静态初始化可以简写，省去后面的new T[]。

T[] 数组名称 = {data1, data2, data3, ..., datan};


int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0}; 
String[] array3 = new String[]{"hell", "Java", "!!!"};


// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原 int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};


// 静态和动态初始化也可以分为两步，但是省略格式不可以。
int[] array1;
array1 = new int[10];

 
int[] array2;
array2 = new int[]{10, 20, 30};

 
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};
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

• 动态初始化：
  在创建数组时，直接指定数组中元素的个数。

int[] array = new int[10];
1

3. 数组的使用

数组在内存中是一段连续的空间，
支持随机访问，即通过下标访问快速访问数组中任意位置的元素。

下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，
否则会报出下标越界异常。

int[] array = {1, 2, 3};
System.out.println(array[3]);  // 数组中只有3个元素，下标一次为：0  1  2，array[3]下标越界


// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
        at Test.main(Test.java:4)


使用数组一定要下标谨防越界.
1
2
3
4
5
6
7
8
9
10
11

4. 遍历数组

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
    System.out.println(array[i]);

}



// 也可以使用 for-each 遍历数组

int[] array = {1, 2, 3};
for (int x : array) {
    System.out.println(x);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15