【疯狂Java】数组

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);//20System.out.println("b:" + b);//20b = 13;//将13存入b所在的内存System.out.println("a:" + a);//20System.out.println("b:" + b);//13int[] arr = new int[] {20};//引用类型赋值：将该对象所在首地址存入变量int[] brr = arr;//引用类型赋值：将该对象所在首地址存入变量System.out.println("arr[0]:" + arr[0]);//20System.out.println("brr[0]:" + brr[0]);//20brr[0] = 13;System.out.println("arr[0]:" + arr[0]);//13System.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();
}