Java数组

一.数组的定义

数组就是一个变量，用来存放相同类型的数据，在内存中划分一个连续的空间

二.数组的作用

用来存放一组相同数据类型的数据

三.数组的基本要素

（1）标识符：数组名字；

（2）数组元素：存放的数据；

（3）元素下标：从0开始，编号；

（4）数组的类型：数据类型

四.使用数组的四个步骤

（1）第一步：先声明一个数组

 数据类型[]数组名；/ 数据类型 数组名[]；

（2）第二步：分配数组的空间

 数组名 = new 数据类型[大小]； eg：scores = new int[10]；

（3）第一、第二步：声明分配空间

 数据类型[] 数组名 = new 数据类型[大小]；

 数组当中的数据类型必须一致

（3）第三步：给数组赋值 -----下标从0开始

 数组名[下标] = 值；

 eg：scores[0] = 10；

（4）第四步：使用数组
 
注意：
数组的长度只能给一次
数组的长度固定不变，避免数组下标越界
 
数组下标从0开始的原因：

a[i]_address = base_adderss + i*data_type_size

a[i]_address = base_adderss +(i-1)*type_size 

计算机会给每个内存单元分配一个地址，计算机通过地址来访问内存中的数据，当计算机需要随机访问数组中的某个元素时，会通过公式计算出，对比两个公式，可知从一开始的每次访问多了一次减法运算，对于CPU来说就多了一次减法指令，作为非常基础的数据结构，通过下标随机访问数组元素，又是其非常基础的编程操作，效率优化就要尽可能做到极致，所以为了减少减法操作，数组下标从0开始。
 
历史原因：
C语言设计者用0开始设计数组下标，之后的JavaScript等高级语言都效仿C语言或者说一定程度上减少C语言程序程序员学习java的学习成本,因此继续沿用了从0开始,有些语言甚至会出现负数下标 比如:python
 

五.数组中各种数据类型的默认值

（1）基本数据类型：

1）整型：byte、short、int、long -----默认值：0

2)浮点型：float、double ----默认值：0.0

3）布尔类型：booble -----默认值：false

4）字符型：char ----默认值：空格
 
（2）引用数据类型：

引用数据类型：String ----默认值：null

六.如何给数组一起赋值

（1）第一种：边声明，边赋值

	//第一种
	int[] scores = {99,88,100};  //常用格式
	//第二种
	String[] names = new String[] {"张三","李四","王五"};
	//第三种
	int[] num = new int[3];
	num[0]=5;
	num[1]=8;
	num[2]=9;

声明并赋值的时候，必须在一条语句中完成
 
（2）第二种：动态的从键盘录入

		int[] nums = new int[3];
		Scanner input = new Scanner(System.in);
		//给数组赋值
		for(int i=0;i<3;i++) {
			System.out.println("请输入第"+(i+1)+"个数：");
			nums[i] = input.nextInt();
		}
		//输出一下数组
		for(int i=0;i<3;i++) {
			System.out.print(nums[i]+"\t");
		}

获取数组的长度： 数组名.length;
 

七.java中的内存——CPU

内存分类：寄存器，栈内存，堆内存，方法区
 
寄存器：速度最快
 存放临时参与计算的结果等
 
栈内存： 速度紧次于寄存器，先进后出，后进先出
 基本数据类型变量、数组名、引用数据类型的变量名
 
堆内存：速度慢，先进先出，后进后出
 对象（具体的对象值）、数组（具体的数组元素）
 
GC 垃圾回收器
 

八.数组下标越界

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

数组下标从0开始到“数组名.length-1”结束
数组下标超出数组长度就会出现异常

九.向数组中插入数据

		int[] nums = {99,88,66,44,22,0};
		int data = 70;
		//第一步：找到插入的下标
		int index =0;
		for(int i=0;i<nums.length;i++) {
			if(data>nums[i]) {
				index=i;
				break;
			}
		}
		//第二步：下标之后的数据后移
		for(int i =nums.length-1;i>index;i--) {
			nums[i]=nums[i-1];
		}
		//第三步：插入数据
		nums[index]= data;
		//输出数据：
		for(int num:nums) {
			System.out.print(num+"\t");
		}

十.冒泡排序（升序）

（1）外层循环控制轮数
（2）内层循环，两两比较，然后交换数

口诀：
（1）N 个数字来排队
（2）两两比较小靠前
（3）外层循环N-1
（4）内存循环N-1-i

	int[] nums = {42,59,31,56,94,20};
	//外层循环控制轮数
	for(int i = 0;i<nums.length-1;i++){
		//内层循环，两两比较，然后交换数
		for(j = 0;j<nums.length-1-i;j++){
			if(nums[j]>nums[j+1]){
				int temp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = temp;
			}
		}
	}

十一.选择排序

自己选择升序还是降序
 
（1）外层循环控制轮数
（2）选出最大值或者最小值
（3）然后进行交换

	int[] nums = {42,59,31,56,94,20};
	//外层循环控制轮数
	for(int i = 0;i<nums.length-1;i++){
		int minindex = i;//最小数字的下标
		for(int j = i;j<nums.length;j++){
			if(nums[minindex]>nums[j]){
				minindex = j;	
			}
			//交换数据
			if(minindex != i){
				int temp = nums[i];
				nums[i] = nums[minindex];
				nums[minindex] = temp;
			}
		}
	}
	for(int i : nums){
		System.out.print(i + "\t");
	}

十二.操作数组的工具类Arrays类

int[] nums = new int[10];
（1）Arrays.sort(nums );       给数组进行升序排序
（2）Arrays.equals(nums ,nums1);    比较的是地址
（3）Arrays.toString(nums );     字符串形式输出数组
（4）Arrays.fill(nums,value);     将数组值全部置成value
（5）Arrays.copyOf(nums,num);   复制长度为num的数组
（6）Arrays.binarySearch(nums ,value);   查找某个值在数组中的下标，要求数组已经升序排序
 a: 要搜索的数组
 key：要搜索的值
 
 如果key在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是索引键将要插入数组的那一点，即第一个大于该键的元素的索引。
 
注意：
[1] 搜索值不是数组元素，且在数组范围内，从1开始计数，得“ - 插入点索引值”；
[2] 搜索值是数组元素，从0开始计数，得搜索值的索引值；
[3] 搜索值不是数组元素，且大于数组内元素，索引值为 – (length + 1);
[4] 搜索值不是数组元素，且小于数组内元素，索引值为 – 1。
 

十三.二维数组

	数据类型[][]  数组名 = new 数据类型[n][m];
	
	数据类型  数组名[][] = new 数据类型[n][m];

例：
m班n个学生成绩：
数组名.length – 一维的长度（班级的数目）
数组名[i].length – 二维的长度 （每个班的人数）

数组名[m][n] --获取的具体的某个元素

注意：
1）数据类型[][] 数组名 = new 数据类型[n][];
 a.第二维数据为空
 b.给第二维数组赋值
 数组名[i] = new 数据类型[m];
 
2）二维数组声明并赋值
 
数据类型[][] 数组名 = new 数据类型[][]{{值1，值N…},{值1，值N…}};
数据类型[][] 数组名 = {{值1，值N…},{值1，值N…}};