JAVA初学——数组

1.概念：一组连续（线性）的存储空间，存储多个相同的数据类型的值
1.1特点：类型相同 长度固定

2数组的创建
int[ ] a = new int[5]; //创建数组并固定数组的长度
int a[ ] = new int[5];
声明 int 数组类型变量，定义变量名为 a 分配长度为5 的连续空间
每一个小块都是数组元素 || 可以存储5个int 类型的值

数组中的每个数据格被称为“数组元素”
对每个元素进行赋值或取值的操作被称为“元素的访问”
访问元素时，需要使用“下标”（从0开始，依次+1，自动生成，且最大为数组长度-1）
访问的语法：数组名[下标]； // 例如 存a[0]=10; 取 a[0];

下标取值有效范围： 0 ~ 数组长度 - 1
遍历：从头至尾，逐一对数组的每个元素进访问。
a.length 数组名.length 可动态获取数组长度
a[i] 使用循环便利“i”充当下标，逐一访问数组中的每个元素
3.数组的默认值
在没有为数组元素赋值的情况下，依旧可以正确访问
整数： 0
小数：0.0
字符：\u0000
布尔：false
其他：null
4.数组的创建语法
4.1先声明，再分配空间
数据类型[] 数组名；
数组名 = new 数据类型[长度];
4.2声明并分配空间
数据类型[] 数组名 = new 数据类型[长度]；
4.3声明并赋值（繁）
数据类型[] 数组名 = new 数据类型[]{value1,value2,…}
4.4声明并赋值（简）
数据类型[] 数组名 = {value1,value2,…}；
//显示初始化，且不可换行
5.数组的扩容‘
创建数组时，必须显示指定长度，并在创建之后不可更改长度
5.2扩容的思路
创建大于原数组长度的新数组
将原数组中的元素依次复制到新数组中
5.3数组的复制
循环 将原数组中的所有元素，逐一赋值给新数组
System.arraycopy(原数组名字，原数组起始位置，新数组名字，新数组起始位置，长度);
java.util.Arrays.copyOf(原数组名字，新长度);//返回带有原值的新数组
6.地址替换
数组作为引用类型之一，其变量中存储的是数组的地址
完成元素复制后，需将新数组地址赋值给原变量进行替换
nums地址 0x0000A0011 里面存着 11 22 33 44 55 值
通过newNums地址0x0000B0022 将值复制进去后 11 22 33 44 55 0 0 0 0 0
再将地址newNums的地址赋值到nums 中
6.1.基本数据类型的变量存储的是值
6.2 引用数据类型的变量存储是地址
6.3 nums = newNums // 将新数组的地址，赋值给nums变量，进而在后续作nums时，则操作长度更大的新数组
7.数据类型的参数

int[] nums = {11,22,33,44,55};
printArray(nums); 
// 假设 nums 的地址是0x000A01 那么传参后 oneArray的地址为0x0000A01
{
	public static void printArray(int[] oneArray){
		for(int i  = 0 ; i < oneArray.length; i++){
			System.out.println(oneArray[i]);
		}
	}
}

方法调用时，将nums 中的地址赋值给oneArray，此时二者指向同一个数组
①基本数据类型的传递，是“值”的传递，一方改变，不会影响另一方
②引用数据类型的传递，是“地址”的传递，一方改变，会影响另一方
7— 栈和堆
JVM栈空间（局部变量）
int a = 10; int b = a;
Heap 堆空间（对象，数组）
所有对象，包括数组必须分配在堆空间里（为？）
①这块空间是我们Java程序员，在管理角度来讲，能操作的最大操作空间
②Java中有七种垃圾收集器，可以帮助我们自动完成收集工作

int[] oldArray = new int[4];
局部变量 int[] oldArray
new int[4] 即在堆空间中分配地址为0x0000A01的4个小空间
/= 表示 两者通过 引用reference 或 句柄 来连接

8.数据类型返回值

int[] oa = {11,22,33,44,55};  //0x0000A111
int[] na = expand(oa);
for(int i = 0; i < na.length; i++){
	System.out.println(na[i]);
}
public static int[] expend(int[] oldArray){//0x0000A111
	int[] newArray = new int[oldArray.length*2];//0x0000B222
		for(int i = 0; i < oldArray.length; i++){ //遍历
			newArray[i]=oldArray[i];
		}
		return newArray; // 0x0000B222  返回值长度为10的newArray
}

创建新数组，长度为原数组的2倍，新数组中保留原有数据，返回新数组
System.out.println(Array.toString(oa));
9.可变长参数
9.1概念：可接收多个同类型实参，个数不同，使用方式与数组相同。
9.2语法：数据类型 …形参名 // 必须定义在形参列表的最后，且只能有一个，支持0~N个参数
int… = int[] String… = String[] char…= char[]
double… = double[] method(xxx,xxx[],xxx…);
//可变长参数，是对数组的一种便利写法的补充（80%的场景用数组，20%的场景用可变长参数）
可接受零散的数据，个数不限
不在接收数组
且在函数内部，仍旧是多个值的意思
① int… array == > int[] array
② printArray{1,2,3,4,5} //零散数据导入
printArray(int array);//函数
10.排序
冒泡排序
相邻的两个数值比较大小，互换位置
记忆： 外层 length - 1; 内层 length -1-i
补充： 嵌套循环 约定俗成的变量命名
一重循环 i ，二重循环 j，三重循环k

int[] array = {2,44,4,11,1}
	int temp = 0;
	for(int i = 0; i < array.length - 1 ; i ++){
		for(int  j= 0 ; j < array.length -1-i ; j++){
			if(array[j]>array[j+1]){
				temp = array[j+1];
				array[j+1] = array[j];
				array[j]= temp;
			}
		}
	}
	for(int i = 0 ; i < array.length; i++){
		System.out.println(array[i]);
	}

选择排序
固定值与其他值比较大小，互换位置。
记忆： 外层 length-1; 同时外层i作为固定值,内层的j = i +1 ;作为其他值的起始

int[] scores = {1190,222,1,3,2222};
int temp = 0;
	for(int i = 0 ; i <scores.length-1; i ++){
		for(int j = i+1 ; j < scores.length ; j++){
			if(scores[i] > scores[j]){
			temp = scores[i];
			scores[i] = scores[j];
			scores[j]  = temp;
		}
		}
	}
	for(int i = 0 ; i < scores.length; i++){
		System.out.println(scores[i]);
	}

JDK排序
java.util.Array.scort(数组名)；//JDK提供（升序）

int scores[]={89,56,45,78,12,3};
java.util.Arrays.sort(scores);//JDK排序 只能做升序

11.二维数组
①概念： 一维数组中的一堆数组，数组中的元素不是数组
（例如：在excle中查找的某一表格 有行有列 ， 二维数组相当于一个多行多列的表格）
/X[高维（行）][低维（列）]
②

int[][] array = new int [3][5];
	array[0][0] = 10; 
	array[0][3] = 20;
	array[1][1] = 30;
	array[1][2] = 40;
	array[2][4] = 50;
	
		0   1   2   3   4   5
	0   10  0   0   20  0   0
	1   0  30   40   0   0  0
	2   0   0   0    0   0  50

③注意高维数组中的每一个元素，保存了低维数组的地址
访问 array[0]等价于在访问0x0000A11（“二维数组的内存分配图”）
12.二维数组的创建语法
现声明再分配空间
数组名 = new 数据类型[高维长度][低维长度]
声明并分配空间
数据类型[] [] 数组名 = new 数据类型[高][低]
声明并赋值（繁）
数据类型[][] 数组名 = new 数据类型[高][]
// 不规则数组，自行new 低维数组
声明并赋值（简）
数据类型[] 数组名 = {{v1,v2,v3},{v1,v2},{v1,v2,v3,v4}}
//显示初始化
13 数组（插入，扩充）

static int[] nums = new int[5];
public static void main(String[] args){
	nums[0]=11;
	nums[1]=22;
	nums[2]=33;
	nums[3]=44;
	print(); //打印数据 // 遍历
	insert(55); //插入数据
	print(); // 遍历
}
	public static void insert(int value){
		for(int i = 0 ; i <nums.length ; i++){//查找 值为0时 赋值
			if(nums[i] == 0){
				nums[i] = value;
				break;
			}
		}
	}
	public static void print(){
		for(int i = 0 ; i < nums.length ; i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}

14.杨辉三角，
杨辉三角