小白学习生涯第六章：数组的学习

一、数组
概念：数组就是保存一组相关变量的数据类型，数组不属于基本数据类型，属于引用数据类型。

数组的创建方式在JAVA中有三种：
第一种 ：数据类型 [] 数组名 = new 数据类型 [数组的长度]
第二种 ：数据类型 [] 数组名 = new 数据类型 [ ] {元素，元素，元素。。。}
第三种 ：数据类型 [] 数组名 = {元素，元素，元素。。。}
注意：
1、数组的名称要按照标识符的命名规则（第一个字符必须是英文大小写，下划线，美元符号，不能是数字）
2、一个数组只能保存一种数据类型（除了object类型的数组之外）
3、new关键字表示在内存中开辟空间来保存数据

第一种声明方式：
demo：

//第一种声明方式，该数组可以保存5个int类型的数据
		int [] Shuzu = new int [5];
		//.length函数是获取数组的长度
		System.out.println(Shuzu.length);
		//此时数组有5个元素，它们都有默认值，该元素的默认值就是0；

第二种声明方式：

	//第二种声明方式,该数组已经保存了我们指定的数据
		int [] Shuze1 = new int [] {1,2,3,4,5};
		System.out.print(Shuze1.length);
		}

第三种声明方式：

int [] Shuzu2 = {1,2,33,4,5};

数组的内存分配结构：
一个数组如果要有意义，那么必须能操作数组中的元素，要操作数组中的元素，就得访问数组元素
数组元素的访问使用的是 “ 数组名 [下标] ”的方式去访问，下标是从0开始，所以数组的元素的最后一个下标就是数组的长度减去一。
如果要真正了解数组元素的访问，那么你要理解数组数据在内存中是如何分配的，当创建了一个数组的时候在内存中其实是使用两块空间，这两块空间分别是栈和堆。 其中堆中保存的是数组真正的数据，那么这个数组在堆中有一个地址，这个地址保存到栈中，那么访问数据的时候只要找到这个地址就能操作堆中的数组中的数据了（在堆中的数组是一个连续的空间）

如何取得数组的元素？

int [] arr =  new int [] {1,44,55,33,231} ;
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}

为数组元素赋值

	int [] Shuze1 = new int [] {1,2,3,4,5};
		for (int i = 0; i < Shuze1.length; i++) {
			if (i % 2 == 0) {//如果下标为偶数时才赋值
				System.out.println(Shuze1[i]);
			}
		}

使用while循环遍历数组

	int fw = 0 ;
		int [] Shuze1 = new int [] {1,2,3,4,5};
		while (fw < Shuze1.length) {//为什么不能 <= ?
							//如果=7.那么数组下标为[5]，数组最大的下标为[4]
			System.out.print(Shuze1[fw] + " ");
			fw++;	
			}
		

总结：
1、数组的内存分配结构需要记住；
2、数组元素的访问机制需要理解

二维数组的学习：
二位数组的声明方式：
数据类型 [] [] 数组名称 = {{数组一}，{数组二} …}
数据类型 [] [] 数组名称 = new 数据类型 [长度] [长度]
数据类型 [] [] 数组名称 =new 数据类型 [长度] [ ];
数据类型 [] [] 数组名称 =new 数据类型 [] [] {{初始值1}，{初始值2}，{初始值3}};

方式1：数据类型 [] [] 数组名称 = {{数组一}，{数组二} …}:
demo： int [] [] arr = { {1,2},{3,4},{5,6}}

方式二：数据类型 [] [] 数组名称 = new 数据类型 [长度] [长度]
demo：

int [] [] p = new int [3] [2];
		//为数组元素赋值
		p [0] [0] = 13;
		p [0] [1] = 14;
		p [1] [0] = 15;
		p [1] [1] = 16;
		p [2] [0] = 17;
		p [2] [1] = 18;
		//遍历数组
		for (int i = 0; i < p.length; i++) {
			for (int j = 0; j < p[i].length; j++) {
				System.out.print(p[i][j]+" ");
			}
		}

第三种：数据类型 [] [] 数组名称 =new 数据类型 [长度] [ ];
demo；
如果按照以下写法，会出现异常报错，说明程序正在访问一个不存在的数组对象
即是说int [] [] p = new int [3] [];只是创建外层数组，内层数组还是不存在，还是null；需要创建内存数组

int [] [] p = new int [3] [];
		//为数组元素赋值
		p [0] [0] = 13;
		p [0] [1] = 14;
		p [1] [0] = 15;
		p [1] [1] = 16;
		p [2] [0] = 17;
		p [2] [1] = 18;
		//遍历数组
		for (int i = 0; i < p.length; i++) {
			for (int j = 0; j < p[i].length; j++) {
				System.out.print(p[i][j]+" ");
			}
		}

如果用以下代码访问：

int [] [] p = new int [3] [];
System.out.print(p[0]);

会输出空。

正确的声明方式写法：

int [] [] p = new int [3] [];
		//创建内层数组
		for (int i = 0; i < p.length; i++) {
			p [i] = new int [i+1] ;//[i+1]为每一个内层数组的长度，参考于一维数组
		}
		//为数组元素赋值
		p[0][0] = 1;
		p[1][0] = 2;
		p[1][1] = 3;
		p[2][0] = 4;
		p[2][1] = 5;
		p[2][2] = 6;
		for (int i = 0; i < p.length; i++) {//遍历外层数组
			System.out.print("第"+(i+1)+"个小数组（内层数组）的内容为： ");
			for (int j = 0; j < p[i].length ; j++) {//分别对每个内层数组遍历
				System.out.print(p[i][j] + ",");
			}
			System.out.println();
		}

第四种声明方式：数据类型 [] [] 数组名称 =new 数据类型 [] [] {{初始值1}，{初始值2}，{初始值3}};

	double nums [] []  = new double [] [] {{1,2},{3,4},{5,6},{7,8}};
		for (int i = 0; i < nums.length; i++) {//遍历外层数组
		System.out.print("第"+(i+1)+"个小数组（内层数组）的内容为： ");
			for (int j = 0; j < nums[i].length ; j++) {
				System.out.print(nums[i][j] + ",");
			}
			System.out.println();
	}

//如何访问二位数组
 int [] [] arr = { {1,2},{3,4},{5,6}} ;
		//如何访问二位数组的 1 元素？ 答：arr[0][0]
		//如何访问二位数组的3？arr[1][0]
		//如何访问二位数组的6？arr[2][0]

遍历二维数组：

 int [] [] arr = { {1,2},{3,4},{5,6},{7,8}} ;
		 for (int i = 0; i < arr.length; i++) {//只能遍历外层数组
			for (int j = 0; j < arr[i].length; j++) {//分别对每个内层数组遍历
				System.out.print(arr[i][j] + "，");
			}
		}

for循环的加强使用：
加强的for循环在遍历数组的饿时候不需要再声明初始化变量了，也可以不知道数组的长度。
demo：
这是加强的for循环实现遍历

int [] nums = {2,3,4,5,67,231};
		for (int temp:nums) {
			System.out.println(temp + ",");
		}

表示需要遍历数组中的所有元素（数组中的每个元素都要取出来一次），每次取出的元素保存到temp，保存完毕之后执行循环体的内容，循环体执行完毕之后取数组的下一个元素保存到temp再执行循环体，一直这样循环下去，知道数组的最后一个元素。

数组越界异常：
在定义玩数组的时候，数组 长度就已经确定了，如果我们在访问数组元素的时候超过下标的范围，就会出现数组异常