Java入门——数组

一、数组的概述

1、数组的理解，数组（Array），是多个相同类型数据按照一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2、数组相关的概念

• 数组名
• 下标，角标（或索引）
• 元素
• 数组的长度

3、数组的特点

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

4、数组的分类

• ①按照维数，一维数组、二维数组……
• ②按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

二、一维数组

2.1一维数组的使用

①一维数组的声明和初始化 

②如何调用数组的指定位置的元素 
③如何获取数组的长度
④如何遍历数组

public class ArrayTest {
	
	public static void main(String[] args) {
		
		//①一维数组的声明和初始化
		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];
		
		
		//总结：数组一旦初始化完成，其长度就确定了。
		
		//②如何调用数组的指定位置的元素:通过角标的方式调用
		//数组的角标（或索引）从0开始的，到数组的长度-1结束。
		names[0] = "王明";
		names[1] = "王鹤";
		names[2] = "张雪莹";
		names[3] = "孙巨龙";
		names[4] = "王宏志";//charAt(0)
		
		
		//③如何获取数组的长度。
		//属性：length
		System.out.println(names.length);//5
		System.out.println(ids.length);
		
		//④如何遍历数组
//		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]);
		}
	}

}

⑤数组元素的默认初始化值

public class ArrayTest1 {
	public static void main(String[] args) {
		//⑤数组元素的默认初始化值
		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(short 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[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[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("今天天气不错！");
		}
	}
}

 ⑥数组的内存解析

 

2.2练习

/*
 * 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 + "学生成绩：");
		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];
			}
		}
		
		
		//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);
		}
	}
}

三、二维数组

3.1二维数组的使用

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

3.2二维数组的使用

①二维数组的声明和初始化

②如何调用数组的指定位置的元素

③如何获取数组的长度
④如何遍历数组

public class ArrayTest2 {
	public static void main(String[] args) {
		//①二维数组的声明和初始化
		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},{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}};
		//②如何调用数组的指定位置的元素
		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]);
		
		// ③如何获取数组的长度
		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();
		}
	}
}

 规定：二维数组分为外层数组的元素，内层数组的元素
        int[][] arr = new int[4][3];         

        外层元素：arr[0],arr[1]等
        内层元素：arr[0][0],arr[1][2]等

⑤数组元素的默认初始化值
   1.针对于初始化方式一：int[][] arr = new int[4][3];
           外层元素的初始化值为：地址值
           内层元素的初始化值为：与一维数组初始化情况相同
    2.针对于初始化方式一：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@19e0bfd
		System.out.println(arr[0][0]);//0
		
		//System.out.println(arr);//[[I@139a55
		
		System.out.println("*********************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);//地址值
		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]);//0
		
		System.out.println("*********************");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);//null
		System.out.println(arr3[1][0]);//报错
		
		
	}
}

 * 数组一旦初始化，其长度就是确定的
 * 数组长度一旦确定，就不可修改。

⑥二维数组的内存结构

 

四、数组的常见算法

4.1数组的创建与元素赋值

使用二维数组打印一个10行杨辉三角
【提示】
 * 1.第一行有1个元素，第n行有n个元素
 * 2.每一行的第一个元素和最后一个元素都是1
 * 3.从第三行开始，对于非第一个元素的最后一个元素的元素，即
 * yanghui[i][j] = yanghui[i-1][j] + 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] + " ");
			}
			System.out.println();
		}
	}
}

4.2针对于数值型的数组

 /*
 * 求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个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.println(arr[i] + "\t");
		}
		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 = 0; i < arr.length; i++){
			sum += arr[i];
		}
		System.out.println("总和为：" + sum);
		
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

4.3 数组的复制、反转、查找（线性查找、二分查找）

/*
 * 算法的考查，数组的复制、反转、查找（线性查找、二分查找）
 */
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 = "BB";
		dest = "CC";
		boolean isFlag = true;
		for(int i = 0; i < arr.length;i++){
			if(dest.equals(arr[i])){
				System.out.print("找到了指定的元素，位置为：" + 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;
		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.4数组的排序算法

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

理解：1）衡量排序算法的优劣
            时间复杂度、空间复杂度、稳定性
           2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）
           3）不同排序算法的时间复杂度

 

 冒泡排序

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] + "\t");
		}
	}
}

 快速排序：

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

五、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)	对排序后的数组进行二分法检索指定的值

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

六、数组的常见异常

/*
 * 数组中的常见异常：
 * 1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
 * 
 * 2.空指针异常：NullPointerException
 */
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]);
//		}
//		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());
	}
}