3.数组练习题

1.数组脚标越界异常(ArrayIndexOutOfBoundsException)

   合理范围：[0,arr.length-1]

   越界：arr[-1],arr[arr.length]

python界限是[-arr.length-1,arr.length-1]

2.空指针异常(NullPointerException)

   int[] arr = null;

   arr[0] ;

二、代码练习

1.数组元素的调用

1.升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。

package com.atguigu.exer;


public class ArryDemo {
	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);//18013820100
		String[] str = new String[] {"霜叶红于二月花","北风卷地百草折","平生胆气尤奇伟"};
		char name = str[0].charAt(1);
		char name1 = str[1].charAt(1);
		System.out.println("姓名：" + name+name1);
		int[] arr1 = new int[]{8,6,1,0,3,7};
		int[] index1 = new int[]{2,5,0,1,2,4,2,4,3,0,1};
		String tel01 = "";
		for(int i = 0;i < index1.length;i++){
			tel01 += arr1[index1[i]];
		 }
		System.out.println("联系方式：" + tel01);//17861313086
		
		
	}

}

2.获取最大值

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

package com.atguigu.exer;

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

public class ArryDemo1 {
	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);//导包快捷键ctrl+shift+o
		
		//1.使用Scanner，读取学生个数
		System.out.print("请输入学生人数：");
		int num = scanner.nextInt();
		
		//2.创建数组，存储学生成绩：动态初始化
		int[] scores = new int[num];
		
		//3.给数组中的元素赋值
        int max=0;
		System.out.println("请输入"+num+"个成绩：");
		for(int i = 0;i<num;i++) {
			scores[i] = scanner.nextInt();

            //4.获取数组中的元素最大值：最高分
            if(max<=scores[i]) {
				max=scores[i];
			}
		}
		System.out.println("最高分是："+max);
        
        /*
		//4.获取数组中的元素最大值：最高分
		int max=0;
		max=scores[0];
		for(int i = 1;i<scores.length;i++) {
			if(max<=scores[i]) {
				max=scores[i];
			}
		}
		System.out.println("最高分是："+max);
		*/

		//5.根据每个学生成绩与最高分的差，得到每个学生的等级，并输出等级和成绩
		for(int i =0;i<scores.length;i++) {
			char grade;
			/*
             *输出学生等级
			 * if(max-scores[i] <= 10){
			 * 		grade = 'A';
			 * }else if(max-scores[i] <= 20){
			 * 		grade = 'B';
			 * }else if(max-scores[i] <= 30){
			 * 		grade = 'C';
			 * }else{
			 * 		grade = 'D';
			 * }
			 * */
                
            //输出学生等级
			switch((max-scores[i])/10) {
				case 0:
					grade = 'A';
					break;
				case 1:
					if(max-scores[i]==10) {
						grade = 'A';
					}else {
					grade = 'B';
					}
					break;
				case 2:
					if(max-scores[i]==20) {
						grade = 'B';
					}else {
					grade = 'C';
					}
					break;
				case 3:
					if(max-scores[i]==30) {
						grade = 'C';
					}else {
					grade = 'D';
					}
					break;
				default:
					grade = 'D';
			}
			System.out.println("student"+" "+i+" "+"score is"+" "+scores[i]+" "+"grade is"+" "+grade);
		}
	}
}

3.数组元素相加

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++) {
				System.out.print(arr[i][j]+" ");
				sum += arr[i][j];
			}
			System.out.println();
		}
		System.out.println("arr数组的总和为："+sum);//54
	}

}

4.数组中涉及的常见算法

1. 数组元素的赋值 ( 杨辉三角、回形数等 )

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

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

4. 数组元素的排序算法

1.数组元素的赋值：1.1使用二维数组打印一个 10 行杨辉三角。

package com.atguigu.exer;

import javax.sound.midi.Soundbank;

/*
 * 
 *	使用二维数组打印一个 10 行杨辉三角

yanghui[i][j]                  
i位元素                        i位元素是长度为i+1的数组

    0: 1                        0位元素是长度为1的数组            0
    1: 1  1                     1位元素是长度为2的数组            0 0
    2: 1  2   1                 2位元素是长度为3的数组            0 0 0
    3: 1  3   3   1                                                  ......
    4: 1  4   6   4   1          -----不赋值时形如右边三角-------->        ......
    5: 1  5  10  10   5     1                                                  ......
    6: 1  6  15  20   15    6   1  
    7: 1  7  21  35   35   21   7   1  
    8: 1  8  28  56   70   56  28   8   1  
    9: 1  9  36  84  126  126  84  36   9  1                     0 0 0 0 0 0 0 0 0 0
	【提示】
	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.给元素赋值
		/*	yanghui[0] = new int[1];//0位元素是长度为1的数组
			yanghui[1] = new int[2];//1位元素是长度为2的数组
			yanghui[2] = new int[3];//2位元素是长度为3的数组
			......
			......
			yanghui[i] = new int[i+1];//i位元素是长度为i+1的数组
		*/
		for(int i = 0;i < yanghui.length;i++) {
			yanghui[i] = new int[i+1];
			
			//2.1给首末元素赋值
			yanghui[i][0] = 1;
			yanghui[i][i] = 1;
			
			//给每行非首尾元素赋值
		//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]; 
			}
		//}
			
		}
		
		//遍历二维数组
		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();
		}
	}

}

1.数组元素的赋值1.2拓展：随机赋值，要求个元素都不一样

创建一个长度为 6 的 int 型数组，要求数组元素的值都在 1-30 之间，且是随机赋值。同时，要求

元素的值各不相同。

package com.atguigu.exer;
/*
 *	创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。
 *	同时，要求元素的值各不相同。
 * 
 * 
 * */
public class TuoZhanTest {
	public static void main(String[] args) {
		
		//1.声名并初始化数组
		int[] arr = new int[6];
		
		//2.给数组元素赋值
		for(int i=0;i<arr.length;i++) {
			
			boolean bo = false;
                //给元素赋值：随机数Math.random()
				arr[i] = (int)(Math.random()*30+1); 
			while(true) {
				//判断当前元素是否与以前元素相等
				for(int j = 0;j<i;j++) {
					if(arr[i]==arr[j]) {
					arr[i] = (int)(Math.random()*30+1); 
						bo = true;
						break;
					}else {
						bo=false;
						continue;
					}
				}
				if(bo==false) {
					break;
				}
			}




         //第二种方法：
       /* 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;
		}*/
        //第三种方法：
       /* 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;
			
				for (int j = 0; j < i; j++) {
					if (arr[i] == arr[j]) {
						i--;
						break;
					}
				}
			}*/		
		}
			
		
		
		//3.遍历数组
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]); 
		}
		
	}
}

1.数组元素的赋值：1.3回形针数：

回形数格式方阵的实现：

从键盘输入一个整数（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

package com.atguigu.exer;

import java.util.Scanner;

public class HuiXingZheng {
	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--;
				}
			}
		}
/*
方式二：
int n = 7;
		int[][] arr = new int[n][n];

		int count = 0; // 要显示的数据
		int maxX = n - 1; // x轴的最大下标
		int maxY = n - 1; // Y轴的最大下标
		int minX = 0; // x轴的最小下标
		int minY = 0; // Y轴的最小下标
		while (minX <= maxX) {
			for (int x = minX; x <= maxX; x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for (int y = minY; y <= maxY; y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for (int x = maxX; x >= minX; x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for (int y = maxY; y >= minY; y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				String space = (arr[i][j] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[i][j] + " ");
			}
			System.out.println();
		}

*/

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

2.算法考察：求数值型数组中元素的最大值、最小值、平均数、总和等

定义一个 int 型的一维数组，包含 10 个元素，分别赋一些随机整数，

然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。

要求：所有随机数都是两位数。

提示；

[0,1) * 90 -> [0,90) + 10 -> [10,100) -> [10,99]

(int)(Math.random() * 90 + 10)

package com.atguigu.java;
/*
 * 算法考察：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 
 *定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 *然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 *要求：所有随机数都是两位数。
 *
 *
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		//1.声名并初始化
		int[] arr = new int[10];
		
		int max = 0;//最大值
		int min;//最小值
		int sum = 0;//和
		double avg = 0.0;//平均值
		
		//2.给元素赋值
		for(int i = 0;i<arr.length;i++) {
			arr[i] = (int)(Math.random()*90+10);
			
			//①选出最大值
			if(max <= arr[i]) {
				max = arr[i];
			}
			
		}
		//3.遍历数组
		for(int i = 0;i <arr.length;i++) {
			System.out.print(arr[i]+",");
		}
		System.out.println();//换行
		
		
		min=max;
		for(int i = 0;i<arr.length;i++) {
			//②选出最小值
			if(min >= arr[i]) {
				min = arr[i];
			}
			//③求数组元素之和
			sum += arr[i];
		}
		//④求平均值
		avg= (double)sum/arr.length;
		
		//输出最大值：
		System.out.println("最大值为："+max);
		//输出最小值
		System.out.println("最小值为："+min);
		//输出数组元素的和
		System.out.println("数组元素和为："+sum);
		//输出平均值
		System.out.println("数组平均值为："+avg);
	}
}

3. 数组的复制、反转、查找(线性查找、二分法查找)：3.1使用简单数组（复制）

(1) 创建一个名为 ArrayTest 的类，在 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 是什么关系？

拓展： 修改题目，实现 array2 对 array1 数组的复制

赋值 array2 变量等于 array1：结果如下

修改题目，实现 array2 对 array1 数组的复制：结果如下

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。 
 * 
 * 思考：array1和array2是什么关系？
    array2仅存储了array2的地址值。在堆中共用一个存储结构，array2相当于array1的一个桌面快捷方式
 * 拓展：修改题目，实现array2对array1数组的复制
 */
public class ArrayExer3 {
public static void main(String[] args) {
	//声明array1和array2两个变量, 他们是int[]类型的数组。
	 int[] array1;
	 int[] array2;
	 
	 //array1初始化为8个素数：2,3,5,7,11,13,17,19。
	 array1 = new int[] {2,3,5,7,11,13,17,19};
	 
	 //显示array1的内容
	 System.out.print("array1为：");
	 for(int i = 0;i<array1.length;i++) {
		 System.out.print(array1[i]+"\t");
	 }
	 System.out.println();
	
     //array2 = array1;//赋值array2变量等于array1

	 //拓展：实现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.print("array1为：");
	 for(int i = 0;i<array1.length;i++) {
		 System.out.print(array1[i]+"\t");
	 }
	 System.out.println();
	 
	}
}

3.算法考察: 3.2数组的复制、反转、查找(线性查找、二分法查找)

package com.atguigu.java;
/*
 * 算法考察: 数组的复制、反转、查找(线性查找、二分法查找)
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
        System.out.println(Arrays.toString(arr));
		//数组的复制(区别于数组变量的赋值：arr1 = arr;)
		String[] arr1 = new String[arr.length];
		for(int i = 0;i<arr.length;i++) {
			arr1[i] = arr[i];
		}
		
		//数组的反转
		//方式一：
		/*for(int i = 0;i<arr.length/2;i++) {
			String temp = arr[i];
			arr[i] = arr[arr.length-1-i];
			arr[arr.length-1-i] = 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 =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.1.冒泡排序

package com.atguigu.java;

import java.util.Arrays;
import java.lang.System;
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;
				}
			}
		}
		
		//1.使用冒泡排序，实现如下的数组从小到大排序。
		//int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
		int[] arr1 = new int[] {34,5,22,-98,6,-76,0,-3};
		for(int i = 0;i<arr1.length-1;i++) {
			for(int j=0;j<arr1.length-1-i;j++) {
				if(arr1[j]>arr1[j+1]) {
				int temmp1 = arr1[j];
				arr1[j]=arr1[j+1];
				arr1[j+1] = temmp1;
				}
			}	
		}
		System.out.println(Arrays.toString(arr1));
	
		
		
		//遍历数组
		for(int i = 0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}
		System.out.println();//换行
	}

}

4.数组元素的排序算法:4.2快速排序

package com.atguigu.java;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 * @author shkstart
 * 2018-12-17
 */
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.java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法

package com.atguigu.java;

import java.util.Arrays;

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

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);//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, 2110);//返回值是正数则是找到了这个是数，返回值是负数则是没有找到
			if(index>=0) {
				System.out.println("这个数的位置是："+index);
			}else {
				System.out.println("没有找到！");
			}
			
			
	}

}