java学习 数组

数组

概念：一组连续的存储空间，存储多个相同数据类型的值。
特点：类型相同，长度固定。
Java在定义数组时并不为数组元素分配内存，因此[ ]中无需指定数组元素的个数，即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的，我们必须要为它分配内存空间，这时要用到运算符new，

• 创建数组时必须明确长度。
• 数组中的每个数据被称为“数组元素”。
• 对每个元素进行赋值或取值的操作被称为“元素的访问”。
• 访问元素时，需要使用“下标”（从0开始，一次+1，紫宗生成）。
• 访问的语法:数组名[下标]；

int[] nums = new int[5];
nums[0] = 10;//依次赋值

下标的范围[0,数组长度-1]
下标超过范围，编译不会报错，运行时会报错。

//存
Scanner input = new Scanner(System.in);
double[] scores = new double[5];
for (int i =1;i<=scores.length;i++){
	System.out.println("请输入第"+(i)+"名学生的成绩:");
	scores[i-1] = input.nextDouble();
}

数组名.length 可动态获取数组长度

数组的默认值：

• 整数：0
• 小数：0.0
• 字符：\u0000
• 布尔：false
• 其他：null

int[] intValue = new int[3];
System.out.println(intValue[1]);

数组创建语法：

• 先声明，再分配空间

//1.先声明，再分配空间		
int[] name ;
name = new int[5];
//2.声明并分配空间
int array = new int[5];
//3.声明并赋值
int numbers1 = new int[]{11,22,33,44,55};//可换行
int numbers2 = {11,22,33,44,55};//不可换行

数组的复制与扩容
创建数组时，必须显示指定长度，并在创建之后不可更改长度。
扩容的思路：

• 创建大于原数组长度的新数组。
• 将原数组的元素依次复制到新数组中。

//原数组
int[] oldArray = new int[]{11,22,33,44,55};
//1.创建比原数组更大的新数组
int[] newArray = new int[oldArray.length*2];
//2.将原数组的元素，依次赋值到新数组中
for(int i = 0;i<oldArray.length;i++){
	newArray[i] = oldArray[i];
}

或
System.arraycopy(原数组，原数组起始位置，新数组，新数组起始位置，拷贝长度);

//原数组
int[] oldArray = new int[]{11,22,33,44,55};
//1.创建比原数组更大的新数组
int[] newArray = new int[oldArray.length*2];
//2.将原数组的元素，赋值到新数组中
System.arraycopy(oldarray,0,newarray,0,olarray.length);

或
java.util.Arrays.copyOf(原数组，新长度);//返回带有原值的新数组
此方法不能自定义复制长度，位置。

int[] newArray = Arrays.copyOf(oldArray,oldArray.length*2);

地址
数组作为引用类型之一，其变量中存储的是数组的地址。

int[] array;// 变量----> 存储一个值（基本类型的值[]、引用类型的值）
array = new int[5];
System.out.println(array);
System.out.println(array[1]);

[I@15db9742
0

可变长参数
概念：可接受多个同类型实参，个数不限，使用方式与数组相同
语法：数据类型… 形参名//必须定义在形参列表最后，且只能有一个
可变长参数的方法的调用
调用的时候可以给出任意多个参数也可不给参数

//接受一个整数数组，并返回一个更大的包含原有元素的新数组
	public static int[] copyOf(int[] array, int length) {
		int[] newArray = new int[length*2];
		for(int i = 0;i<array.length;i++){
			newArray[i] = array[i];
		}
		return newArray;
	}
	//元素倒置
		public static void Inversion(int[] array) {
			for(int i = 0;i<array.length/2;i++){
				int temp = array[i];
				array[i] = array[array.length-i-1];
				array[array.length-i-1] = temp;
			}
		}
	
	//有效值无效值区分是为使数值插入连续（线性）
	public static void addElement(int[] array, int position ,int value,int flag) {//flag为无效值
		//1.还有没有可用空间
		boolean tag = false;//没有可用空间
		int index = array.length;
		for(int i = 0; i<array.length;i++){
			if(flag == array[i]){
				tag = true;//有可用空间
				index = i;//无效值开始的位置
				break;
			}
		}
		if(!tag){
			//expand(); //无可用空间，则扩容
		}
		//2.验证是否为有效位置（0-第一个flag）
		if(position<0||position>index){
			System.out.println("无效位置");
			return;
		}
		//3.移动元素
		for(int i = index-1;i >= position ;i--){
			array[i+1] = array[i];
		}
		//4.目标位置赋新值
		array[position] = value;
	}

二维数组
概念：一维数组中的一维数组，数组中的元素还是数组。
数据类型[][] 数组名 = new 数据类型[二维数组的长度][包含的一维数组的个数][每个一维数组的长度];

int[][] arr = new int[3][5];—定义了一个整型的二维数组，其中包含3个一维数组，每个一维数组可以存储5个整数

arr[0]—下标为0的位置上的一维数组

arr[1][3]—如果要获取具体的元素需要两个下标

数据类型[][] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][];
高维元素array[]指向一个低维数组
创建语法：

//先声明，再分配空间：
数据类型[][] 数组名;
数组名 = new 数据类型[高维长度][低维长度];
//声明并分配空间
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];
//声明并赋值
数据类型[][] 数组名 = {{v1,v2},{v3,v4,v5},{v6}};//低维数组长度可不一致，因为指向的是地址

数据类型[][] 数组名 = new 数据类型[高维长度][];
//不写低维长度即意味着不创建低维数组，此时输出数组名[0]结果为null
//输出数组名[0][0] 出现错误  （空指针异常）
数组名[0] = new 数据类型[3];
//这时，输出数组名[0]结果为一个地址（一个长度为3的低维数组）
数组名[1] = new 数据类型[4];

高维数组存的是地址， 低维数组存的是数据

int[][] array = new int[3][5];
array[0][0] = 5;
System.out.println(array[0][0]);
System.out.println(array[0]);//输出为地址（存的是长度为5的一维数组）
System.out.println(array[0].length);//输出为 5
System.out.println(array.length);//输出为 3 
for(int i = 0;i<array.length;i++){
	for(int j = 0 ; j<array[0].length;j++){
		System.out.print(array[i][j] + "\t");
	}
	System.out.println();
}

JVM栈空间（局部变量）
基本类型的赋值==值的赋值，一方改变不影响另一方
引用类型的赋值等价于地址的赋值，一方改变，会影响另一方（堆中的数组被共享）

Heap堆空间 （对象、数组）

案例：杨辉三角

public class YangHui {
	public static void YH(int rows) {
		int[][] YHarray = new int[rows][];
		for(int i = 0;i<rows;i++){
			YHarray[i] = new int[i+1];
			YHarray[i][0] = 1;
			YHarray[i][i] = 1;
			if(i>1){
				for(int j = 1; j<i;j++){
					YHarray[i][j] = YHarray[i-1][j] +YHarray[i-1][j-1];
				}
			}
		}
		array2Print(YHarray);
	}
	public static void array2Print(int[][] array) {
		for(int i = 0;i<array.length;i++){
			for(int j = 0 ; j<array[i].length;j++){
				System.out.print(array[i][j] + "\t");
			}
			System.out.println();
		}
	}
	public static void main(String[] args) {
		int nums = 7;
		YH(nums);
	}
}

结果：

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1