008、java数组

一、数组的定义
数组:存储同一种数据类型的多个元素的容器。
	
	定义格式：
		A:数据类型[] 数组名;
		B:数据类型 数组名[];
		
	举例：
		A:int[] a; 定义一个int类型的数组a变量
		B:int a[]; 定义一个int类型的a数组变量
		
	注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。
    推荐使用第一种。

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

如何对数组进行初始化呢?
		A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值
		B:有几种方式呢?
			a:动态初始化 只指定长度，由系统给出初始化值
			b:静态初始化 给出初始化值，由系统决定长度
			
	1、动态初始化的格式：
		数据类型[] 数组名 = new 数据类型[数组长度];
		举例：
		int[] arr = new int[3];	
左边：
				int:说明数组中的元素的数据类型是int类型
				[]:说明这是一个数组
				arr:是数组的名称	
			右边：
				new:为数组分配内存空间。
				int:说明数组中的元素的数据类型是int类型
				[]:说明这是一个数组
				3:数组长度，其实也就是数组中元素的个数
		
		如何获取数组中的元素呢?
			通过:
				数组名[索引]
				索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。

2、数组的静态初始化：
		格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
		简化格式：
			数据类型[] 数组名 = {元素1,元素2,…};
		
		举例：
			int[] arr = new int[]{1,2,3};
			简化后：
			int[] arr = {1,2,3};
			
		注意事项：
			不要同时动态和静态进行。
			如下格式：int[] arr = new int[3]{1,2,3}; //错误


三、数组中常见的异常
		ArrayIndexOutOfBoundsException:数组索引越界异常
			原因：你访问了不存在的索引。
		NullPointerException:空指针异常
			原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。


四、数组获取最值(获取数组中的最大值最小值)
分析：
		A:定义一个数组，并对数组的元素进行静态初始化。
		B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
		C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
		D:最后参照物里面保存的就是最大值。

1、获取最大值
public static int getMax(int[] arr) {
			//从数组中任意的找一个元素作为参照物
			int max = arr[0];
			//然后遍历其他的元素
			for(int x=1; x<arr.length; x++) {
				//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
				if(arr[x] > max) {
					max = arr[x];
				}
			}
			//最后参照物里面保存的就是最大值。
			return max;
		}
2、获取最小值
public static int getMin(int[] arr) {
			//从数组中任意的找一个元素作为参照物
			int min = arr[0];
			//然后遍历其他的元素
			for(int x=1; x<arr.length; x++) {
				//依次获取和参照物进行比较，如果小就留下来，如果大，就离开。
				if(arr[x] < min) {
					min = arr[x];
				}
			}
			//最后参照物里面保存的就是最小值。
			return min;
		}

五、数组元素逆序 (就是把元素对调)
分析：
		A:定义一个数组，并进行静态初始化。
		B:思路
			把0索引和arr.length-1的数据交换
			把1索引和arr.length-2的数据交换
			...
			只要做到arr.length/2的时候即可。
public static void reverse(int[] arr) {
		/*
		//第一次交换
		int temp = arr[0];
		arr[0] = arr[arr.length-1-0];
		arr[arr.length-1-0] = temp;
		
		//第二次交换
		int temp = arr[1];
		arr[1] = arr[arr.length-1-1];
		arr[arr.length-1-1] = temp;
		
		//第三次交换
		int temp = arr[2];
		arr[2] = arr[arr.length-1-2];
		arr[arr.length-1-2] = temp;
		*/
		//用循环改进
		for(int x=0; x<arr.length/2; x++) {
			int temp = arr[x];
			arr[x] = arr[arr.length-1-x];
			arr[arr.length-1-x] = temp;
		}
	}
	

六、二维数组
二维数组：就是元素为一维数组的一个数组。
	
	格式1：
		数据类型[][] 数组名 = new 数据类型[m][n];
		
		m:表示这个二维数组有多少个一维数组。
		n:表示每一个一维数组的元素有多少个。
		
	注意：
		A:以下格式也可以表示二维数组
			a:数据类型 数组名[][] = new 数据类型[m][n];
			b:数据类型[] 数组名[] = new 数据类型[m][n];
		B:注意下面定义的区别
			int x;
			int y;
			int x,y;
			
			int[] x;
			int[] y[];
			
			int[] x,y[];
举例：
//定义一个二维数组
		 int[][] arr = new int[3][2];

格式2：
		数据类型[][] 数组名 = new 数据类型[m][];
		
		m:表示这个二维数组有多少个一维数组。
		列数没有给出，可以动态的给。这一次是一个变化的列数。

举例：
//定义数组
			int[][] arr = new int[3][];

			//动态的为每一个一维数组分配空间
			arr[0] = new int[2];
			arr[1] = new int[3];
			arr[2] = new int[1];

格式3：
		基本格式：
			数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
		简化版格式：
			数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
			
		举例：
			int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
			int[][] arr = {{1,2,3},{4,5},{6}};

/*
		需求：遍历二维数组
	*/
	public static void printArray2(int[][] arr) {
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				System.out.print(arr[x][y]+" ");
			}
			System.out.println();
		}
	}

/*
二维数组求和
*/
public static void main(String[] args) {
		//把题目的数据用二维数组来表示
		int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
		
		//定义一个求和变量sum，初始化值是0。
		int sum = 0;
		
		//通过遍历就可以得到每一个二维数组的元素。
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				//把元素累加即可。
				sum += arr[x][y];
			}
		}
		
		//最后输出sum，就是结果。
		System.out.println("一年的销售额为："+sum+"万元");
	}