Java基础篇——数组

1、什么是数组

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

数组的三个基本特性：

1.  一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
2. 有序性：数组中的元素是有序的，通过下标访问。
3. 不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。

数组的特点：

• 数组可以是一维数组、二维数组或多维数组。
• 数值数组元素的默认值为 0，而引用元素的默认值为 null。
• 数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
• 数组元素可以是任何类型，包括数组类型。
• 数组类型是从抽象基类 Array 派生的引用类型。

2、一维数组

当数组中每个元素都只带有一个下标时，这种数组就是“一维数组”。一维数组（one-dimensional array）实质上是一组相同类型数据的线性集合，是数组中最简单的一种数组。

2.1、声明和创建

为了在程序中使用一个数组，必须声明一个引用该数组的变量，并指明整个变量可以引用的数组类型。声明和创建一维数组的语法格式为： 

//保存基本数据类型的数组
int[] arr1 = new int[10];  //常用，声明变量创建对象
int arr2[] = new int[10];  //不常用
int[] arr3;                //先声明变量
arr3 = new int[10];        //再创建对象，初始化变量
int arr4[];                //先声明变量,不常用
arr4 = new int[10];        //再创建对象，初始化变量

//保存引用数据类型的数组
Object[] arrObj1 = new Object[10];  //常用
Object arrObj2[] = new Object[10];  //不常用
Object[] arrObj3;                //先声明变量
arrObj3 = new Object[10];        //再创建对象，初始化变量
Object arrObj4[];                //先声明变量,不常用
arrObj4 = new Object[10];        //再创建对象，初始化变量

在创建数组对象时，必须指定长度，下面这种方式是错误的

  int[] arr = new int[]; //错误，必须指定数组长度

2.2、初始化

Java 语言中数组必须先初始化，然后才可以使用。所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。

正常的初始化方式，用基本数据类型数组举例说明，引用类型数组与之类似。

int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
int[] arr2 = new int[]{1,2,3,4,5,6,7,8,9,10};
int[] arr3 = new int[10];
arr3[0] = 1;
arr3[1] = 2;
arr3[2] = 3;
int[] arr4;
arr4 = new int[]{1,2,3,4,5,6,7,8,9,10};

错误的初始化方式，不能在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值 。

int[] arr = new int[10]{1,2,3,4,5,6,7,8,9,10};//错误，不能即指定长度，又初始化

错误的初始化方式，使用这种方式时，数组的声明和初始化操作要同步，即不能省略数组变量的类型

int[] arr;
arr = {1,2,3,4,5,6,7,8,9,10};

2.3、遍历

获取单个元素

int[] arr = {1,2,3,4,5,6,7,8,9,10};
System.out.println(arr[0]);
System.out.println(arr[3]);

获取全部元素，使用for循环方式

int[] arr = {1,2,3,4,5,6,7,8,9,10};
for (int i=0; i<arr.length; i++) {
    System.out.println(arr[i]);
}

获取全部元素，使用foreach循环方式

for (int val:arr) {
    System.out.println(val);
}

对于基础数据类型的数组，如果初始化值小于数组长度，系统将类型对应的默认值赋给未初始化的元素。例如：int[] arr = new int[10];  arr[2] = 2;  数组元素的值分别是{0,0,2,0,0,0,0,0,0,0}

对于引用数据类型的数组，如果初始化值小于数组长度，系统将null值赋给未初始化的元素。例如：Object[] arr = new Object[10]; arr[0] = new Object(); 数组元素的值分别是{Object对象引用,null,null,null,null,null,null,null,null}，因为数组中保存的是对象的引用，在没有初始化的情况下，调用对象的方法，将报空指针异常的错误。

动态初始化数组由系统决定每个数组元素的初始值，遵循以下规则：

• byte、short、int、long类型的数组的初始值为0
• float、double类型的数组的初始值为0.0
• char类型的数组的初始值为'\u0000'，表现为空字符''，但要占位
• boolean类型的数组的初始值为false
• 引用类型的数组的初始值为null

2.4、内存结构分析

基本数据类型

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

String引用数据类型数组 

String[] books = new String[]{"疯狂Java讲义","Thinking in Java","Java核心技术卷"};
String[] names = {"张三","李四","王五","赵六"};
String[] strArr = new String[5];

 引用数据类型数组

Person[] person = new Person[2];
Person p1 = new Person("张三",20);
Person p2 = new Person("李四",30);
person[0] = p1;
person[1] = p2;

3、二维数组

当数组中每个元素都只带有两个下标时，这种数组就是“二维数组”。一个二维数组实际上就是多个一维数组

3.1、声明和创建

int[][] arr1 = new int[2][3];
int arr2[][] = new int[2][3];
int[][] arr3 = new int[2][];

3.2、初始化 

int[][] arr1 = {{1,2,3}, {4,5,6}};
int[][] arr2 = new int[][]{{1,2,3}, {4,5,6}};
int[][] arr3 = new int[2][3];
arr3[0][0] = 1;
arr3[1] = new int[]{1,2,3};

3.3、遍历

获取单个元素

int[][] arr = {{1,2,3}, {4,5,6}};
System.out.println(arr[1][0]);

使用for循环，获取全部元素

for (int i=0; i<arr.length; i++) {
    for (int j=0; j<arr[i].length; j++)
    System.out.println();
} 

 使用foreach获取全部元素 

for (int[] val1:arr) {
    for (int val2:val1) {
        System.out.println(val2);
    }
}

3.4、内存分析

基本数据类型的二位数组 

int[][] a = new int[4][2];
a[0] = new int[] {0,2};

 内存结构分析

4、多维数组

除了一维数组和二维数组外，Java 中还支持更多维的数组，如三维数组、四维数组和五维数组等，它们都属于多维数组。经过前面一维，二维的练习后不难发现，想要提高数组的维数，只要在声明数组时将索引与中括号再加一组即可，所以三维数组的声明为 int score[][][]，而四维数组为 int score[][][][]，以此类推。

多维数组最终都能转为一维数组，比如 int[][][]...[​​​​​] 可以转化为 ***...* 个 int[]个一维数组。