Java中数组的使用-CSDN博客

本文链接：https://blog.csdn.net/m0_49124752/article/details/132001158

文章目录

一、数组的概述
二、一维数组的使用
三、多维数组的使用
四、数组的练习
五、数组中涉及到的常见算法
六、Arrays工具类的使用
七、自定义数组的工具类
八、数组使用中的常见异常

一、数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改。
可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
数组的分类：
①按照维度：一维数组、二维数组、三维数组、…
②按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

二、一维数组的使用

一维数组的声明方式。例如：

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组

Java语言中声明数组时不能指定其长度(数组中元素的数)，例如： int a[5]; //非法
静态初始化：在定义数组的同时就为数组元素分配空间并赋值。例如：

int arr[] = new int[]{ 3, 9, 8};
int[] arr = {3,9,8};

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行。例如：

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素。
数组元素的引用方式：数组名[数组元素下标]
①数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
②数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
数组一旦初始化，其长度是不可变的。
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

public class Test {
	public static void main(String argv[]){
		int a[]= new int[5];
		System.out.println(a[3]); //a[3]的默认值为0
	}
}

①对于基本数据类型而言，默认初始化值各有不同。
②对于引用数据类型而言，默认初始化值为null(注意与0不同)。
在这里插入图片描述

/*
 * 	一、数组的概述
 * 1.数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，
 * 	并通过编号的方式对这些数据进行统一管理。
 * 
 * 2.数组相关的概念
 * >数组名
 * >元素
 * >角标、下标、索引
 * >数组的长度：元素的个数
 * 
 * 3.数组的特点：
 * 1）数组的有序排列的。
 * 2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
 * 3）创建数组对象会在内存中开辟一整块连续的空间。
 * 4）数组的长度一旦确定，就不能修改。
 * 
 * 4.数组的分类：
 * ①按照维数：一维数组、二维数组、. . . . . .
 * ②按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组。
 * 
 * 5.一维数组的使用
 * ①一维数组的声明和初始化
 * ②如何调用数组的指定位置的元素
 * ③如何获取数组的长度
 * ④如何遍历一维数组
 * ⑤数组元素的默认初始化值：见ArrayTest1.java
 */
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[];
//		int[] arr3 = new int[3] { 1, 2, 3 };

		// 也是正确的写法：
		int[] arr4 = { 1, 2, 3, 4 };// 类型推断

		// 总结：数组一旦初始化完成，其长度就确定了。

		// 2.如何调用数组的指定位置的元素：通过角标的方式调用
		// 数组的角标（或索引）从0开始的，到数组的长度-1结束
		names[0] = "000";
		names[1] = "111";
		names[2] = "222";
		names[3] = "333";
		names[4] = "444";// charAt(0)
//		names[5] = "555";

		// 3.如何获取数组的长度
		// 属性：length
		System.out.println(names.length);
		System.out.println(ids.length);

		// 4.如何遍历数组
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
	}
}

/*
 * ⑤数组元素的默认初始化值
 * 	>数组元素是整型：0
 * 	>数组元素是浮点型：0.0
 * 	>数组元素是char型：0或'\u0000'，而非'0'
 * 	>数组元素是boolean型：false
 * 
 * 	>数组元素是引用数据类型：null
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		// 5.数组元素的默认初始化值
		int[] arr = new int[4];
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

		System.out.println();
		short[] arr1 = new short[4];
		for (int i = 0; i < arr1.length; i++) {
			System.out.println(arr1[i]);
		}

		System.out.println();
		float[] arr2 = new float[4];
		for (int i = 0; i < arr2.length; i++) {
			System.out.println(arr2[i]);
		}

		System.out.println();
		char[] arr3 = new char[4];
		for (int i = 0; i < arr3.length; i++) {
			System.out.println("-" + arr3[i] + "*");
		}

		if (arr3[0] == 0) {
			System.out.println("你好！");
		}

		System.out.println();
		boolean[] arr4 = new boolean[4];
		for (int i = 0; i < arr4.length; i++) {
			System.out.println(arr4[i]);
		}

		System.out.println();
		String[] arr5 = new String[4];
		for (int i = 0; i < arr5.length; i++) {
			System.out.println(arr5[i]);
		}

		if (arr5[0] == null) {
			System.out.println("今天天气不错！");
		}
	}
}

三、多维数组的使用

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

/*
 * 二维数组的使用
 * 
 * 1.理解
 * 	对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 * 	其实，从数组底层的运行机制来看，其实没有多维数组。
 * 
 * 2.二维数组的使用
 * ①二维数组的声明和初始化
 * ②如何调用数组的指定位置的元素
 * ③如何获取数组的长度
 * ④如何遍历二维数组
 * ⑤数组元素的默认初始化值：见ArrayTest3.java
 */
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] arr4 = new String[][];
//		int[][] arr1 = new int[4][3] { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };

		// 也是正确的写法：
		int arr4[][] = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };
		int arr5[][] = { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };

		// 2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][2]);// 2
		System.out.println(arr2[1][1]);// null

		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);// null

		// 3.如何获取数组的长度
		System.out.println(arr4.length);// 3
		System.out.println(arr4[0].length);// 3
		System.out.println(arr4[1].length);// 2

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

/*
 * 	二维数组的使用：
 * 	规定：二维数组分为外层数组的元素，内层数组的元素
 * 		int[][] arr = new int[4][3];
 * 		外层元素：arr[0],arr[1]等
 * 		内层元素：arr[0][0],arr[1][2]等
 * 
 * ⑤数组元素的默认初始化值
 * 	针对于初始化方式一：比如：int[][] arr = new int[4][3];
 * 		外层元素的初始化值为：地址值
 * 		内层元素的初始化值为：与一维数组初始化情况相同
 * 	针对于初始化方式二：比如int[][] arr = new int[4][];
 * 		外层元素的初始化值为：null
 * 		内层元素的初始化值为：不能调用，否则报错
 */
public class ArrayTest3 {
	public static void main(String[] args) {
		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

		System.out.println("-----------------");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);// [F@7852e922
		System.out.println(arr1[0][0]);// 0.0

		System.out.println("-----------------");
		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);// [Ljava.lang.String;@4e25154f
		System.out.println(arr2[1][1]);// null

		System.out.println("-----------------");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);// null
//		System.out.println(arr3[1][0]);//报错
	}
}

四、数组的练习

1）练习一：成绩评分

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

public class ArrayDemo {
	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];
			}
		}

		// 5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
		char 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);
		}
	}
}

2）练习二：遍历总和

public class ArrayExer {
	public static void main(String[] args) {
		int[][] arr = new int[][] { { 3, 5, 8 }, { 12, 9 }, { 7, 0, 6, 4 } };
		
		int sum = 0;// 记录总和
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				sum += arr[i][j];
			}
		}
		
		System.out.println("总和为：" + sum);
	}
}

3）练习三：杨辉三角

使用二维数组打印一个 10 行杨辉三角。
提示：
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) {
				for (int j = 1; j < yangHui[i].length - 1; j++) {
					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] + "\t");
			}
			System.out.println();
		}
	}
}

运行结果

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

五、数组中涉及到的常见算法

求数值型数组中元素的最大值、最小值、平均数、总和等。

定义一个int型的一维数组，包含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 = 0; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);

		// 数组元素的最小值
		int minValue = arr[0];
		for (int i = 0; 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);
	}
}

数组的复制、反转、查找(线性查找、二分法查找)。

public class ArrayTest2 {
	public static void main(String[] args) {
		String[] arr = new String[] { "JJ", "DD", "MM", "BB", "GG", "AA" };

		// 数组的复制(区别于数组变量的赋值：arr1 = arr2)
		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 - i -1];
//			arr[arr.length - i -1] = 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])) {
				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("很遗憾，没有找到的啦！");
		}
	}
}

六、Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。例如：
①boolean equals(int[] a,int[] b) ：判断两个数组是否相等。
②String toString(int[] a) ：输出数组信息。
③void fill(int[] a,int val) ：将指定值填充到数组之中。
④void sort(int[] a) ：对数组进行排序。
⑤int binarySearch(int[] a,int key)：对排序后的数组进行二分法检索指定的值。
java.util.Arrays类的sort()方法提供了数组元素排序功能。

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);
		if (index >= 0) {
			System.out.println(index);
		} else {
			System.out.println("未找到");
		}
	}
}

七、自定义数组的工具类

自定义数组工具类

public class ArrayUtil {

	// 求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	// 求数组的最小值
	public int getMin(int[] arr) {
		int minValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}

	// 求数组的总和
	public int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}

	// 求数组的平均值
	public int getAvg(int[] arr) {
		return getSum(arr) / arr.length;
	}

	// 如下的两个同名方法构成了重载
	// 反转数组
	public void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}

	public void reverse(String[] arr) {
		
	}

	// 复制数组
	public int[] copy(int[] arr) {
		int[] arr1 = new int[arr.length];
		for (int i = 0; i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		return arr1;
	}

	// 数组排序
	public void sort(int[] arr) {
		// 冒泡排序
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
//					int temp = arr[j];
//					arr[j] = arr[j + 1];
//					arr[j + 1] = temp;
					// 错误的：
//					swap(arr[j],arr[j + 1]);
					// 正确的：
					swap(arr, j, j + 1);
				}
			}
		}
	}

	// 错误的：交换数组中指定两个位置元素的值
//	public void swap(int i,int j){
//		int temp = i;
//		i = j;
//		j = temp;
//	}

	// 正确的：交换数组中指定两个位置元素的值
	public void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// 遍历数组
	public void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
	}

	// 查找指定元素
	public int getIndex(int[] arr, int dest) {
		// 线性查找：
		for (int i = 0; i < arr.length; i++) {
			if (dest == arr[i]) {
				return i;
			}
		}
		return -1;// 返回一个负数，表示没有找到
	}
}

测试类

public class ArrayUtilTest {
	public static void main(String[] args) {
		ArrayUtil util = new ArrayUtil();
		int[] arr = new int[] { 32, 34, 32, 5, 3, 54, 654, -98, 0, -53, 5 };
		int max = util.getMax(arr);
		System.out.println("最大值为：" + max);

		System.out.println("排序前：");
		util.print(arr);

		util.sort(arr);
		System.out.println("排序后：");
		util.print(arr);

		System.out.println("查找：");
		int index = util.getIndex(arr, -5);
		if(index >= 0){
			System.out.println("找到了，索引地址为：" + index);
		}else{
			System.out.println("未找到");
		}

		util.reverse(arr);
	}
}

八、数组使用中的常见异常

①数组脚标越界异常(ArrayIndexOutOfBoundsException)

//访问到了数组中的不存在的脚标时发生。
int[] arr = new int[2];
System.out.println(arr[2]);
System.out.println(arr[-1]);

②空指针异常(NullPointerException)

//arr引用没有指向实体，却在操作实体中的元素时。
int[] arr = null;
System.out.println(arr[0]);

以上两种异常，编译时，不报错！

public class ArrayExceptionTest {
	public static void main(String[] args) {

		// 1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
		int[] arr = new int[] { 1, 2, 3, 4, 5 };

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

		// 2.空指针异常：NullPointerException
		// 情况一：
//		int[] arr1 = new int[]{1,2,3};
//		arr1 = 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());
	}
}