Java菜鸟学习之路之基础编程---数组中涉及到得常见得算法、Arrays工具类得使用、数组中常见得异常详解(七)

1.数组中涉及到得常见得算法

---

1. 数组元素的赋值(杨辉三角、回形数等)
2. 求数值型数组中元素的最大值、最小值、平均数、总和等
3. 数组的复制、反转、查找(线性查找、二分查找等)
4. 数组元素的排序算法(面试题重点)
    

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

---

杨辉三角得测试用例:

//使用二维数组打印一个10行的杨辉三角
public class YangHui_Test {
	public static void main(String[] args) {
		//1.声明并初始化数组
		int[][] arr = new int[10][];	
		//因为行数为10，每列的元素个数不确定，所以需要使用第二维不确定的动态初始化
		
		//2.根据杨辉三角的构型，找出行与列的关系，并为第二维开辟列空间(给数组元素赋值)
		for(int i = 0;i < arr.length;i++) {
			arr[i] = new int[i + 1];
		}
		
		//3.使用嵌套for循环，遍历二维数组中的每一个元素
		for(int i = 0;i < arr.length;i++) {	//外层数组元素个数
			for(int j = 0;j < arr[i].length;j++) {	//内层数组元素个数
				//3.1 第一行和第二行和每行的第一列和最后一列都是元素1
				if(i == 0 || i == 1 || j == 0 || j == arr[i].length - 1) {
					arr[i][j] = 1;
					System.out.print(arr[i][j] + "\t");
				//3.2 其余位置元素值为上一行元素的前一位和上一行元素的前一位的前一位相加而成
				}else {
					arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
					System.out.print(arr[i][j] + "\t");
				}
			}
			//每一个内层循环结束，打印一层杨辉三角，追加换行
			 System.out.println();
		}
	}
}

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

---

测试用例：

/*定义一个int型的一维数组，包含10个元素，分别赋一些随机数，然后求出这些元素的最大值，最小值，和值
 * 平均值。
 * 要求:所有随机数都是两位数 (10,100)
 * */
public class ManyArray2_Test {
	public static void main(String[] args) {
		int[] arr = new int[10];
		int maxNumber;
		int minNumber;
		for(int i = 0;i < arr.length;i++) {
			arr[i] = (int)(Math.random() * 90 + 10);
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		maxNumber = arr[0];
		minNumber = arr[0];
		int sum = 0;
		for(int i = 0;i < arr.length;i++) {
			if(arr[i] > maxNumber) {
				maxNumber = arr[i];
			}
			if(arr[i] < minNumber) {
				minNumber = arr[i];
			}
			sum += arr[i];
		}
		System.out.println("随机数最大值为: " + maxNumber);
		System.out.println("随机数最小值为: " + minNumber);
		System.out.println("随机数和为: " + sum);
		System.out.println("随机数平均值为: " + sum / arr.length);
	}
}

 

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

---

测试用例:

/*算法的考察:(1).数组的复制，
			 (2).反转
			 (3).查找(线性查找，二分查找) 
 * */
public class ArrayTest1_Test {
	public static void main(String[] args) {
		//(1).数组的复制(在堆内存中开辟空间创建一个新的数组)
		//1.声明两数组变量
		int[] arr1,arr2;
		
		//2.array1初始化为8个素数：2,3,5,7,11,13,17,19。
		arr1 = new int[]{2,3,5,7,11,13,17,19,20};
		
		//3.用new关键字为arr2在堆内存中开辟空间，创建大小和arr1相等的数组对象
		arr2 = new int[arr1.length];
		
		//4.通过对数组元素进行遍历，每次都将arr1的对应位置元素值给到对应位置上的arr2(真正的复制)
		for(int i = 0;i < arr1.length;i++) {
			arr2 [i] = arr1[i];
			System.out.print(arr2[i] + "\t");	
			//输出arr2
		}
		System.out.println();
		
		//(2).数组的反转
		//方式1
		//1.对数组进行遍历并且进行反转(反转一半就完成操作)，如果长度为arr1.length那么就是反转两遍，就等于它本身
		for(int i = 0;i < arr1.length / 2;i++) {
			int temp = arr1[i];
			arr1[i] = arr1[arr1.length - 1 - i];
			arr1[arr1.length - 1 - i] = temp;
		}
		//2.对反转之后数组进行遍历输出,查看交换效果
		for(int i = 0;i < arr1.length;i++) {
			System.out.print(arr1[i] + "\t");
		}
		System.out.println();
		
		//方式2
		//1.定义两变量i,j，一个从头开始遍历，一个从尾开始遍历，每交换一次，同时进行自增和自建操作
		for(int i = 0,j = arr1.length - 1;i < j;i++,j--) {
			int temp = arr1[i];
			arr1[i] = arr1[j];
			arr1[j] = temp;
		}
		
		//2.对反转之后数组进行遍历输出,查看交换效果
		for(int i = 0;i < arr1.length;i++) {
			System.out.print(arr1[i] + "\t");
		}
		System.out.println();
		
		//(3).查找(搜索)
		//3.1线性查找: 
		int aimNumber = 13;	//目标查找元素
		boolean isFlag = true;	//表征符号
		for(int i = 0;i <  arr1.length;i++) {
			if(arr1[i] == aimNumber) {	//寻找目标元素是否存在
				System.out.println(aimNumber + " 存在,位置为" + i);
				isFlag = false;	//表征符号改变
				break;
			}
		}
		if(isFlag) {	//整个循环内都没有找到指定元素
			System.out.println(aimNumber + " 不存在 ");
		}
		
		
		//3.2二分法查找(熟悉)
		//前提:所要查找的数组必须有序。
		int[] arr = new int[] {-58,-46,-27,-15,0,5,18,26,51,86};
		int aimNumber1 = 26;
		int head = 0;
		int tail = arr.length - 1;
		boolean isFlag1 = true;
		int mid;
		while(head <= tail) {
			mid = (head + tail) / 2;
			if(arr[mid] == aimNumber1) {
				System.out.println(aimNumber1 + "存在");
				isFlag1 = false;
				break;
			}else if(aimNumber1 < arr[mid]) {
				tail  = mid - 1;
			}else {
				head = mid + 1;
			}
		}
		if(isFlag1) {
			System.out.println(aimNumber1 + "不存在");
		}
	}
}

 

1.4数组元素的排序算法

---

分类:内部排序和外部排序

        内部排序：整个排序的过程不需要借助外部存储器(如磁盘等)，所有排序操作都在内存中完成。

        外部排序： 参与排序的数据非常多，数据量非常大，计算机无法把真个排序过程放在内存中完成，必须借助于外部存储器(如磁盘)。外部排序最常见的就是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序算法:

• 选择排序：直接选择排序、堆排序(思想)
• 交换排序：冒泡排序、快速排序(会手写)
• 插入排序：直接插入排序、折半插入排序、Shell排序
• 归并排序(思想)
• 桶式排序
• 基数排序

冒泡排序的实现:

/*数组的冒泡排序的实现:
 * */
public class BubbleSort_Test {
	public static void main(String[] args) {
		int[] arr = new int[] {8,6,4,5,7,1,3,2,9};
		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 + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
		}
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + "\t");
		}
	}
} 

2.Arrays工具类得使用

---

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

常用方法:

static boolean	equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
static String	toString(int[] a) 返回指定数组的内容的字符串表示形式。
static void	fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
static void	sort(int[] a) 按照数字顺序排列指定的数组。
static int	binarySearch(int[] a, int key) 使用二叉搜索算法搜索指定的int数组的指定值。

数组工具类Arrays的测试用例:

import java.util.Arrays;

/*java.util.Arrays：操作数组的工具类，里面定义了很多操作数组的方法
 * */
public class Arrays_Test {
	public static void main(String[] args) {
		//1.`equals(int[] a,  int[] a2)`  如果两个指定的int数组彼此 *相等* ，则返回 `true` 。 
		int[] arr = new int[] {3,2,1,8,9,6};
		int[] arr1 = new int[] {3,2,1,8,9,6};
		boolean equals = Arrays.equals(arr,arr1);	//两数组相同索引处的元素一一对比
		System.out.println(equals);	//true
		
		//2.`toString(int[] a)`  返回指定数组的内容的字符串表示形式。 
		System.out.println(Arrays.toString(arr));	//[3, 2, 1, 8, 9, 6]
		
		//3.`fill(int[] a,  int val)`  将指定的int值分配给指定的int数组的每个元素。 
		/*
		 * Arrays.fill(arr, 10); System.out.println(Arrays.toString(arr)); //[10, 10,
		 * 10, 10, 10, 10]
		 */	
		
		//4.`sort(int[] a)`  按照数字顺序排列指定的数组。
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));	//[1, 2, 3, 6, 8, 9]
		
		//5.`binarySearch(int[] a,  int key)`  使用二叉搜索算法搜索指定的int数组的指定值。 
		//二分查找的前提:有序
		int[] arr2 = new int[] {1,16,28,36,48,59,66};
		int binarySearch = Arrays.binarySearch(arr2, 59);
		System.out.println(binarySearch);	//返回查找到元素的索引，返回负数，则代表未找到指定元素
	}
}

 

3.数组中常见得异常

---

3.1 数组角标越界:ArraryIndexOutOfBoundsException

int[] arr = new int[]{1,2,3,4};
for(int i = 0;i <= arr.length;i++){
	System.out.print(arr[i]);	//输出1,2,3,4
    //数组长度为4索引从0开始只有0,1,2,3，当循环执行到角标为4的时候，数组中无此索引，报出数组角标越界的异常
}

3.2 空指针异常：NullPointerException

//情况一:
int[] arr = new int[4];
int[] arr1;
arr1 = null;	//arr1数组默认引用指向为空
arr = arr1;		//将空引用给到arr，那么arr也指向为空
System.out.println(arr[0]); 	//arr数组变量引用已变成空，指向了寂寞

//情况二:
int[][] arr2 = new int[4][];
System.out.println(arr[0]);	//null,外层数组元素存放的是内层一维数组，数组为引用数据类型，未指定，默认为null
System.out.println(arr2[2][0]);	//二维数组的外层数组存放的都是内层数组的首地址值，那么当未给内部数组开辟空间的时候，那么想调用内层数组元素，那么肯定就指向了寂寞，出现空指针异常

注意:一旦出现异常，未处理时，就终止执行。

 

好的呢！今天得共享就分享到这里了!这期得知识还都是挺基础得，可以好好理解一下数组得内存模型，以后再看见数组就能理性得分析数组了，详情请先上一篇博客数组得使用和内存模型详解！祝愿大家前程似锦！归来仍是骚年！

 

 

“路漫漫其修远兮,吾将上下而求索”