Java基础编程/第三章(数组)_用n=(int)(10*math.random())+3定义不规则二维数组a的行长度,即int[][-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_52941440/article/details/120457365

本文详细介绍了Java中的数组，包括一维和二维数组的概念、特点、声明、初始化和使用方法。讲解了数组的长度、遍历、内存解析，以及数组元素的默认初始化值。此外，还探讨了常见的数组算法，如杨辉三角的打印、数值型数组的统计计算、数组的复制、反转和查找，以及冒泡排序和快速排序。最后，提到了数组排序算法的时间复杂度和稳定性分析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

- 第三章数组

第三章数组

数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组相关的概念：
- 数组名
- 元素
- 角标、下标、索引
- 数组的长度：元素的个数
数组的特点：
- 数组是有序排列的
- 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
- 创建数组对象会在内存中开辟一整块连续的空间
- 数组的长度一旦确定，就不能修改
数组的分类：
1. 按照维数：一维数组、二维数组、。。。
2. 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
一维数组的使用（如下）

① 一维数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
1. 数组元素是整形：0
2. 数组元素是浮点型：0.0
3. 数组元素是char型：0(对应97（‘a’）的0)或’\u0000’，而非’0’。输出效果类似于空格
4. 数组元素是boolean型：false（0）
5. 数组元素是String型（所有的引用数据类型）：null
⑥ 数组的内存解析

在这里插入图片描述

String类型即(刘德华，张学友)实际不在堆里，在常量池里

一维数组

public class ArrayTest {
	
	public static void main(String[] args) {
		
		//1. 一维数组的声明和初始化
		int num;//声明
		num = 10;//初始化
		int id = 1001;//声明 + 初始化
		
		int[] ids;//声明
		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
		
		//错误的写法：
//		int[] arr1 = new int[];
//		int[5] arr2 = new int[5];
//		int[] arr3 = new int[3]{1,2,3};
		
		//也是正确的写法：
		int[] arr4 = {1,2,3,4,5};//类型推断，省略new int[]，只有当声明和初始化一起时才能省略
		
		//总结：数组一旦初始化完成，其长度就确定了。
		
		//2.如何调用数组的指定位置的元素:通过角标的方式调用。
		//数组的角标（或索引）从0开始的，到数组的长度-1结束。
		names[0] = "王铭";
		names[1] = "王赫";
		names[2] = "张学良";
		names[3] = "孙居龙";
		names[4] = "王宏志";
//		names[5] = "周扬";超出范围
		
		//3.如何获取数组的长度。
		//属性:length
		System.out.println(names.length);//5
		System.out.println(ids.length);
		
		//4.如何遍历数组
		/*System.out.println(names[0]);
		System.out.println(names[1]);
		System.out.println(names[2]);
		System.out.println(names[3]);
		System.out.println(names[4]);*/
		
		for(int i = 0;i < names.length;i++){
			System.out.println(names[i]);
		}
		
		
	}

}

Train(公寓招租联系方式)

package com.atguigu.exer;

public class ArrayDemo{
	public static void main(String[] args) {
		int[] arr = new int[] {1,2,3,4,5,6};
		int[]index = new int[] {0,2,2,1,3,4,0,0,4,5,5};
		String tel = "";
		for(int i = 0;i < index.length;i++) {
			tel += arr[index[i]];
		}
		System.out.println("联系方式：" + tel);//13324511566
	}
}

Train(学生成绩)

package com.atguigu.exer;

import java.util.Scanner;

/*
 * 2. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
		成绩>=最高分-10    等级为’A’   
		成绩>=最高分-20    等级为’B’
		成绩>=最高分-30    等级为’C’   
		其余              等级为’D’
		
		提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

 * 
 */
public class ArrayDemo1 {
	public static void main(String[] args) {
		//1.使用Scanner，读取学生个数
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入学生人数：");
		int number = scanner.nextInt();		
        
		//2.创建数组，存储学生成绩：动态初始化
		int[] scores = new int[number];
		//3.给数组中的元素赋值
		System.out.println("请输入" + number + "个学生成绩：");
		int maxScore = 0;
		for(int i = 0;i < scores.length;i++){
			scores[i] = scanner.nextInt();
			//4.获取数组中的元素的最大值:最高分
			if(maxScore < scores[i]){//输入的同时比较大小
				maxScore = scores[i];
			}
		}
//		for(int i = 0;i < scores.length;i++){
//			if(maxScore < scores[i]){
//				maxScore = scores[i];
//			}
//		}
		
		//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
		char level;//经过循环level肯定会被赋值，所以不用初始化也行
		for(int i = 0;i < scores.length;i++){
			if(maxScore - scores[i] <= 10){
				level = 'A';
			}else if(maxScore - scores[i] <= 20){
				level = 'B';
			}else if(maxScore - scores[i] <= 30){
				level = 'C';
			}else{
				level = 'D';
			}
			
			System.out.println("student " + i + 
					" score is " + scores[i] + ",grade is " + level);
		}
		
	}
}

二维数组

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

package com.atguigu.java;
/*
 * 二维数组的使用
 * 
 * 1.理解：
 * 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 * 其实，从数组底层的运行机制来看，其实没有多维数组。
 * 
 * 2. 二维数组的使用:
 *   ① 二维数组的声明和初始化
 *   ② 如何调用数组的指定位置的元素
 *   ③ 如何获取数组的长度
 *   ④ 如何遍历数组
 *   ⑤ 数组元素的默认初始化值 
 		针对于初始化方式一：比如：int[][] arr = new int[4][3];
 *      外层元素的初始化值为：地址值
 *      内层元素的初始化值为：与一维数组初始化情况相同
 *      
 *   	针对于初始化方式二：比如：int[][] arr = new int[4][];
 *   	外层元素的初始化值为：null
 *      内层元素的初始化值为：不能调用，否则报错。
 *   ⑥ 数组的内存解析 
 * 
 * 
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		//1.二维数组的声明和初始化
		int[] arr = new int[]{1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];//二维中值不同时使用
		//错误的情况 
//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
		
		//也是正确的写法：
        int arr4[][] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//省略new int
		
		//2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		arr3[1] = new String[4];//对应的元素也是一个指针，对其初始化
		System.out.println(arr3[1][0]);
		
		//3.获取数组的长度
		System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4
		
		//4.如何遍历二维数组
		for(int i = 0;i < arr4.length;i++){
			
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
		}
        
        //5.数组元素的默认初始化值
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);//[I@15db9742（[：一维数组） 
		System.out.println(arr[0][0]);//0
		
//		System.out.println(arr);//[[I@6d06d69c（I：int型）
		
		System.out.println("*****************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);//地址值（[3]的地址）
		System.out.println(arr1[0][0]);//0.0
		
		System.out.println("*****************");
		
		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);//地址值
		System.out.println(arr2[1][1]);//null
		
		System.out.println("*****************");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);//null（后面没有初始化，不指向地址，数组为引用数据类型，默认的初始化值都为null）
//		System.out.println(arr3[1][0]);//报错，没初始化，空指针不指向地址
	}
}

数组中涉及的常见算法

数组元素的赋值(杨辉三角、回形数等)
求数值型数组中元素的最大值、最小值、平均数、总和等
数组的复制、反转、查找(线性查找、二分法查找)
数组元素的排序算法

Train(1.打印十行杨辉三角)

package com.atguigu.exer;
/*
 * 使用二维数组打印一个 10 行杨辉三角。
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  
1  7  21  35   35   21   7   1  
1  8  28  56   70   56   28  8   1  
1  9  36  84   126  126  84  36  9  1 
【提示】
 1. 第一行有 1 个元素, 第 n 行有 n 个元素
 2. 每一行的第一个元素和最后一个元素都是 1
 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 * 
 */
public class YangHuiTest {
	
	public static void main(String[] args) {
		//1.声明并初始化二维数组
		int[][] yangHui = new int[10][];
		
		//2.给数组的元素赋值
		for(int i = 0;i < yangHui.length;i++){
			yangHui[i] = new int[i + 1];
			
			//2.1 给首末元素赋值
			yangHui[i][0] = yangHui[i][i] = 1;
			//2.2 给每行的非首末元素赋值
			//if(i > 1){从第三行开始给非首尾赋值，不要if也可以，i=0、1时进不去for循环
			for(int j = 1;j < yangHui[i].length - 1;j++){ //j从第二列开始(j=1)，到倒数第二列结束(长度-1)
				yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
			}
			//}
		}
		
		
		//3.遍历二维数组
		for(int i = 0;i < yangHui.length;i++){
			for(int j = 0;j < yangHui[i].length;j++){
				System.out.print(yangHui[i][j] + "  ");
			}
			System.out.println();
		}
			
	}	
}

Train(2.求数值型数组中元素的最大值、最小值、平均数、总和)

package com.atguigu.java;
/*
 * 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。	
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 * 
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){ //第一个值以已经使用，从第二个数开始，所以i从1开始
			if(maxValue < arr[i]){
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(minValue > arr[i]){
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
		//求数组元素的总和
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
			sum += arr[i];
		}
		System.out.println("总和为：" + sum);
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

K P(3. 数组的复制)

array2 = array1，只是将array1的地址给了array2，两个的地址值相同不能称作数组的复制

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CbiW5u0G-1632470839664)(E:\All Documents\typora documents\JAVA\JAVA 尚硅谷 pictures\image-20210313103248994.png)]$

需要新new一个array2

package com.atguigu.exer;
/*
 * 
 * 使用简单数组
(1)创建一个名为ArrayExer2的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
 * 
 */
public class ArrayExer3 {
	public static void main(String[] args) {  //alt + /
		int[] array1,array2;
		
		array1 = new int[]{2,3,5,7,11,13,17,19};
		
		//显示array1的内容
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
		
		//数组的复制:
		//赋值array2变量等于array1,知识地址相同，不能称作数组的复制。
		//array2 = array1;只是将地址复制给array2
		array2 = new int[array1.length];
		for(int i = 0;i < array2.length;i++){
			array2[i] = array1[i];
		}

		
		//修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
		for(int i = 0;i < array2.length;i++){
			if(i % 2 == 0){
				array2[i] = i;
			}
			
		}
		System.out.println();
		//打印出array1
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
	}
}

K P(3.数组的复制、反转、查找(线性查找、二分法查找))

package com.atguigu.java;
/*
 * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
 * 
 * 
 */
public class ArrayTest2 {
	
	public static void main(String[] args) {
		
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
		
		//数组的复制(区别于数组变量的赋值：arr1 = arr)
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++){
			arr1[i] = arr[i];
		}
		
		//数组的反转
		//方法一：
//		for(int i = 0;i < arr.length / 2;i++){ 循环条件！！！！！！！！！
//			String temp = arr[i];
//			arr[i] = arr[arr.length - 1 - i];//最后一个元素为arr.length - 1,当i = 0时 最后一个元素为arr[5],即arr[0]=arr[5],arr[1]=arr[4]
//			arr[arr.length - 1 - i] = temp;
//		}
		
		//方法二：
//		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
//			String temp = arr[i];
//			arr[i] = arr[j];
//			arr[j] = temp;
//		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		
		System.out.println();
		//查找（或搜索）
		//线性查找：
		String dest = "BB";
		dest = "CC";
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
			
			if(dest.equals(arr[i])){ //(一般int型用)dest == arr[i] = dest.equals(arr[i])（一般String用）
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
			
		}
		if(isFlag){
			System.out.println("很遗憾，没有找到的啦！");
			
		}
		
        
        //二分法查找：(熟悉)
		//前提：所要查找的数组必须有序。
		int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		
		int dest1 = -34;
		dest1 = 35;
		int head = 0;//初始的首索引
		int end = arr2.length - 1;//初始的末索引
		boolean isFlag1 = true;
		while(head <= end){
			
			int middle = (head + end)/2;
			
			if(dest1 == arr2[middle]){
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1){
				end = middle - 1;	
			}else{//arr2[middle] < dest1
				head = middle + 1;
			}

			
		}
		
		if(isFlag1){
			System.out.println("很遗憾，没有找到的啦！");
		}
		
		
	}
}

排序算法

衡量排序算法的优劣:

时间复杂度:分析关键字的比较次数和记录的移动次数
空间复杂度:分析排序算法中需要多少辅助内存
稳定性:若两个记录A和B的关键字值相等，但排序后A、B的先后次序保
持不变，则称这种排序算法是稳定的。

排序算法分类:内部排序和外部排序。

内部排序:整个排序过程不需要借助于外部存储器(如磁盘等)，所有排序操作都在内存中完成。
外部排序:参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器(如磁盘)。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序算法
●选择排序
➢直接选择排序、堆排序
●交换排序
➢冒泡排序、快速排序
●插入排序
➢直接插入排序、折半插入排序、Shell排序
●归并排序
●桶式排序
●基数排序

Train(冒泡排序)

package com.atguigu.java;
/*
 * 数组的冒泡排序的实现
 * 
 */
public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		//冒泡排序
		for(int i = 0;i < arr.length - 1;i++){//最后一轮只剩下一个元素
			
			for(int j = 0;j < arr.length - 1 - i;j++){
			//每执行一轮，相邻对比的次数就减少，i=0第一轮执行9次	
				if(arr[j] > arr[j + 1]){
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}	
			}
		}
			
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		
	}
}

快排时间复杂度: 0(nlogn)

冒泡时间复杂度: 0( n^2)

Train(快速排序）

package com.atguigu.java;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 * @author shkstart
 * 2018-12-17
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

K P(数组常用五种方法)

package com.atguigu.java;

import java.util.Arrays;

/*
 * java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
 * 
 * 
 */
public class ArraysTest {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中(替换)。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		//System.out.println(index);//如果找不到会出现负数
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}
		
		
	}
}

K P(数组常见异常)

package com.atguigu.java;
/*
 * 数组中的常见异常：
 * 1. 数组角标越界的异常：ArrayIndexOutOfBoundsException
 * 
 * 2. 空指针异常：NullPointerException
 * 
 */
public class ArrayExceptionTest {
	public static void main(String[] args) {
		
		1. 数组角标越界的异常：ArrayIndexOutOfBoundsException
		int[] arr = new int[]{1,2,3,4,5};
		
//		for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);
//		}
		
//		System.out.println(arr[-2]);
		
//		System.out.println("hello");前方异常后后面不执行
		
		2.  空指针异常：NullPointerException
		//情况一：
//		int[] arr1 = new int[]{1,2,3};
//		arr1 = null; 赋值为null或者一开始只定义没有初始化
//		System.out.println(arr1[0]);
		
		//情况二：
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3[0].toString());
	}
}