Java学习之路Day06

(一)数组的概念

为什么使用数组
如何存储100名学生的成绩？使用变量存储，重复声明100个double类型的变量。缺点：麻烦，重复操作过多。
如何让100名学生的成绩+1？100个变量重复相同的操作，直至全部完毕。缺点：无法进行统一的操作。
数组的概念：一组连续的存储空间，存储多个相同数据类型的值。特点：类型相同，长度固定。

(二)数组的创建

public static void main(String[] args) {
		int[] a=new int[5];
	}

int[] a ：声明int数组类型变量 定义变量名为a
new int[5]：分配长度为5的连续空间。

(三)数组的组成

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

(四)数组的使用

public static void main(String[] args) {
		int[] a = new int[5];
		a[0] = 5;
		a[1] = 3;
		a[2] = 4;
		a[3] = 7;
		a[4] = 10;
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[4]);
	}

运行结果如下

int[] a = new int[5]；是创建数组。
a[0] = 5；…是依次赋值。
System.out.println(a[0]); …是依次取值。

下标范围

public static void main(String[] args) {
		int[] a = new int[5];
		a[0] = 5;
		a[1] = 3;
		a[2] = 4;
		a[3] = 7;
		a[4] = 10;
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[4]);
		System.out.println(a[5]);
	}

int[] a = new int[5]；有效的下标范围：0~数组长度-1
a[5]为无效下标，范围无效下标，会到导致数组下标越界。

数组的遍历

遍历：从头至尾，逐一对数组的每个元素进行访问。

public static void main(String[] args) {
		int[] a = new int[5];
		a[0] = 5;
		a[1] = 3;
		a[2] = 4;
		a[3] = 7;
		a[4] = 10;
		for(int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}

数组名.length可动态获取数组长度。
使用循环变量"i"充当下标，逐一访问数组中的每个元素。

数组的默认值

public static void main(String[] args) {
		int[] a = new int[5];

		for(int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}

运行结果如下

a[i]：在没有为数组元素赋值的情况下，依旧可以正确访问。
数组的默认值：整数：0；小数：0.0；字符\u0000；布尔：false；其他：null

数组的创建语法

先声明、在分配空间：
数组类型[] 数组名；
数组名 = new 数据类型[长度]；
声明并分配空间：
数据类型[] 数组名 = new 数据类型[长度]；
声明并赋值（繁）
数组类型[] 数组名 = new 数据类型[]{value1,value2,value3…};
声明并赋值（简）
数组类型[] 数组名 = {value1,value2,value3…}；//显示初始化，注意：不可换行。

数组的扩容

创建数组后，必须显示指定长度，并在创建之后不可更改长度。
扩容思路：
创建大于原数组长度的新数组。
将原数组中的元依次复制到新数组中。

复制的方式

循环将原数组中的所有元素逐一赋值给新数组。
System.arraycopy(原数组，原数组起始，新数组，新数组起始，长度);
java.util.Arrays.copyOf(原数组，新长度)；//返回带有原值的新数组。

地址的替换

数组作为引用类型之一，其变量中存储的是数组的地址。
完成数组的赋值后，需要将新数组地址，赋值给原变量进行替换。

数组类型的参数

public static void main(String[] args) {
		int[] nums = {111,222,333,444,555};
		printArray(nums);
		
	}
	public static void printArray(int[] oneArray) {
		for(int i = 0; i < oneArray.length; i++) {
			System.out.println(oneArray[i]);
		}
	}

运行结果如下：

假设nums地址为：0x0000A001
传入参数后oneArray地址为：0x0000A001
方法调用时，将nums中的地址赋值给oneArray，此时二者指向同一个数组。
传递参数时：基本类型传递的是变量中的值；引用类型传递的是变量中的地址。

数组类型的返回值

public static void main(String[] args) {
		int[] oa = {111,222,333,444,555};
		int[] na = expand(oa);
		for(int i = 0; i < na.length; i++) {
			System.out.println(na[i]);
		}
		
	}
	public static int[] expand(int[] oldArray) {
		int[] newArray = new int[oldArray.length*2];
		for(int i = 0; i < oldArray.length; i++) {
			newArray[i] = oldArray[i];
		}
		return newArray;
	}

运行结果如下：

na变量结果expand返回的新数组。
int[] newArray = new int[oldArray.length*2]; 创建长度2倍的新数组，保留原数据。
return newArray; 返回长度为10的newArray。
调用数组类型返回值的方法时，方法执行后，返回的是数组的地址。

(五)可变长参数

概念：可接收多个同类型实参，个数不限，使用方式与数组相同。
语法：数据类型… 形参明//必须定义在形参列表的最后，且只能有一个。

public static void main(String[] args) {
		printArray(111,222,333,444,555);
		
	}
	public static void printArray(int... oneArray) {
		for(int i = 0; i< oneArray.length; i++) {
			System.out.println(oneArray[i]);
		}
	}

int… oneArray 定义int型可变长参数。

可为可变长参数赋予0~N个实际参数
运行结果如下：

(六)数组的排序

冒泡排序：相邻的两个数值比较大小，互换位置。

public static void main(String[] args){
		int[] a={5,3,6,1,4,2};
		int temp=0;
		/*冒泡排序
		升序排序前一个数和后一个数比较，若前一个数比后一个数大那么把前一个数更后一个
		数进行替换，然后继续进行比较指导最后一个数是最大，若数组的长度为6那么轮次就需
		要轮5次，第一轮需要比较5次，第二轮需要4次，第三轮需要3次，第四轮需要2次，第五
		轮需要1次。
		*/ 
		for(int i=0;i<a.length-1;i++){
			for(int j=0;j<a.length-1-i;j++){
				if(a[j]>a[j+1]){
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
				}
			}
		}
		for(int k=0;k<a.length;k++){
			System.out.print(a[k]+"\t");
		}
	}

选择排序：固定值与其他值依次比较大小，互换位置。

	public static void main(String[] args){
		int[] a={5,4,2,6,3,1};
		int i=0;//选择排序的固定下标
		/*选择排序从固定开始找到固定下标的值与后面下标的最小值，并且把最小值替换到
		固定下标，下标为0那么需要和后面比较5次，下标为1需要和后面比较4次
		*/
		for(int j=0;j<a.length-1;j++){//控制轮次
			for(int k=j+1;k<a.length;k++){
				if(a[j]>a[k]){
				int temp=a[j];
				a[j]=a[k];
				a[k]=temp;
				}
			}
		}
		for(int j=0;j<a.length;j++){
			System.out.print(a[j]+"\t");
		}
	}

JDK排序：java.util.Arrays.sort(数组名)；//JDK提供(升序)

(七)二维数组

概念：一维数组中的一维数组；数组中的元素，还是数组。

二维数组的赋值

public static void main(String[] args) {
		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;
	}

二维数组的内存分配

高维数组中的每一个元素，保存了低维数组的地址。访问array[0]等价于在访问0x000A111

二维数组的访问

public static void main(String[] args) {
		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;
		for(int i = 0; i < array.length; i++ ) {
			for(int j = 0; j < array[i].length; j++) {
				System.out.print(array[i][j]);
			}
			System.out.println();
		}
	}

array[i].length 访问低维长度：array[0].length 首个低维数组的长度。
array[i][j] 访问低维数组元素 array[0][0] 首个低维数组的首个元素。

二维数组的创建语法

先声明，在分配空间
数据类型[ ][ ] 数组名；
数组名 = new 数据类型[高维长度][低维长度]；
声明并分配空间
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度]；
声明并赋值（繁）
数组类型[][] 数组名 = new 数据类型[高维长度][];//不规则数组，自行new低维数组。
声明并赋值（简）
数组类型[][] 数组名 = {{v1,v2,b3},{v4,v5},{v5,v7,v8,v9}}；//显示初始化

总结

数组的概念：
一组连续的存储空间，存储多个相同数据类型的值。
数组的声明与赋值：
数据类型[] 数组名 = new 数据类型[长度];
数组名[下标] = 值；
数组的遍历：
从头至尾，逐一对数组的每个元素进行访问。
数组的排序：
冒泡排序、选择排序、JDK排序。
数组的应用：
数组复制、数组扩容、数组参数、数组返回值、二维数组。