第五章数组及排序 ① 笔记

数组及排序

1. 内容回顾

1.1. 课前测试
多刷题：

1.2 上节内容

2. 本章重点

2.1. 数组的定义和使用
2.2. 数组排序
2.3. 二维数组
2.4. 对象数组
2.5. Arrays工具类的使用

3. 具体内容

3.1. 数组的定义和使用

3.1.1. 什么是数组

所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。
在js中，数组没有数据类型限制,并且可以随意扩容。Java中的数组就是 将相同数据类型的数据 进行存储的数据格式。并且存储到数组中的数据都会自动生成一个编号，称之为索引值或者下标。然后数组是通过操作索引值对数据进行存取。索引
值从0开始。并且java中的数组是定容，统一数据类型的。

3.1.2 java数组的特点

a. java数组是一种引用数据类型
b. java数组中的数据类型必须统一
c. java数组是定长的（长度一旦确定就不能变化）
d. 数组的重新赋值，只能通过标准格式，不能使用简化格式赋值
e. 初始化数组时如果没有直接赋值，那么数组中元素的默认值
整数: 0 浮点数: 0.0 字符:‘\u0000’ 布尔型:false 引用类型:null
f. 因为数组是定长的，如果想扩容只能创建一个新的数组。
Arrays.copyOf(原始数组，长度)

3.1.3 数组的定义

语法：

// 定义有容量的数组
数据类型[] 数组变量 = new 数据类型[数组容量];
// 定义有初始化数据的数组.后面的中括号中不能写长度
数据类型[] 数组变量 = new 数据类型[]{数据1,数据2...};
// 直接赋值创建(静态创建)，定义和赋值必须写在一起
数据类型[] 数组变量 = {数据1,数据2...};

实例：

public static void main(String[] args) {
	/*
	数据类型 变量名 = 数据;
	数据类型[] 数组变量名 = new 数据类型[长度];
	*/
	//int num = 10; // 普通变量
	//int[] numAry = new int[10]; // 数组对象
	// java中的数组创建
	// 方式一: 定义数组变量，并创建特定长度的数组空间
	// 没有赋值，有默认值: int 0,String null,char '0',boolean false
	int[] numAry = new int[5];
	//System.out.println(numAry); // 输出数组再内存地址
	/*System.out.println(numAry[0]);
	System.out.println(numAry[1]);
	System.out.println(numAry[2]);
	System.out.println(numAry[3]);
	String[] nameAry = new String[3];
	//System.out.println(nameAry);
	System.out.println(nameAry[0]);
	System.out.println(nameAry[1]);
	System.out.println(nameAry[2]);
	//System.out.println(nameAry[3]);*/
	//Array(数组)Index(索引)OutOf(超出)Bounds(边界)Exception(异常)
	// 方式二: 定义数组变量，并使用new的方式进行数据初始化
	// 后面的中括号，一定不能写长度
	int[] numAry2 = new int[]{200,100,300}; // 根据个数创建数组空间，并赋值
	/*System.out.println(numAry2.length); // length:数组长度
	System.out.println(numAry2[0]);
	System.out.println(numAry2[1]);
	System.out.println(numAry2[2]);*/
	// 方式三: 定义变量，用静态方式直接进行初始化
	// 这种方式必须再声明变量的同时进行赋值。不能先声明变量，再赋值
	int[] numAry3 ={12,34,11,39};
	// 循环
	for (int i=0;i<numAry3.length;i++){
		System.out.println(numAry3[i]);
	}
}

3.1.4 数组的使用

语法：

// 创建数组
数据类型[] 数组变量 = new 数据类型[数组容量];
// 通过数组变量+下标 为数组元素赋值。数组的最大下标只能取到"数组容量-1"
数组变量[下标1] = 数据1;
数组变量[下标2] = 数据2;
...
数组变量[数组容量-1] = 数据n;
// 通过数组变量+下标 访问数组元素
System.out.println(数组变量[下标])

实例：

public class Test2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 定义长度为5的整形数组,输入5个分数,并遍历输出
		int[] scoreAry = new int[5];
		//scoreAry[0] =234;
		//scoreAry[1] = 456;
		for (int i=0;i<scoreAry.length;i++){
			System.out.println("请输入第"+(i+1)+"个学生的分数:");
			int s = sc.nextInt(); // 接收整数
			// 将分数存入数组中
			scoreAry[i] = s;
		}
		System.out.println("==================");
		// for+索引 遍历
		for (int i=0;i<scoreAry.length;i++){
			System.out.println(scoreAry[i]);
		}
		System.out.println("==================");
		// for each 遍历
		for(int t : scoreAry){
			System.out.println(t);
		}
	}
}

注意: 当数组下标超出数组边界的时候，会报出ArrayIndexOutOfBoundsException

3.1.5 数组在内存中的存储方式

3.1.6 数组的遍历

方式一：for+索引

int[] scoreAry = new int[5];
// for+索引 遍历
for (int i=0;i<scoreAry.length;i++){
	System.out.println(scoreAry[i]);
}

方式二: for each 遍历

int[] scoreAry = new int[5];
// for each 遍历
for(int t : scoreAry){
	System.out.println(t);
}

3.1.7 数组的操作

求数组最大值，最小值，最大值下标，最小值下标

public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	// 定义长度为5的整形数组,输入5个分数,并遍历输出
	int[] scoreAry = new int[5];
	//scoreAry[0] =234;
	//scoreAry[1] = 456;
	for (int i=0;i<scoreAry.length;i++){
		System.out.println("请输入第"+(i+1)+"个学生的分数:");
		int s = sc.nextInt(); // 接收整数
		// 将分数存入数组中
		scoreAry[i] = s;
	}
	System.out.println("==================");
	// for+索引 遍历
	for (int i=0;i<scoreAry.length;i++){
		System.out.println(scoreAry[i]);
	}
	System.out.println("==================");
	// for in 遍历
	for(int t : scoreAry){
		System.out.println(t);
	}
}

public static void main(String[] args) {
	// 定义数组，存储5个分数，求最高分，最低分，最高分位置，最低分位置
	int[] scores = {67,34,88,29,5,87,120,33,58,90};
	// 定义最大值位置
	int maxPos = 0;
	// 定义最小值位置
	int minPos = 0;
	for (int i = 1; i < scores.length; i++) {
		// 比较对应位置上的数据
		if(scores[i]>scores[maxPos]){
			// 记录数据的位置
			maxPos = i;
		}
		if(scores[i]<scores[minPos]){
			minPos = i;
		}
	}
	System.out.println("最大值:"+scores[maxPos]+" 最大值位置:"+maxPos );
	System.out.println("最小值:"+scores[minPos]+" 最小值位置:"+minPos );
}

3.1.8 排序算法

 冒泡排序

public static void main(String[] args) {
	// N元数组冒泡序，两两相比小前移，外层循环从1始，内层循环减i去
	// 冒泡排序:
	// 1.比较 2.换位
	int[] numAry = {20,12,33,8,4,1,200,34,98};
	// 外层控制轮数
	for(int i=1;i<numAry.length;i++){
		// 内层控制比较过程(次数)
		for(int j=0;j<numAry.length-i;j++) {
			//核心
			// 比较
			if (numAry[j] > numAry[j + 1]) {
				// 换位
				int temp = numAry[j];
				numAry[j] = numAry[j + 1];
				numAry[j + 1] = temp;
			}
		}
	}
	for(int n :numAry){
		System.out.println(n);
	}
}

 选择排序
选择: 每轮排序都选择数据最小的那个元素（下标），与本轮排位第一的元素换位

public static void main(String[] args) {
	int[] numAry = {1,12,33,8,4,200,34,20,98};
	//k=1 k=5
	// 控制轮数,记录本轮第一个元素的位置
	for (int i=0;i<numAry.length-1;i++){
		int k=i; // 记录最小值的位置
			for(int j=i+1;j<numAry.length;j++){
			// 通过比较，记录最小值的位置
			// 如果k上的值，比j上的值大
			if(numAry[k]>numAry[j]){
				// 就要把j的值赋值给k。k总是指向最小值
				k = j;
			}
		}
		// 找到本轮最小值的位置
		System.out.println("K:"+k);
		// 如果最小值的位置，和排位第一的位置不同，则换位
		if(k!=i){
			int temp = numAry[i];
			numAry[i] = numAry[k];
			numAry[k] = temp;
		}
	}
	// 循环输出
	for (int n :numAry){
		System.out.println(n);
	}
}

 其它排序(自学)

3.1.9 Arrays数组工具类

	// 定义数组
	int[] nums = {20,30,40,12,17};
	// 排序
	Arrays.sort(nums);
	for (int n : nums){
		System.out.println(n);
	}
	// 字符串
	String res = Arrays.toString(nums);
	System.out.println(res);
	// 扩展数组（重点内容，是后面ArrayList集合扩容的核心方法）
	int[] my = Arrays.copyOf(nums,20);
	System.out.println(Arrays.toString(my));

扩容原理/图如下：

3.2 对象数组

3.2.1 对象数组创建和遍历

public static void main(String[] args) {
	// 定义对象数组
	//int[] nums; // 整形数组
	//String[] strs; // 字符串数组
	//Student[] stus; // 学生数组,每个元素空间，必须存储学生对象
	Student[] stus = new Student[10];
	// 在数组第一个位置存储一个学生
	Student s1 = new Student("张三","男",20);
	//System.out.println(s1.name+" "+s1.sex);
	//System.out.println(s1);
	stus[0] = s1;
	stus[1] = new Student("李四","女",18);
	stus[2] = new Student("王五","女",18);
	stus[3] = new Student("赵六","女",18);
	stus[4] = new Student("孙琪","女",18);
	// 遍历学生对象
	for (int i=0;i<stus.length;i++){
		if(stus[i]!=null) {
			Student x = stus[i];
			System.out.println(x.name+" "+x.sex+" "+x.age);
			//System.out.println(stus[i].name + " " + stus[i].sex + " " + stus[i].age);
		}
	}
}

3.2.2 对象数组的排序

public class Test2 {
	public static void main(String[] args) {
		Student[] stus = new Student[3];
		stus[0]=new Student("张三","男",20);
		stus[1]=new Student("李四","男",19);
		stus[2]=new Student("王五","男",25);
		for (Student s: stus){
			s.show();
		}
		System.out.println("====================");
		// 冒泡排序
		for(int i=1;i<stus.length;i++){
			for(int j=0;j<stus.length-i;j++){
			// 前面的学生和后面学生的年龄相比
				if(stus[j].age>stus[j+1].age){
					// 年龄大的学生，向后移动
					Student temp = stus[j];
					stus[j]=stus[j+1];
					stus[j+1]=temp;
				}
			}
		}
		for (Student s: stus){
			s.show();
		}
	}
}

3.3 二维数组

public static void main(String[] args) {
	// 存储一排学生的位置
	String[] names1 = {"张三","李四","王五"};
	// 存储一个班级的学生
	String[][] names2= new String[][] {
		//0 1 2
		{"张三","李四","王五"}, // 0
		{"赵六","孙琪","王高"}, // 1
		{"高达","悟空","唐僧"} // 2
	};
	// 创建二维数组: [行][列]
	String[][] names3 = new String[3][5];
	for (int i = 0; i < names2.length; i++) {
		System.out.println("第"+(i+1)+"排:");
		for (int j=0;j<names2[i].length;j++){
			System.out.print(names2[i][j]+" ");
		}
	System.out.println();
	}
	/*System.out.println(names2[0][0]);
	System.out.println(names2[0][1]);
	System.out.println(names2[0][2]);
	System.out.println(names2[1][0]);
	System.out.println(names2[1][1]);*/
}