第五章 数组及排序 ① 笔记

已于 2022-06-30 14:17:57 修改
阅读量77 收藏
点赞数
分类专栏： # Java 文章标签： java 开发语言
于 2022-06-30 14:13:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu_wen_wen/article/details/125538752
版权

数组及排序

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]);*/
}

4. 本章总结

 数组的定义和使用
 数组排序
 Arrays工具类的使用
 二维数组
 对象数组

5. 课后作业

定义长度为10的学生数组，实现学生数据的添加，删除，修改，查询操作

小丫头爱打盹
关注
专栏目录
JAVA学习笔记4,数组及排序算法
weixin_38587484的博客
01-21 486
数组及排序算法1 数组(Array)2 一维数组的申明2.1 数组的申明2.2 数组初始化后的默认值3 二维数组3.1 二维数组申明3.2 二维数组元素的初始化值4 排序算法4.1 冒泡排序4.2 选择排序4.3 插入排序4.4 希尔排序5 练习 1 数组(Array) 数组是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。 1、数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 2、创建数组对象会在内存中开辟一整块
学习笔记：第五章 数组
张小憨憨的博客
12-17 687
第五章 数组第五章 数组数组的定义与顺序存储数组的定义：数组的顺序存储：数组的基本操作：普通矩阵的表示和实现：矩阵的乘法矩阵与三角矩阵行列式的值矩阵压缩存储：特殊矩阵简介：存储方案：三角矩阵带状矩阵稀疏矩阵： 第五章 数组 数组的定义与顺序存储 数组的定义： 数组A为n(n>0)个元素的有穷序列，记作A=（a1,a2,…an） ai(1<=i=<n)或者全部为相同数据类型的原子项ei（即具体数值）；或者全部为具有相同定义的数组Bi。 数组A=（a1，…，an）的维度Dim递归定义为： C
用java定长数组实现线性表
07-02
用定长数组实现线性表用定长数组实现线性表
java基础之数组
qq_41720578的博客
04-07 637
一、数组的定义及使用 数组:是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。 在js中，数组没有数据类型限制,并且可以随意扩容。Java中的数组 就是 将相同数据类型的数据 进行存储的数据格式。并且存储到数组中的数据都会自动生成一个编号，称之为索引值或者下标。然后数组是通过操作索引值对数据进行存取。索引值从0开始。并且java中的数组是定容，统一数据类型的。
java 学生对象数组
qq_coding的博客
07-01 461
学生对象数组
Java创建指定长度的数组
qq_27130997的博客
10-08 8205
1 需要创建一个为10的Object类型的数组 Object[] objects = new Object[10];
设计一个学生类Student，所有学生对象存储到数组中，按总分排序，并输出最后结果。
yingying111222的博客
12-26 2687
输入若干学生的学号、姓名、英语、数学、语文、物理、化学、生物成绩，并计算总分和平均分，按总分从高到低排序。要求：设计一个学生类Student，所有学生对象存储到数组中，按总分排序，并输出最后结果。
创建随机数组并排序（冒泡排序）（个人笔记）
qq_45968325的博客
03-28 2753
冒泡排序的思想：就像水中的泡泡一样，离水面越近，泡泡就越大，以从小到大排序为例。依次比较2个相邻的数据，如果前面的数据大于后面的数据， 两个数据交换位置，一趟下来后，最大的数据就留在了最后位置，并且这个数据在下一趟不再参与比较。第二趟仍是依次比较2个相邻的数据，如果前面的数据大于后面的数据，两个数据交换位置，第二趟下来后，第2大的数据就跑到了倒数第二位，依次类推，若数组有n个数，则进行n-1趟上述的过程，就可以排序完成。 例 .创建一个包含10个随机数的数组，随机数的取值范围是[10, 90]，对其按从小
JS随机洗牌算法之数组随机排序
10-22
值得注意的是，虽然在文件内容中提到了一些推荐阅读的资料，例如JavaScript学习笔记之数组的增、删、改、查和JavaScript学习笔记之数组求和方法，这些资料可能涉及数组的基础操作和算法，但是它们并不是洗牌算法的...
Java笔记一维数组 二维数组 冒泡排序 选择排序 二分查找法
weixin_45279447的博客
11-03 609
java笔记数组一维数组使用增强for循环遍历一维素组经典冒泡排序二维数组Arrays类的应用将所有元素赋相同的值查询元素在数组中的下标 数组 一维数组 **定义：**数组是用来存储一组相同类型数据的数据结构 注意：数组中的元素类型必须是相同的 语法步骤 声明数组: 1、声明数组时不定义数组长度：数据类型[] 数组名;或数据类型 数组名[]; 分配空间: 数组名 = new 数据类型[3]; 声明并分配空间： 2、声明并分配空间： 数据类型[] 数组名 = new数据类型[3]; 或 数据类型 数组名
Java使用定长数组实现队列的抽象，并可动态调整数组大小
qq_16118409的博客
05-17 578
如题： 编写定长数组实现队列的抽象，并可动态调整数组大小 import java.util.Scanner; public class ResizingArrayQueueOfStrings { private int first; private int last; private int count; private String[] queue; public Resizin...
java数组实现对象排序
最新发布
Serendipityemo的博客
06-11 356
【代码】java数组实现对象排序。
Java如何实现顺序表存储学生信息
u013471607的博客
03-16 2206
注意，在删除学生信息时，我们使用了MyArrayList类中的remove方法，该方法会将指定位置的元素删除并将后面的元素向前移动一位，同时将MyArrayList对象的大小减一。删除、修改和查找学生信息时，我们遍历MyArrayList对象，通过学号来定位要操作的学生信息，然后进行相应的操作。通过Scanner对象读取用户的输入，根据用户的选择进行相应的操作，包括添加学生信息、删除学生信息、修改学生信息和查找学生信息等。在这个数组中，每个元素都可以存储一个学生的信息，包括学号、姓名和年龄。
java创建数组时定义数组的长度
dd2016124的博客
11-21 9491
直接看案例： Double[] d = new Double[6]; 这里定义了一个double类型的数组，定义数组的长度为6
java生成指定长度、指定范围的数组
sleep_i_like的博客
02-25 3875
package zxcv; import java.lang.reflect.Array; import java.util.*; public class 另一个乱七八糟的测试 { public static void main(String[] args) { int[] rr=qwe(10,10); System.out.println(Arrays.toString(rr)); ...
【Java】数组
weixin_TB20160103的博客
04-21 467
如果您需要动态地添加或删除元素，则应该使用 Java 中的集合类，如 ArrayList 或 LinkedList。这些集合类可以根据需要自动调整大小，并提供了一组实用的方法来操作它们。使用集合类可以使代码更加灵活和易于维护。Java 中的数组是固定长度的，一旦创建后无法更改其大小。
JAVA输出值随机但不同的定长数组
weixin_44596902的博客
01-05 128
创建长度为6的int型数组，要求数组元素的值都在1~30之间，且是随机赋值，要求元素的值各不相同 public class DistinctValue { public static void main(String[] args){ int[] arr = new int[6]; for(int i = 0; i < arr.length; i++){ arr[i] = (int)(Math.random()*30) + 1;//保证其取值在[1,31)之间 for(int.
Java初学—数组初始化
贝贝小菜鸟的博客
06-07 329
数组的概念:是一种容器，可以同时存放多个数据值 数组的特点: 1.数组是一种引用数据类型 2.数组当中的多个数据，类型必须统一 3.数组的长度在程序运行期间不可改变 代码练习: public class Demo01Array { public static void main(String[] args){ int score1 = 100; int score2 = 98 ; int score3 = 99 ; System.out
java固定数组_Java在固定长度的数组里加入一个数
weixin_42500642的博客
02-13 933
展开全部题目：给定一个有序的数组{13,15,19,28,33,45,78,106}，如果往该32313133353236313431303231363533e59b9ee7ad9431333361323563数组中存储一个元素，并保证这个数组还是有序的，那么这个元素的存储的角标如何获取？并打印出插入后的数组packagecom.ljy.interviewQuestion;/***...
C语言基础教程：循环、数组与排序实践
在《C语言学习笔记》中，我们将会探讨三个有趣的C语言程序示例，这些程序分别展示了基础的数据处理、数组操作以及算法应用。 第一个程序是关于累加数列的计算。这个程序使用了for循环和乘法运算来实现对一个数的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值