java—数组1（数组常见问题，操作数组）

数组概念：是一种容器，可以同时存放多个数值

数组特点：
	1. 数组是一种引用数据类型
	2. 数组当中的多个数据，类型必须统一
	3. 数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值

两种常见的初始化方式：
	1. 动态初始化（指定长度）
		在创建数组的时候，直接指定数组中的数据元素个数
		
		格式： 数据类型[] 数组名称 = new 数据类型[数组长度]；
		
		数据类型：数组中保存的数据，全部都是统一的什么类型
		[] : 代表是一个数组
		数组名称·： 给数组取一个名字
		new： 代表创建数组的动作
		右侧的数据类型：必须和左边的数据类型保持一致
		[数组长度]： 就是数组中，可以保存多少个数据，是一个int 数字
	2. 静态初始化（指定内容）
		在创建数组时，不指定数据个数多少，而是直接将具体的数据内容进行指定

		格式： 数据类型[] 数组名称 = new 数据类型[] { 元素1， 元素2， ... }；
		省略格式：数据类型[] 数组名称 ={ 元素1， 元素2， ... }；
	
	注意：
		1. 虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度
		2. 静态初始化标准格式可以拆分为两个步骤
		3. 动态初始化也可以拆为两个步骤
		4. 静态初始化一旦使用省略格式，不能拆分为两个步骤
		
	使用建议：
		如果 不确定数组当中的具体内容，用动态初始化；
		否则，已经确定了具体内容，用静态初始化

public class Demo {
	public static void main(String[] args) {
		// 创建一个数组，里面可以存300个int数据
		int[] arrayA = new int[300]; // 动态初始化

		// 创建一个数组，里面全是int数字，具体为：5、15、25
		int[] arrayB = new int[] {  // 静态初始化
			5, 15, 25
		};
		int[] arrayC = { 5, 15, 25 };

		// 动态初始化标准格式可以拆分为两个步骤
		int[] arrayD;
		arrayD = new int[5];

		// 静态初始化标准格式可以拆分为两个步骤
		int[] arrayD;
		arrayD = new int[] { 1, 2, 3 };
	}
}

访问数组元素：
	直接打印数组名称，得到的是数组对应的：内存地址哈希值
	二进制： 01
	十进制： 0123456789
	十六进制： 0123456789abcdef

访问数组元素的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号
【注意】索引值是从0开始，一直到“数组的长度 - 1”为止

public class Demo {
	public static void main(String[] args) {
		// 静态初始化的省略格式
		int[] array = { 1, 2, 3 };
		System.out.println(array); // [I@1540e19d
		
		// 直接打印数组中的元素
		System.out.println(array[0]); // 1 
		System.out.println(array[1]); // 2 
		System.out.println(array[2]); // 3 
		
		// 也可以将数组中的某一个单个元素，赋值交给变量
		int num = array[1];
		System.out.println(num); // 2

		/* 动态初始化数组的时候，其中的元素有一个默认值，规则：
		如果是整数类型，默认为0
		浮点类型，默认为0.0
		字符类型，默认为'\u0000'
		布尔类型，默认为false
		引用类型，默认为null

		注意：静态初始化其实也有默认值的过程，只不过系统自动
		将默认值替换成为了大括号当中的具体数值
		*/
		int[] arrayB = new int[3];
		System.out.println(arrayB); // 内存地址值
		System.out.println(arrayB[0]); // 0
		System.out.println(arrayB[1]); // 0 
		System.out.println(arrayB[2]); // 0 
		arrayB[0] = 123;
		System.out.println(arrayB[0]); // 123
		System.out.println(arrayB[1]); // 0 
		System.out.println(arrayB[2]); // 0 
	}
}

java的内存划分成5个部分
1. 【栈（Stack）】：存放的都是方法中的局部变量。【方法的运行一定要在栈当中】
	局部变量：方法的参数，或者是方法{}内部的变量
	作用域：一旦超出作用域，立刻从栈内存中消失
2.【 堆（Heap）： 凡是new出来的东西，都在堆内存中。】
		堆内存里面的东西都有一个地址值：16进制
		堆内存里面的数据，都有默认值，规则：
			如果是整数，默认为0
			浮点数   =>   0.0
			字符     =>   "\u0000"
			布尔     =>   fasle
			引用类型  =>   null
3. 【方法区（Method Area）】：存储class相关信息，包含方法的信息
4. 本地方法栈（Native Method Stack）：与操作系统有关
5. 寄存器（pc Register）：与CPU相关
把方法信息加载到栈中，在栈中开辟空间，new出来的都在堆中，栈中存的只是堆中的地址

1. 数组常见问题

   数组索引越界
   	数组的索引从0开始，一直到“数组的长度-1”为止
   	如果访问的数组元素，索引编号并不存在，那么将会发生数组索引越界异常
   	ArrayIndexOutOfBoundRxception
   	原因：没有找到数组索引编号的元素
   
   空指针异常
   	所有的引用类型的变量，都可以赋值为一个null值，代表其中什么都没有
   	数组必须进行new初始化才能使用其中的元素，否则空指针异常
   	NullPointerException
   	原因：没有new
   

   // 数组索引越界
   int[] array = { 1, 2, 3};
   System.out.println(array[3]); // 报错 ArrayIndexOutOfBoundRxception
   
   // 空指针异常
   int[] arrayA; // => int[] arrayA = null;
   // array = new int[3];
   System.out.println(arrayA[0]); // 报错 NullPointerException
   
   

2. 操作数组

   1. 获取数组长度 :  .length      （会得到一个int数字，代表数组长度）
   	数组一旦创建，程序运行期间，长度不可改变
   

   int[] arrayA = new int[3];
   
   int[] arrayB = { 1, 12, 13, 14, 15, 44, 55, 66 };
   System.out.println(arrayB.length); // 8
   

   2. 遍历数组
   	对数组中的每一个元素进行逐一处理
   

   int[] array = {1,2,3};
   
   // 循环遍历
   for (int i = 0; i < array.length; i++) {
   	System.out.println(array[i]);
   }
   
   

   3. 数组的反转 (修改原数组)
   	[1,2,3]   =>  [3,2,1]		
   

   int[] array = {1,2,3};
   for (int min = 0,max = array.length; min < max; min++, max--) {
   	int temp = array[min];
   	array[min] = array[max];
   	array[max] = temp;
   }