Java数组，看这一篇还不够

写在前面，Java基础系列文章都是作者基于b站尚硅谷的Java基础视频所做的笔记，没有时间的同学可以认真看看，如果有时间的同学，还是建议看看视频，毕竟笔记说到底还是自己的东西，每个人的习惯也是不一样的，所以为了自己，学就对了，加油！
也请各位同学，如果感觉对自己有帮助，可以帮忙给个一键三连，谢谢！

---

1.数组的概述

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

2. 一维数组的使用

/*
 * 5.一维数组的使用
 * 	① 一维数组的声明和初始化
 * 	② 如何调用数组 指定位置的元素
 * 	③ 如何获取数组的长度
 * 	④ 如何遍历数组
 * 	⑤ 数组元素的默认初始化值,见ArrayTest1.java
 * 	⑥ 数组的内存解析,见ArrayTest1.java
 */

案例

案例1：ArrayTest.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[5];
//		int[] arr3 = new int[3]{1,2,3};
		
		//也是正确的写法：
		int[] arr4 = {1,2,3,4,5}; //类型推断
		
		//总结：数组一旦初始化完成，其长度就确定了
		
		//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
		
		//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]);
		}
    
	} 
}

案例2：ArrayTest1.java

/*
 * 5.数组元素的默认初始化值
 * 		> 数组元素是整型：0
 * 		> 数组元素是浮点型：0.0
 * 		> 数组元素是char型：0或'\u0000',而非'0'
 * 		> 数组元素是boolean型：false
 * 		> 数组元素是引用数据类型：null
 * 
 * 6.数组的内存解析
 */

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]); //输出0
		}
		
		System.out.println("************************");
		short[] arr1 = new short[4];
		for(int i = 0;i < arr1.length;i++) {
			System.out.println(arr1[i]); //输出0
		}
		
		System.out.println("************************");
		float[] arr2 = new float[4];
		for(int i = 0;i < arr2.length;i++) {
			System.out.println(arr2[i]); //输出0.0
		}
		
		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]); //输出false
		}
		
		System.out.println("************************");
		String[] arr5 = new String[5];
		System.out.println(arr5[0]); //输出null
		if(arr5[0] == null) {
			System.out.println("北京天气不错");
		}
	}

}

2.1 一维数组的内存解析

一维数组的内存解析

int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = “刘德华”;
arr1[2] = “张学友”;
arr1 = new String[3];
System.out.println(arr1[1]);//null

2.2 一维数组练习

练习1

/*
 * 升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。
 * 屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
 * eclipse代码一键格式规范化：Ctrl+Shift+F
 */
public class ArrayDemo {
	public static void main(String[] args) {
		int[] arr = new int[] { 8, 2, 1, 0, 3 };
		int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
		String tel = "";
		for (int i = 0; i < index.length; i++) {
			tel += arr[index[i]];
		}
		System.out.println("联系方式：" + tel);
	}
}

练习2

/*
 * 2. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
 * 成绩>=最高分-10    等级为’A’   
 * 成绩>=最高分-20    等级为’B’
 * 成绩>=最高分-30    等级为’C’   
 * 其余等级为’D’
 * 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
 */
import java.util.Scanner;
public class ArrayDemo2 {
	public static void main(String[] args) {
		//1.使用Scanner，读取学生的个数
		Scanner scan = new Scanner(System.in);
		System.out.print("请输入学生人数：");
		int num = scan.nextInt();
		
		//2.创建数组，存储学生成绩，动态初始化
		int[] str = new int[num];
		System.out.println("请输入" + num + "个学生成绩");
				
		//3.给数组中的元素赋值
		int maxnum = 0;
		for(int i = 0;i < str.length;i++){
			str[i] = scan.nextInt();
			//4.获取数组元素中的最大值：最高分
			if(maxnum < str[i]){
				maxnum = str[i];
			}
		}
		
		//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩	
		char Grade;	//成绩等级
		for(int i = 0;i < str.length;i++){
			if(maxnum - str[i] <= 10){
				Grade = 'A';
			}else if(maxnum - str[i] <= 20){
				Grade = 'B';
			}else if(maxnum - str[i] <= 30){
				Grade = 'C';
			}else{
				Grade = 'D';
			}
			
			System.out.println("student " + i + "score is" + str[i] + 
					" grade is " + Grade);
		}
	}
}

3. 二维数组的使用

案例1：ArrayTest2.java

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

案例2：ArrayTest3.java

/*
 * 二维数组的使用：
 * 		规定：二维数组分为外层数组的元素，内层数组的元素
 * 		int[][] arr = new int[4][3];
 * 		外层元素：arr[0],arr[1]等
 * 		内层元素：arr[0][0],arr[1][2]等
 * 
 * 5.二维数组元素的默认初始化值
 * 	针对于初始化方式一：比如：int[][] arr = new int[4][3];
 * 		外层元素的初始化值为：地址值
 * 		内层元素的初始化值为：与一维数组初始化情况相同
 * 	针对于初始化方式二：比如：int[][] arr = new int[4][];
 * 		外层元素的初始化值为：null
 * 		内层元素的初始化值为：不能调用，否则报错
 * 
 * 6.二维数组的内存解析
 * 	
 */
public class ArrayTest3 {
	
	public static void main(String[] args) {
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);  //[I@7852e922
		System.out.println(arr[0][0]); //0
		
		System.out.println(arr); //[[I@4e25154f
		
		System.out.println("----------------------");
		
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);  //[F@70dea4e
		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;@5c647e05
		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]); //java.lang.NullPointerException
	}
  
}

二维数组[][]：数组中的数组
格式1（动态初始化）：int[ ] [ ] arr = new int[3] [2];
定义了名称为arr的二维数组 ，二维数组中有3个一维数组 ，每一个一维数组中有2个元素 ，一维数组的名称分别为arr[0], arr[1], arr[2] ，给第一个一维数组1脚标位赋值为78写法是：arr[0] [1] = 78;
格式2（动态初始化）：int[ ] [ ] arr = new int[3] [ ];
二维数组中有3个一维数组。 每个一维数组都是默认初始化值null (注意：区别于格式1）， 可以对这个三个一维数组分别进行初始化 arr[1] = new int[1]; arr[2] = new int[2]; 注： int [ ] [ ] arr = new int[][3]; //非法
格式3（静态初始化）：int[ ] [ ] arr = new int[ ] [ ]{ {3,8,2} , {2,7} , {9,0,1,6} };
定义一个名称为arr的二维数组，二维数组中有三个一维数组 每一个一维数组中具体元素也都已初始化 第一个一维数组 arr[0] = {3,8,2}; 第二个一维数组 arr[1] = {2,7}; 第三个一维数组 arr[2] = {9,0,1,6}; 第三个一维数组的长度表示方式：arr[2].length;
注意特殊写法情况：int[ ] x,y[ ]; x是一维数组，y是二维数组。Java中多维数组不必都是规则矩阵形式

3.1 二维数组的内存解析

案例1

int[][] arr1 = new int[4][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[4];
arr1[2][1] = 30;

案例2

int[][] arr4= newint[3][];
System.out.println(arr4[0]);//null
System.out.println(arr4[0][0]);//报错
arr4[0] = new int[3];
arr4[0][1] = 5;
arr4[1] = new int[]{1,2};

案例3

int[][] arr = new int[3][];
arr[1] = new int[]{1,2,3};
arr[2] = new int[3];
System.out.println(arr[0]);//null
System.out.println(arr[0][0]);//报异常

案例4

int[][] arr1= newint[4][];
arr1[0] = new int[3];
arr1[1] = new int[]{1,2,3};
arr1[0][2] = 5;
arr1 = new int[2][];

3.2 二维数组练习

练习1

public class ArrayExer1 {
	
	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);
		
	}
}

练习2

练习3：使用二维数组打印一个10行的杨辉三角

/*
 * 使用二维数组打印一个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] = 1; //首元素
			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] + " ");
			}
			System.out.println();
		}
		
	}
}

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

//此题只做了解，初学不必精通。
public class ArrayEver3 {
	public static void main(String[] args) {
		// 方式一：
//		int[] arr = new int[6];
//		for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
//			arr[i] = (int) (Math.random() * 30) + 1;
//
//			boolean flag = false;
//			while (true) {
//				for (int j = 0; j < i; j++) {
//					if (arr[i] == arr[j]) {
//						flag = true;
//						break;
//					}
//				}
//				if (flag) {
//					arr[i] = (int) (Math.random() * 30) + 1;
//					flag = false;
//					continue;
//				}
//				break;
//			}
//		}
//
//		for (int i = 0; i < arr.length; i++) {
//			System.out.println(arr[i]);
//		}
		// 方式二：
		int[] arr2 = new int[6];
		for (int i = 0; i < arr2.length; i++) {// [0,1) [0,30) [1,31)
			arr2[i] = (int) (Math.random() * 30) + 1;

			for (int j = 0; j < i; j++) {
				if (arr2[i] == arr2[j]) {
					i--;
					break;
				}
			}
		}

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

4. 有关数组的算法

4.1 数组元素的赋值

import java.util.Scanner;
/*
 * 此题了解！！！
 * 
 * 回形数格式方阵的实现
 * 从键盘输入一个整数（1~20） 
 * 则以该数字为矩阵的大小，把 1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 
 * 4 3 
 * 输入数字 3，则程序输出：1 2 3 
 * 8 9 4 
 * 7 6 5 
 * 输入数字 4， 则程序输出： 
 * 1   2   3   4
 * 12  13  14  5 
 * 11  16  15  6 
 * 10  9   8   7
 */
public class ArrayTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字:");
		int len = scanner.nextInt();
		int[][] arr = new int[len][len];
		int s = len * len;
		/*
		 * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
		 */
		int k = 1;
		int i = 0, j = 0;
		for (int m = 1; m <= s; m++) {
			if (k == 1) {
				if (j < len && arr[i][j] == 0) {
					arr[i][j++] = m;
				} else {
					k = 2;
					i++;
					j--;
					m--;
				}
			} else if (k == 2) {
				if (i < len && arr[i][j] == 0) {
					arr[i++][j] = m;
				} else {
					k = 3;
					i--;
					j--;
					m--;
				}
			} else if (k == 3) {
				if (j >= 0 && arr[i][j] == 0) {
					arr[i][j--] = m;
				} else {
					k = 4;
					i--;
					j++;
					m--;
				}
			} else if (k == 4) {
				if (i >= 0 && arr[i][j] == 0) {
					arr[i--][j] = m;
				} else {
					k = 1;
					i++;
					j++;
					m--;
				}
			}
		}
		// 遍历
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				System.out.print(arr[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

4.2 数组元素的基本操作

/*
 * 使用简单数组
 * (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。
 * 
 * 思考：array1和array2是什么关系？
 * 答：array1和array2的地址值相同，都指向了堆空间的唯一的一个数组实体
 * 
 * 拓展：修改题目，实现array2对array1数组的复制，见ArrayExer3.java
 */
public class ArrayExer2 {
	
	public static void main(String[] args) {
		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中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
		for(int i = 0;i < array2.length;i++) {
			if(i % 2 == 0) {
				array2[i] = i;
			}
		}
		
		//打印出array1
		System.out.println();
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + "\t");
		}
		
	}
}

扩展：ArrayExer3.java

/*
 * 拓展：修改题目，实现array2对array1数组的复制
 */
public class ArrayExer3 {
	
	public static void main(String[] args) {
		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 = 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;
			}
		}
		
		//打印出array1
		System.out.println();
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + "\t");
		}
		
	}
}

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

/*
 * 算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：获取[a,b]范围内的随机数：(int)( Math.random()*(b - a + 1) + a )
 * (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]; //如果随机数是负数，就不能用0，用数组里面的第一个元素
		for(int i = 1;i < arr.length;i++) { //然后数组从第二个元素开始对比
			if(maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为:"+maxValue);
		
		//求数组的最小值
		int minValue = arr[0]; //如果随机数是负数，就不能用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);
	}

}

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

/*
 * 算法的考察：数组的复制、反转、查找(线性查找、二分法查找)
 */
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 < arr1.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 = "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 = 54;
		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("很遗憾，没有找到哦!");
		}
	}
}

4.5 数组的冒泡排序的实现(重要)

• 冒泡排序的基本思想：通过对待排序序列从前向后，依次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部
• 因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序， 因此要在排序过程中设置一个标志swap判断元素是否进行过交换。从而减少不必要的比较

/*
 * 数组的冒泡排序的实现
 */
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++) {
				
				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] + " ");
		}
	}

}

4.6 快速排序

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

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

5. Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如: 排序和搜索）的各种方法。

1	boolean equals(int[ ] a,int[ ] b)	判断两个数组是否相等。
2	String toString(int[ ] a)	输出数组信息。
3	void fill ( int[ ] a,int val )	将指定值填充到数组之中。
4	void sort(int[ ] a)	对数组进行排序。
5	int binarySearch(int[ ] a,int key)	对排序后的数组进行二分法检索指定的值。

import java.util.Arrays;
/*
 * java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
 */
public class ArrayTest {

	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); //false,数组是有序的
		
		//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]; //如果随机数是负数，就不能用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]; //如果随机数是负数，就不能用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 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");
		}
	}
	
	//查找数组中指定的元素
	public int getIndex(int[] arr,int dest) {
	//线性查找：
		boolean isFlag = true;
		for(int i = 0;i < arr.length;i++) {
			if( dest == arr[i] ) {
				return i;
			}
		}
		return -1; //返回一个负数，表示没有找到
				
	}

}

6. 数组使用中的常见异常

编译时，不报错！！

数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[ ] arr = new int[2]; System.out.println(arr[2]); System.out.println(arr[-1]); 访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)
int[ ] arr = null; System.out.println(arr[0]); arr引用没有指向实体，却在操作实体中的元素时。

/*
 * 数组中的常见异常：
 * 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]);
		
		//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());
	}
}