1、一维数组
(1)初始化
①静态初始化：只指定元素，不指定长度
new 类型[] {元素1,元素2,...}
int[] intArr;
intArr = new int[] {5,6,7,8};②动态初始化：只指定长度，不指定元素
new 类型[数组长度]
int[] princes = new int[5];【注意】
- 如果数组元素的类型是基本类型中的整数类型（byte、short、int和long），则数组元素的值为0
- 如果数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的值为0.0
- 如果数组元素的类型是基本类型中的字符类型（char），则数组元素的值为'\u0000'
- 如果数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的值为false
- 如果数组元素的类型是引用类型（类、接口和数组），则数组元素的值为null
(2)使用数组
①length
该属性返回数组的长度
②访问数组元素
索引从0开始，最后一个元素的索引是length-1
使用的元素超出数组长度，就会导致ArrayIndexOutOfBoundsException（数组索引越界异常）
③遍历数组
④foreach循环遍历数组
数组有几个元素，该循环就执行几次，变量会自动、依次等于每个元素
foreach循环只能访问数组元素的值，不能修改数组元素的值。
for(元素类型 变量名 : 数组名)
{
//可通过变量名访问每个元素
}int[] iArr = new int[] {20,30,40,50};
for (int it : iArr) {
System.out.println(it);
}建议：永远不要在foreach循环中修改循环计算器的值
(3)深入理解数组
【Java程序，必须要使用虚拟机Virtual Machine（有些地方也称之为JVM）才能运行】
Java程序的内存可分为：
①堆(heap)内存：Java虚拟机启动时分配的一块永久的、很大的内存区。堆内存只有一块。
堆内存中对象，如果没有引用变量指向它，那么它就会变成垃圾，等待VM的垃圾回收器来回收。
public class 内存中的数组 {
public static void main(String[] args) {
//分配800个字节
long[] arr = new long[100];
arr[99] = 33;
System.out.println(arr[99]);
}
}
由于long数组需要分配800个字节，而虚拟机只有258个字节，所以报错“初始堆内存给的太少了”
②栈(stack)内存：每次方法运行分配一块临时、很小的内存区。每个方法都有自己对应的栈区，方法结束时，对应的栈区就会被回收。
- 在方法中定义的、局部变量（不管是什么类型），都放入对应的方法栈区。
- new出来的对象，都放在堆内存。
引用类型的变量是变量，对象是对象，两者是不同的东西。
例如：
int[] iArr = new int[4];iArr存在栈内存中，new出来的int[4]存在堆内存中。
【变量赋值的区别】
- 基本类型的赋值：直接将该值存入变量所在内存。
- 引用类型的赋值：将该对象所在第一个内存单元的编号（内存地址）存入变量。
下面使用代码+图来演示：
public class 内存中的数组 {
public static void main(String[] args) {
//基本类型的赋值
int it = 20; //4个字节
//iArr在栈内存，new出来的数组对象在堆内存
int[] iArr = new int[4]; //数组占16个字节
}
}
public class 内存中的数组 {
public static void main(String[] args) {
//基本类型的赋值
int it = 20; //4个字节
//iArr在栈内存，new出来的数组对象在堆内存
int[] iArr = new int[4]; //数组占16个字节
System.out.println(iArr.length);
//再次对引用变量赋值，让iArr重新指向一个新的数组
iArr = new int[] {20,10};
System.out.println(iArr.length);
}
} 
【验证自己是否真的理解基本类型和引用类型】
阅读一下代码，说出每个输出语句的输出结果。
public class 基本类型和引用类型 {
public static void main(String[] args) {
int a = 20;
int b = a;
System.out.println("a:" + a);
System.out.println("b:" + b);
b = 13;
System.out.println("a:" + a);
System.out.println("b:" + b);
int[] arr = new int[] {20};
int[] brr = arr;
System.out.println("arr[0]:" + arr[0]);
System.out.println("brr[0]:" + brr[0]);
brr[0] = 13;
System.out.println("arr[0]:" + arr[0]);
System.out.println("brr[0]:" + brr[0]);
}
}答案与解析：
package day04;
public class 基本类型和引用类型 {
public static void main(String[] args) {
int a = 20;
int b = a;//基本类型赋值：直接将值存入变量所在的内存
System.out.println("a:" + a);//20
System.out.println("b:" + b);//20
b = 13;//将13存入b所在的内存
System.out.println("a:" + a);//20
System.out.println("b:" + b);//13
int[] arr = new int[] {20};//引用类型赋值：将该对象所在首地址存入变量
int[] brr = arr;//引用类型赋值：将该对象所在首地址存入变量
System.out.println("arr[0]:" + arr[0]);//20
System.out.println("brr[0]:" + brr[0]);//20
brr[0] = 13;
System.out.println("arr[0]:" + arr[0]);//13
System.out.println("brr[0]:" + brr[0]);//13
}
}
2、没有多维数组
其实只有一维数组，二维数组是假象。
二维数组的本质：数组元素为一维数组的数组。
(1)初始化
①静态初始化
new 类型[]...[] {元素1,元素2,...}
int[][] arr = new int[][]{{1,2,3},{4,5,6,7},{8,9,10,11}};②动态初始化
new 类型[数组长度]...[数组长度]
int[][] arr = new int[5][];③静态和动态混着用
public class 二维数组静态初始化 {
public static void main(String[] args) {
//静态
int[][] arr = new int[][] {
new int[2],//元素用动态创建
new int[3],
new int[4]
};
System.out.println(arr.length);
//静态
int[][] brr = new int[][] {
new int[] {1,2},//元素用静态创建
new int[] {3,4,5},
new int[] {6,7,8,9}
};
System.out.println(brr.length);
//静态
int[][] crr = new int[][] {
new int[4],//元素用动态创建
{1,2,3},//元素用静态的简化语法创建
new int[3]//元素用动态创建
};
System.out.println(crr.length);
}
}④二维数组简化初始化
//创建一个长度为4的数组，其中每个元素都是动态初始化的长度为5的数组
int[][] arr = new int[4][5];
//相当于
int[][] brr = new int[][] {
new int[5],
new int[5],
new int[5],
new int[5],
new int[5],
};(2)对数组元素赋值
【常见错误】
int[][] arr = new int[5][];
//对数组元素赋值
//arr[0]是数组元素，是int[]类型，20是int
arr[0] = 20;(3)使用数组
遍历
int[][] arr = new int[][] {
new int[2],//元素用动态创建
new int[3],
new int[4]
};
for (int i = 0; i < arr.length; i++) {
//arr[i]是int[]类型
int[] brr = arr[i];
for (int j = 0; j < brr.length; j++) {
System.out.print(brr[j] + "\t");
}
System.out.println();
}
