java数组中涉及到的常见算法

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

使用二维数组打印一个 10 行杨辉三角。
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

【提示】

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] = 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();
		}
	}
}

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];
		
		//给arr一维数组赋值
		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random()*90+10);
		}
		
		//遍历
		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("一维数组arr的最大值为：" + maxValue);
		
		//求数组元素的最小值,和值
		System.out.println();
		int minValue = arr[0];
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
			if(minValue > arr[i]){
				minValue = arr[i];
			}
			sum += arr[i];
		}
		System.out.println("一维数组arr的最小值为：" + minValue+",和值为："+sum);
		
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("一维数组arr的平均值为：" + avgValue);
		
	    /*  
	    结果如下：
		54 95 65 61 96 98 54 34 87 60 
		一维数组arr的最大值为：98

		一维数组arr的最小值为：34,和值为：704
		一维数组arr的平均值为：70
		*/
	}
}

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

3.1 复制

题目一：

使用简单数组
(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数组的复制

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] + " ");
		}
	
		//frray2变量等于array1
		System.out.println();
		array2 = array1;
		for(int i = 0;i < array2.length;i += 2){
			array2[i] = i;
		}
        
		//显示array2的内容。
		for(int i = 0;i < array2.length;i++){
			System.out.print(array2[i] + " ");
		}
        
		System.out.println();
		//显示array1的内容。
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + " ");
		}
		/*结果：
		0 3 2 7 4 13 6 19 
		0 3 2 7 4 13 6 19*/
	}
}

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

public class ArrayTest3 {
	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] + " ");
		}
		
		//数组的复制:
		array2 = new int[array1.length];
		for(int i = 0;i < array2.length;i++){
			array2[i] = array1[i];
		}
		
		//修改array2中的偶索引元素
		for(int i = 0;i < array2.length;i++){
			if(i % 2 == 0){
				array2[i] = i;
			}
		}
		System.out.println();
		
		//打印出array2
		for(int i = 0;i < array2.length;i++){
			System.out.print(array2[i] + " ");
		}
		System.out.println();
		//打印出array1
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + " ");
		}
        /*		
		结果：
		0 3 2 7 4 13 6 19 
		2 3 5 7 11 13 17 19
        */
	}
}

结论：数组的复制，区别于数组变量的赋值：arr1 = arr ,这两个数组变量实际上是一个变量，都指向同一个内存地址，随便一个数组改变数组元素，另一个数组也会跟着改变，其值一样。而拓展部分的复制操作不会那样，一个数组元素改变和另一个数组没关系

3.2 反转

	String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		//方法一：
		for(int i = 0;i < arr.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] + " "); //AA GG BB MM DD JJ
		}

3.3查找

线性查找：

String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
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 = 35;
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(dest1 > arr2[middle]){ //目标元素在middle右边，则首索引=中间索引+1
			head = middle + 1;
	}else { //arr2[middle] < dest1
			end = middle - 1;
	}
}
	if(isFlag1){
			System.out.println("没有找到该元素！");
	}

4.数组元素的排序算法

冒泡排序

介绍：
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元
素，如果他们的顺序错误就把他们交换过来。

排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步
   做完后，最后的元素会是最大的数(按从小到大的顺序排序)。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要
   比较为止。

冒泡排序的实现

public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		// n个数要排n-1轮
		for(int i = 0;i < arr.length - 1;i++){
			// n个数比较一轮要比较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] + " ");
			// -98 -21 0 32 32 33 43 64 76 99 
		}	
	}
}

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

举例：

import 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);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1)); //[1, 2, 3, 4]
		
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1)); //[10, 10, 10, 10]
		
		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4]
		
		//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("未找到！");
		}	
	}
}

数组使用时的常见异常

数组脚标越界异常(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引用没有指向实体，却在操作实体中的元素时。