阿里云【名师课堂】Java面向对象开发16 ~ 19：数组案例

16：数组数据统计

范例：假设给定一个数组，统计出该数组的最大值、最小值、平均值、总和。

• 肯定要通过循环完成。
• 通过定义方法实现，更整齐、简洁明了。
• 因为主方法中代码应该越简单越好，最好只有调用。

我的思路：建立四个方法，分别求出最大值、最小值、平均值、总和。

• 缺点：需要四次循环，速度较慢，且不够简洁；

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,2,3,4,66,5,6,7,8,9} ;
		System.out.println("最大值：" + statMax(data)) ;
		System.out.println("最小值：" + statMin(data)) ;
		System.out.println("平均值：" + statAvg(data)) ;
		System.out.println("总和：" + statSum(data)) ;
    }

	public static int statMax(int data[]) {  // 求最大
		int max = data [0];
		for(int x = 0 ; x < data.length ; x++){
			if(data[x] > max){
				max = data[x] ;
			}
		}
		return max ;
	}
	
	public static int statMin(int data[]) {  // 求最小
		int min = data [0];
		for(int x = 0 ; x < data.length ; x++){
			if(data[x] < min){
				min = data[x] ;
			}
		}
		return min ;
	}
	
	public static int statSum(int data[]) {  // 求和
		int sum = data[0] ;
		for(int x = 1 ; x < data.length ; x++){
			sum += data[x] ;
		}
		return sum ;
	}
	
	public static double statAvg(int data[]) {  // 求均值
		int sum = statSum(data) ;
		double avg = sum / data.length ;
		return avg ;
	}
	
} 

• 老师的思路：一个方法直接实现

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,2,3,4,66,5,6,7,8,9} ;
		double result [] = statArr(data) ;  // 调用方法
		System.out.println("最大值：" + (int)result[0]) ;
		System.out.println("最小值：" + (int)result[1]) ;
		System.out.println("平均值：" + result[2]) ;
		System.out.println("总和：" + (int)result[3]) ;
    }

	// 此时需要返回的数据一共4个，但是一个方法只能返回一种数据类型，因此我们使用数组返回
	// temp [0]最大值，temp [1]最小值，temp [2]平均值，temp [3]总和
	public static double[] statArr(int data[]) {
		double temp [] = new double [4] ;
		temp [0] = data [0];
		temp [1] = data [0];
		temp [2] = data [0];
		temp [3] = data [0];
		for(int x = 1 ; x < data.length ; x++){  // x = 0时的值已经给了temp
			if(data[x] > temp[0]){  // 求最大
				temp[0] = data[x] ;
			}
			if(data[x] < temp[1]){  // 求最小
				temp[1] = data[x] ;
			}
			temp[3] += data[x] ;  // 求和
			temp[2] = temp[3] / data.length ;	// 求均值
		}		
		return temp ;
	}
}

17：数组排序

经过n*(n-1)次循环，时间复杂度太高。

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,2,3,4,66,5,6,7,8,9} ;
		sort(data) ;
		printArray(data) ;
    }

	// 此时不需要返回值,因为修改的是原始的数组内容
	public static void sort(int arr[]) {
		for(int x = 0 ; x < arr.length -1 ; x++){  // 外循环控制第几个数进行排序
			for(int y = 0 ; y < arr.length - 1 - x; y++){  // 内循环进行比较、排序
				if(arr[y] > arr[y + 1]){
					int temp = arr[y] ;
					arr[y] = arr[y + 1] ;
					arr[y + 1] = temp ;
				}
			}
		}
	}
	
	// 定义一个专门进行数组输出的方法
	public static void printArray(int temp[]) {
		for(int x = 0 ; x < temp.length ; x++){
			System.out.print(temp[x] + "、") ;
		}
	}
}

18：数组转置

转置简单来说就是首尾交换，两种方法：

• 方式一：新建一个等长数组，把原数组反向赋值给新数组；
• 方式二：在原本数组上完成（推荐）。

范例：方式一

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,2,3,4,66,5,6,7,8,9} ;
		data = reverse(data) ;
		printArray(data) ;
    }

	// 返回值是数组
	public static int [] reverse(int arr[]) {
		int temp [] = new int [arr.length] ;
		int flag = 0 ;
		for(int x = arr.length - 1 ; x >= 0 ; x--){  // 外循环控制第几个数进行排序
			temp[flag++] = arr[x] ;
		}
		return temp;
	}
	
	// 定义一个专门进行数组输出的方法
	public static void printArray(int temp[]) {
		for(int x = 0 ; x < temp.length ; x++){
			System.out.print(temp[x] + "、") ;
		}
	}
}

通过内存分析图可以看出，此方法最大的问题在于开辟了两块完全相同的内存空间，造成空间的浪费。

范例：方式二

• 一共操作元素数/2次.（9/2=4）

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,2,3,4,66,5,6,7,8,9} ;
		reverse(data) ;
		printArray(data) ;
    }

	// 不需要返回值，因为对原数组进行操作
	public static void reverse(int arr[]) {
		int axis = arr.length / 2 ;  // 转换次数
		int head = 0 ;  // 头部索引
		int tail = arr.length -1 ;  // 尾部索引
		for(int x = 0 ; x < axis ; x++){  // 外循环控制第几个数进行排序
			int temp = arr[head + x] ;
			arr[head + x] = arr[tail - x] ;
			arr[tail - x] = temp; 
		}
	}
	
	// 定义一个专门进行数组输出的方法
	public static void printArray(int temp[]) {
		for(int x = 0 ; x < temp.length ; x++){
			System.out.print(temp[x] + "、") ;
		}
	}
}

二维数组的转置

前提条件：行列要相等。

保证某条对角线作为轴不动，即行索引=列索引时不动。

public class ArrayDemo {
	public static void main(String args[]) {
		int data [][] = new int [][] { {1,2,3} , {4,5,6} , {7,8,9} } ;
		reverse(data) ;
		printArray(data) ;
    }

	// 不需要返回值，因为对原数组进行操作
	public static void reverse(int arr[][]) {
		for(int x = 0 ; x < arr.length ; x++){  // 控制第几行
			for(int y = x ; y < arr[x].length ; y++){  // 控制第几列
				if(x != y){
					int temp = arr[x][y];
					arr[x][y] = arr[y][x] ;
					arr[y][x] = temp;
				}
			}
		}
	}
	
	// 定义一个二维数组输出的方法
	public static void printArray(int temp[][]) {
		for(int x = 0 ; x < temp.length ; x++){
			for(int y = 0 ; y < temp[x].length ; y++){
				System.out.print(temp[x][y] + "、") ;
			}
			System.out.println() ;
		}
	}
}

19：二分查找法

如果想要在数组中查找某个元素的位置，可以通过：

数组遍历

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,2,3,4,5,6,7,8,9} ;
		int flag = 7 ;
		System.out.println(index(data,flag)) ;
    }
	
	public static int index(int arr[],int key) {
		for(int x = 0 ; x < arr.length ; x++){
			if(arr[x] == key){
				return x;
			}
		}
		return -1;
	}
}

时间复杂度是n，所有的元素都要经历一次遍历。
更快、更好的方法：

二分查找法（折半查找）

使用二分查找法的前提是先给数组排序。

范例：实现二分查找（采用方法递归操作完成）

public class ArrayDemo {
	public static void main(String args[]) {
		int data [] = new int [] {1,5,6,2,3,4,7,9,8} ;
		java.util.Arrays.sort(data) ;
		System.out.println(binSearch(data,0,data.length - 1,4)) ;
    }
	
	public static int binSearch(int arr[],int from,int to,int key) {
		if(from < to){
			int axis = (from + to) / 2 ;  // 确定中间点
			if(arr[axis] == key) {
				return axis ;
			} else if(key < arr[axis]){
				return binSearch(arr,from,axis,key) ;
			} else if(key > arr[axis]){
				return binSearch(arr,axis,to,key) ;
			}
		}
		return -1;
	}
}