六： 数 组（eclipse的使用）

复习

一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3。编程 找出1000以内的所有完数。（因子：除去这个数本身的其它约数）

//3.一个数如果恰好等于它的因子之和，这个数就称为"完数"。
//例如6=1＋2＋3。编程 找出1000以内的所有完数。（因子：除去这个数本身的其它约数）


public class day05
{
	public static void main(String[] args)
	{
		
		
		for(int i=1;i<1000;i++)
		{
			int factor=0;
			for(int j=1;j<=i/2;j++)
			{
				if(i%j==0)
				{
					factor+=j;
				}
			}
			if(i==factor)
			{
				System.out.println(i);
			}
		}
		
	}
}

隐藏eclipse中的工程

3.2 一维数组的使用：数组元素的引用p10

package come.atguigu.java;
/*
 *
 * 一、数组的概述
 * 1.数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，
 * 并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
 * 
 * 2.数组的相关概念：
 * >数组名
 * >元素
 * >角标、下标、索引
 * >数组的长度：元素的个数
 * 
 * 3.数组的特点：
 * 1)数组属于引用类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
 * 2)创建数组对象会在内存中开辟一整块连续的空间；
 * 3)数组的长度一旦确定，就不能修改;
 * 4)数组是有序排列的。
 * 
 * 4.数组的分类：
 * 	① 按照维数：一维数组、二维数组、三维数组……
 *  ② 按照数组元素类型：基本数据类型元素的数组、引用类型元素的数组
 *    
 * 5.一维数组的使用
 * 	① 一维数组的声明和初始化
 *  ② 如何调用数组的指定位置的元素
 *  ③ 如何获取数组的长度
 *  ④ 如何遍历数组
 *  ⑤ 数组元素的默认初始化值：    见ArrayTest1.java
 *  ⑥ 数组的内存解析：          见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[5];//前边的[]永远都是空的
//				int[] arr3 = new int[3]{1,2,3};//动静合二为一也不行
				
//也是正确的写法：
				int[] arr7 = {1,2,3,5,4};//类型推断
				
/*总结：数组一旦初始化完成，其长度就确定了。
				*/
				
				
				
				
//2.如何调用数组的指定位置的元素：通过角标的方式调用。
//数组的角标(或索引)从0开始的，到数组的长度-1结束
				names[0] = "张郃";
				names[1] = "王陵";
				names[2] = "张学良";
				names[3] = "王传志";	//charAt(0)//java只要是涉及到索引问题，几乎都是从0开始，包括字符串
				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]);
				
//	ctrl+/全部注释，相同操作复原，
//	ctrl+shift+/  多行注释,ctrl+shift+\ 复原
				
				for(int i = 0;i < names.length;i++){
					System.out.println(names[i]);
				}
		
		
	}
	

}

3.2 一维数组的使用：数组元素的默认初始化值p12

package come.atguigu.java;
/*
 * ⑤ 数组元素的默认初始化值
 * 		> 数组元素是整形(byte,short,int,long)：0
 * 		> 数组元素是浮点型(float,double)：0.0
 * 		> 数组元素是char型：0或'\u0000'，而非'0'
 * 			'a'---->97
 * 			'A'---->65
 * 			'0'---->……
 * 			 ……---->0  char的默认值是此 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[5]; 
		for(int i = 0;i < arr2.length;i++){
			System.out.println(arr2[i]);
		}
		System.out.println("*****************");
		
		
		char[] arr3 = new char[5]; 
		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[5];
		System.out.println(arr4[0]);
		
		System.out.println("*****************");
		
		
		
		String[] arr5 = new String[5];
		System.out.println(arr5[0]);
		//验证
		if(arr5[0] == null){
			System.out.println("北京天气好差！");
		}
		
	}
}

3.2 一维数组的使用p21

package come.atguigu.exer;

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

3.2 一维数组的使用p22

package come.atguigu.exer;

import java.util.Scanner;

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

//1.使用Scanner，读取学生个数
//2.创建数组，存储学生成绩：动态初始化
//3.给数组中的元素赋值
//4.获取数组中的元素最大值：最高分
//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩




public class ArrayDemo1 {
	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.3 多维数组的使用p24

ArrayTest2

package come.atguigu.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,9}};
		
		//动态初始化1
		String[][] arr2 = new String[3][2];
		
		//动态初始化2
		String[][] arr3 = new String[3][];
		
		//错误的情况
//		String[][] arr4 = new String[][];
//		String[][] arr5 = new String[][4];
//		String[][] arr6 = new String[4][3]{{1,2,3},{4,5,6},{7,8,9}};
		
		//正确的情况：
		int arr4[][] = new int[][]{{1,2,3},{4,5,12,6},{7,8,9}};
		int[] arr5[] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
		int[][] arr6 = {{1,2,3},{4,5,6},{7,8,9}};		
		
//2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][1]); 	//2
		System.out.println(arr2[1][1]); 	//null
		
		arr3[1] = new String[4];	//定义arr3的[1]为长度为4的字符数组
		System.out.println(arr3[1][0]);	   //null   ,若没有上句，会报错
		
//3.获取数组的长度
		System.out.println(arr4.length);	//3，a4就是一维数组，只不过元素恰好也是一维数组而已
		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();
		}
	}
}

3.3 多维数组的使用p25

引用类型的变量，保存的要么是地址值，要么是null

ArrayTest3

package come.atguigu.java;

/*
 * 二维数组的使用：
 * 	规定：二维数组分为外层数组的元素，内层数组的元素
 * 	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，每一个元素是int型的数组，是引用类型，没有赋值，因此是null
 * 		内层元素的初始化值为：不能调用，否则报错。
 * 
 * 	⑥ 数组的内存解析
 */
public class ArrayTest3 {
	public static void main(String[] args) {
		
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);	//[I@15db9742  输出int型一维地址值
		System.out.println(arr[0][0]);	//0
		
		System.out.println(arr);	//[[I@626b2d4a  输出int型二维地址值
		
		
		
		System.out.println("***********************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);	//[F@5e91993f
		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;@1175e2db
		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]);	//报错
	}
}

3.3 多维数组的使用p32

package com.atguigu.exer;

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

3.3 多维数组的使用p34

package com.atguigu.exer;

/*
 * 使用二维数组打印一个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[][] arr = new int[10][];
		
//2.给数组的元素赋值，遍历二维数组
		for(int i = 0;i < arr.length;i++){
			arr[i] = new int[i+1];
			
			//2.1 给首末元素赋值
			arr[i][0]=arr[i][i]=1;
			
			//2.2 给每行的非首末元素赋值
		//	if(i > 1){
			for(int j = 1;j < arr[i].length-1;j++){
					arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
				}
		//	}
	
		}
		
	//	3.遍历数组
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j <arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
		
	}
}

随机数

 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 * 
 * 注：
 * Math.random()   				:[0.0,1)
 * Math.random()*90				:[0.0,90.0)
 * (int)(Math.random()*90)		:[0,89]
 * (int)(Math.random()*90+10)	:[10,99]
 * 
 * 公式：获取[a,b]范围的随机数：(int)(Math.random())*(b-a+1))+a

3.4 数组中涉及到的常见算法p37

package com.atguigu.java;


/*
 * 算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个 int 型的一维数组，包含 10 个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 * 
 * 注：
 * Math.random()   				:[0.0,1)
 * Math.random()*90				:[0.0,90.0)
 * (int)(Math.random()*90)		:[0,89]
 * (int)(Math.random()*90+10)	:[10,99]
 * 
 * 公式：获取[a,b]范围的随机数：(int)(Math.random())*(b-a+1))+a
 * 	
 * 
 * 
 */
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);//[0,1),[0,90),[10,100)
		}
		
		
		//遍历
		for(int i =0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		
		
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i <arr.length;i++){
			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 = 1;i <arr.length;i++){
			sum += arr[i];
		}
		System.out.println("总和：" + sum);
		
		//求数组元素的平均数
		double avgVales = (double)sum / arr.length;
		System.out.println("平均数：" + avgVales);		
	}
}

3.4 数组中涉及到的常见算法p38

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。
 * 
 * 1、思考：上述 array1 和 array2 是什么关系？
 * array1和array2地址相同，都指向了堆空间中的唯一的一个数组实体
 * 
 * 
 * 拓展：修改题目，实现 array2 对 array1 数组的复制
 * 
 */
public class ArrayExer2 {
	public static void main(String[] args) {
//声明 array1 和 array2 两个 int[]变量
		int[] array1,array2;
//array1 初始化
		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] + " ");
		}
		
		
//赋值 array2 变量等于 array1
        //不能称作数组的复制。
		//如下操作，如同在桌面建立一个文件A的快捷方式，这个快捷方式中保存的是这个文件A的地址值。
		array2 = array1;//是把array1的地址给了array2,array2指向的是堆中array1所指向的数组
		//二者指向同一个数组,只是建立了一个快捷方式
		//new一次就有一个数组，自始至终就new过一个，故只有一个数组
		//将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体
		
		
//修改 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] + " ");
		}
	}
}

3.4 数组中涉及到的常见算法p40

package com.atguigu.exer;

/*
 * 拓展：修改题目，实现 array2 对 array1 数组的复制
 * 
 * 其操作类似于网盘中的一个文件A，对他进行赋值，粘贴到桌面上，这样就有两套一模一样的文件了，对桌面
 * 上的文件进行操作，不影响文件A，即这两个文件就是真正的两套东西。
 * 
 */
public class ArrayExer3 {
	public static void main(String[] args) {
		//声明 array1 和 array2 两个 int[]变量
		int[] array1,array2;
		//array1 初始化
		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 = 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");
		}
	}
}

3.4 数组中涉及到的常见算法p36

package com.atguigu.java;

/*
 * 算法的考察：数组的复制、反转、查找(线性查找、二分法查找)
 */
public class ArrayTest2 {
	public static void main(String[] args) {
	
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
//数组的复制
		//通过new的方式，在堆空间中新开辟一个新数组。将array1数组
		//中的元素值一个一个地复制到array2数组中。
		//区别于数组变量的赋值：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 - i - 1];   //i+(arr.length-i-1)=常数arr.length-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] + " ");
		}
		System.out.println();
		
		
		
		
		
		
		
		//查找（或搜索）
		//线性查找
		String dest = "BB";	//要查找的元素
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
			if(dest.equals(arr[i])){//int型用==可以，但是这是字符串，
				System.out.println("找到了指定元素，位置为：" + i);
				isFlag = false;
				break;
			}
		}
		if(isFlag){
			System.out.println("很遗憾，没找到！");
		}
		
		//更进
		/*
		 * 	String dest = "BB";	//要查找的元素

		for(int i = 0;i < arr.length;i++){
			if(dest.equals(arr[i])){//int型用==可以，但是这是字符串，
				System.out.println("找到了指定元素，位置为：" + i);
				break;
			}
		}
		if(i==arr.length){
			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 = (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("很遗憾，没找到！");
				}
		
	}
}

3.4 数组中涉及到的常见算法：排序算法p47

package com.atguigu.java;
//p166
/*
 * 数组的冒泡排序的实现
 * 49 38 65 97 76 13 27 49
 * 38 49 65 76 13 27 49 97
 * 38 49 65 13 27 49 76 97
 * 38 49 13 27 49 65 76 97
 * 38 13 27 49 49 65 76 97
 * 13 27 38 49 49 65 76 97
 * 
 * 
 */
public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,92,-65,85,71,-42};
		
		//冒泡排序
		//string排序按照ABCD顺序排，中文按照Unicode值排序
		for(int i = 0;i < arr.length - 1;i++){//比较n-1轮
			
			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] + " ");
		}
	}
}

3.5 Arrays工具类的使用p56

package com.atguigu.java;

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,2,9,3};
		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[]{43,32,76,92,-65,85,71,-42}; 
		Arrays.sort(arr3);//排序
		
		System.out.println(Arrays.toString(arr3));//输出
		
		int index = Arrays.binarySearch(arr3, 43);//返回的是个负数则没找到，返回下标
		
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到。");
		}		
	}
}

3.6 数组使用中的常见异常p58

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,6};
		
		//错误1：
//		for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);
//		}
		
		//错误2：
//		System.out.println(arr[-2]);
		
//		System.out.println("hello");
		
		
		
		
		//2.空指针异常:NullPointerException
		//情况一:
//		int[] arr2= new int[]{1,2,3};
//		arr2 = null;//相当于栈中的arr2变量的指向堆中的指针被赋值为null,则堆中的数组不会被指了
//		System.out.println(arr2[0]);
		//情况二:
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三:
//		String[] arr3 = new String[]{"AA","QQ","YY","XX","TT","KK"};
//		arr3[0] = null;
//		System.out.println(arr3[0].toString());		
	}
}