数组详解-优快云博客

本文链接：https://blog.youkuaiyun.com/Xiaobai_rabbit0/article/details/109548529

数组

1、概述
- 1.1、数据结构&算法
2、一维数组
3、二维数组
4、数组的常见算法
5、Arrays工具类的使用
6、数组的常见异常

1、概述

数组的理解：数组(Array)，是多个相同类型数据一定顺序排列的集合
数组相关的概念：

数组名
元素
角标、下标、索引
数组的长度：元素的个数

数组的特点：

数组是序排列的
数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
创建数组对象会在内存中开辟一整块连续的空间
数组的长度一旦确定，就不能修改

数组的分类：

照维数：一维数组、二维数组、…
照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

1.1、数据结构&算法

数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
线性表（一对一）：

顺序表（比如：数组）；
链表；
栈：先进后出；
队列：先进先出。
树形结构（一对多）：二叉树
图形结构
算法：（10个）
选择排序（直接选择排序、堆排序）
交换排序（冒泡排序、快速排序）
插入排序（直接插入排序、折半插入排序、Shell排序）
归并排序
桶式排序
基数排序

2、一维数组

1、一维数组的声明&初始化：

		int[] ids;//声明
		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];

		int[] arr4 = {1,2,3,4,5};//类型推断

note:数组的角标（或索引从0开始的，到数组的长度-1结束)
2、数组的属性：length

System.out.println(names.length);//5
System.out.println(ids.length);

说明：

数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。
3、一维数组的遍历

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

4、一维数组元素的——默认初始化值

- 数组元素是整型：0；
- 数组元素是浮点型：0.0；
- 数组元素是**char**型：**0**或'\u0000'，而**非'0'**
- 数组元素是boolean型：false；
- 数组元素是引用数据类型（String）：null；

eg：一维数组练习题

package com.atguigu.contact;

import java.util.Scanner;

/*
 *  作业1、
 	从键盘读入学生成绩，找出最高分，
	并输出学生成绩等级。
	成绩>=最高分-10 等级为’A’
	成绩>=最高分-20 等级为’B’
	成绩>=最高分-30 等级为’C’
	其余 等级为’D
 */

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 + "个学生成绩：");
//		for(int i = 0;i < scores.length; i++){
//			scores[i] = scanner.nextInt();	
//		}
//		//4.获取数组中元素的最大值，即最高分
//		int maxScore = 0;
//		for(int i = 0; i < scores.length; i++){
//			if(maxScore < scores[i]){
//				maxScore = scores[i];
//			}
//		}
		//3+4.给数组中的元素赋值,获取数组中元素的最大值
		int maxScore = 0;
		System.out.println("请输入" + number + "个学生成绩：");
		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);
		}
		scanner.close();
	}
}

3、二维数组

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][];
	//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

2、二维数组的属性：length

	    System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4

3、二维数组的遍历

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

4、二维数组元素的——默认初始化值

 * 	规定：二维数组分为外层数组的元素，内层数组的元素
 * 		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
 *      内层元素的初始化值为：不能调用，否则报错。

练习：
在这里插入图片描述

4、数组的常见算法

4.1、数组的创建与元素赋值

1、杨辉三角（二维数组）、回形数（二维数组）、1-30之间随机生成6个数且不重复。
在这里插入图片描述

杨辉三角（二维数组）

//杨辉三角：yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];

public class YangHuiTest {
	public static void main(String[] args) {
		//首先，定义数组
		int[][] yangHui = new int[10][];
		
		//初始化数组
		for(int i = 0; i < yangHui.length; i++){
			
			yangHui[i] = new int[i + 1];
			
			yangHui[i][0] = yangHui[i][i] = 1;
//		}
		//为数组赋值
//		for(int i = 1; i < yangHui.length; i++){
			for(int j = 1; j < yangHui[i].length-1; j++){
				yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
			}
		}
		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();
		}
		//打印输出
	}
}

创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同

//public class YangHuiTest {
//	public static void main(String[] args) {
//		int[] arr = new int[6];
//		
//		boolean isFlag = true;
//		for(int i = 0; i < arr.length; i++){
//			while(true){
//				arr[i] = (int)(Math.random() * 30) + 1;                //Math.random   [0,1)
//				for(int j = 0; j < i; j++){
//					if(arr[i] == arr[j]){
//						isFlag = false;
//						break;
//					}
//				}
//				if(isFlag == false){
//					arr[i] = (int)(Math.random() * 30) + 1;  
//					isFlag = true;
//					continue;
//				}else{
//					break;
//				}
//			}
//		}
//		for(int i = 0; i < arr.length; i++){
//			System.out.println(arr[i]);
//		}	
//	}
//}

//创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同        --改进版
public class YangHuiTest {
	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;
			for(int j =0; j < i; j++){
				if(arr[i] == arr[j]){
					i--;
					break;
				}
			}
		}
		for(int i = 0;i < arr.length; i++){
			System.out.println(arr[i]);
		}
	}
}

回形数（二维数组）

2、针对于数值型的数组，求最大值、最小值、总和、平均数等

package com.atguigu.java;

//数组算法考察：求数值型数组中元素的最大值、最小值、平均数、总和等
/*
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机数，然后求出所有元素的最大值、最小值、平均数、总和。
 * 要求：所有随机数都是两位数
 * 
 * */

public class ArrSuanFa2 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i = 0;i < arr.length; i++){
			arr[i] = (int)(Math.random() * 90) + 10;    //公式：[a,b]    (int)(Math.random() * (b-a+1) + a); --> [a,b] ==[a,b+1)
			System.out.print(arr[i] + "\t");
		}
		int maxValue = arr[0];
		int minValue = arr[0];
		int sum = 0;
		float average = 0;
		for(int i = 0;i < arr.length; i++){
			if(maxValue < arr[i]){
				maxValue = arr[i];
			}
			if(minValue > arr[i]){
				minValue = arr[i];
			}
			sum += arr[i];
		}
		average = sum / 10;
		System.out.println();
		System.out.println("最大值为：" + maxValue);
		System.out.println("最小值为：" + minValue);
		System.out.println("总和为：" + sum);
		System.out.println("平均数为：" + average);
	}
}

3、数组的赋值与复制
4、数组元素的反转
5、数组中指定元素的查找：搜索、检索

package com.atguigu.java;

/*
数组算法：数组的复制、反转、查找（线性查找、二分法查找）

思考： array1和array2是什么关系？                                  答： 这里不叫复制，可以叫做赋值。 （地址一样）
 * */

public class ArrSuanFa3 {
	public static void main(String[] args){
		String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
		String[] arr1 = new String[arr.length];
		//数组复制（区别于数组变量的赋值：arr1 = arr）
		for(int i = 0; i < arr.length; i++){
			
			arr1[i] = arr[i];
			System.out.println(arr1[i]);
		}
		
		//数组反转
		for(int i = 0; i < arr.length / 2; i++){
			String temp;
			temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
		System.out.println();
		for(int i = 0; i < arr.length; i++){
			System.out.println(arr[i]);
		}
		
		//查找（或搜索）：线性查找
		String dest = "CC";
		boolean isFlag = false;
		for(int i = 0;i < arr.length; i++){
			if(dest.equals(arr[i])){
				System.out.println("找到了，位置为：" + i);
				isFlag = true;
				break;
			}
		}
		if(isFlag == false){
			System.out.println("很抱歉，没找到的了！");
		}
		
		//二分法查找
		//前提：所要查找的数组必须有序
		int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int dest1 = 34;
		int head = 0;
		int end = arr2.length - 1;

		boolean isFlag1 = true;
		
		while(head <= end){
			
			int middle = (end + head)/2;
			
			if(dest1 == arr2[middle]){
				System.out.println("找到了，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(dest1 < arr2[middle]){
				
				end = middle -1;
			}else{
				head = middle + 1;
			}
		}
		if(isFlag1 == true){
			System.out.println("很抱歉，没找到的了！");
		}
	}
}

4.2数组的排序算法

4.2.1、冒泡排序

1、介绍
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来。
2、排序思想

比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

package com.atguigu.java;

//数组冒泡排序的实现

public class BubbleSort {
	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++){
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		System.out.println();
		for(int i = 0; i < arr.length-1; i++){
			System.out.print(arr[i] + "\t");
		}
		
	}
}

4.2.2、快速排序

1、介绍
快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性。

快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))。
2、排序思想

从数列中挑出一个元素，称为"基准"（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去

package com.atguigu.java;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 */
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));
	}
}

4.2.3、排序算法性能对比

在这里插入图片描述

4.2.4、排序算法性的选择

1、若n较小(如n≤50)，可采用直接插入或直接选择排序

当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直
接插入，应选直接选择排序为宜
2、若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜
3、若n较大，则应采用时间复杂度为O(nlgn)的排序方法： 快速排序、 堆排序或归并排序

5、Arrays工具类的使用

1、理解

定义在java.util包下；
Arrays:提供了很多操作数组的方法
2、使用

		//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("未找到");
		}

6、数组的常见异常

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