Java語言學習（四）：數組及經常使用操做

    衆所周知，座標系有一維、二維、三維，Java中數組也不例外，像一維數組、二維數組，下面就數組來講下相關知識。

    先經過簡單的案例來熟悉數組：

    （1）任務：實現二維數組的行列互換

    （2）準備工做：二維數組的初始化、定義

    （3）編程：

public class ArrayChange {
   public static void main(String[] args) {
       //建立二維數組並初始化
       int arr[][] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
       System.out.println("行列互換前：");
       //輸出互換前數組
       printArr(arr);
       //定義相同大小的二維數組
       int _arr[][] = new int[arr.length][arr.length];
       //互換行列數據
       for(int i=0;i<arr.length;i++){
          for(int j=0;j<arr[i].length;j++){
              _arr[i][j] = arr[j][i];
          }
       }
       System.out.println("行列互換前：");
       //輸出互換後數組
       printArr(_arr);
   }
   public static void printArr(int[][] arr){
       for(int i=0;i<arr.length;i++){
           for(int j=0;j<arr[i].length;j++){
               System.out.print(arr[i][j]+" ");
           }
           System.out.println();
       }
   }
}

    （4）運行：可在控制檯打印出互換行列先後的數組內容

    注意：互換行列數據的原理是把新數組與原數組的行列索引交換進行元素賦值；定義數組變量時，不能聲明其長度，只能在使用new關鍵字建立數組時指定，如int[] arr = new int[9]；還支持靜態數組初始化，如int[] arr={1,2,3}；遵照代碼重用原則，如上數組的輸出函數。

    下面經過幾種常見的排序算法來進一步熟悉數組的操做：

• 選擇排序算法

    （1）任務：選擇排序算法

    （2）準備工做：算法思想：每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排序好的數列的最後，直到所有待排序的元素排完。

    （3）編程：

import java.util.Random;

/*
 * 選擇排序算法
 */
public class SelectSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = new int[10];
		Random random = new Random();
		for(int i=0;i<arr.length;i++){
			//生成100之內的隨機數並賦值給數組
			arr[i] = random.nextInt(100);
		}
		System.out.println("排序前數組：");
		printArr(arr);
		int index;
		for(int i=1;i<arr.length;i++){
			index = 0;
			for(int j=1;j<=arr.length-i;j++){
				if(arr[j] > arr[index])
					index = j;
			}
			//交換
			int temp = arr[arr.length-i];
			arr[arr.length-i] = arr[index];
			arr[index] = temp;
		}
		System.out.println("排序後數組：");
		printArr(arr);
	}
	public static void printArr(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
}

    （4）運行：輸出排序先後的數組

•  冒泡排序算法

    （1）任務：冒泡排序算法  

    （2）準備工做：算法思想：對比相鄰的元素值，若知足條件就交換元素值，把較小的元素移到數組前面，把大的元素移到數組後面，像氣泡同樣從底部上升到頂部。

    （3）編程：

import java.util.Random;

/*
 * 冒泡排序算法
 */
public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = new int[10];
		Random random = new Random();
		for(int i=0;i<arr.length;i++){
			//生成100之內的隨機數並賦值給數組
			arr[i] = random.nextInt(100);
		}
		System.out.println("排序前數組：");
		printArr(arr);
		for(int i=1;i<arr.length;i++){
			for(int j=0;j<arr.length-i;j++){
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		System.out.println("排序後數組：");
		printArr(arr);
	}
	public static void printArr(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
}

    （4）運行：輸出排序先後的數組

•  快速排序算法

    （1）快速排序算法

    （2）準備工做：算法思想：經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據都比另外一部分的全部數據小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可遞歸進行。

    （3）編程：

import java.util.Random;

/*
 * 快速排序算法
 */
public class QuickSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = new int[10];
		Random random = new Random();
		for(int i=0;i<arr.length;i++){
			//生成100之內的隨機數並賦值給數組
			arr[i] = random.nextInt(100);
		}
		System.out.println("排序前數組：");
		printArr(arr);
		QuickSort(arr,0,arr.length-1);
		System.out.println("排序後數組：");
		printArr(arr);
	}
	public static void QuickSort(int arr[],int lowIndex,int highIndex){
		//記錄最小索引
		int low = lowIndex;
		//記錄最大索引
		int high = highIndex;
		//分界點元素
		int mid;
		if(highIndex > lowIndex){
			//肯定中間分界點元素值
			mid = arr[(lowIndex+highIndex)/2];
			while(low <= high){
				//肯定不大於分界點元素值的最小索引
				while((low <highIndex) && (arr[low] < mid)){
					++low;
				}
				//肯定大於分界點元素值的最大索引
				while((high > lowIndex) && (arr[high] > mid)){
					--high;
				}
				//若最大索引和最小索引沒有重疊，交換索引元素
				if(low <= high){
					swap(arr,low,high);
					++low;
					--high;
				}
			}
			//遞歸排序
			if(lowIndex < high){
				QuickSort(arr,lowIndex,high);
			}
			if(highIndex > low){
				QuickSort(arr,low,highIndex);
			}
		}	
	}
	//交換方法
	public static void swap(int arr[],int  i,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	public static void printArr(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
}

    （4）運行：輸出排序先後的數組

    以上是幾種常見的排序算法，各有優劣，下面說下Arrays類提供的sort()方法對數組的排序：

    （1）任務：Arrays.sort()排序方法

    （2）準備工做：Arrays類位於java.util包，它是數組的一個工具類，包含不少方法

    （3）編程：

import java.util.Arrays;
import java.util.Random;

/*
 * Arrays.sort()
 */
public class ArraysSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = new int[10];
		Random random = new Random();
		for(int i=0;i<arr.length;i++){
			//生成100之內的隨機數並賦值給數組
			arr[i] = random.nextInt(100);
		}
		System.out.println("排序前數組：");
		printArr(arr);
		Arrays.sort(arr);
		System.out.println("排序後數組：");
		printArr(arr);
	}
	public static void printArr(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
}

    （4）運行：輸出排序先後的數組

    注意：Arrays類提供了建立、操做、搜索、排序的方法，sort()方法有不少重載格式，能夠接受任何數據類型的數組並執行不一樣類型的排序，默認升序排序，上面使用了int參數類型的重載實現。

    最後，說下數組在函數可變參數中的使用：

    （1）任務：可變參數

    （2）準備工做：可變參數是java1.5以後的新特性，能夠表明零到多個相同數據類型的變量，是爲了解決因參數個數的變化而致使過多的方法重載問題

    （3）編程：

public class ParaChange {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		double sum = add(4,2.1,3.6,5.3);
		System.out.println("數組求和爲："+sum);
	}
	public static double add(int a,double...b){
		double sum = a;
		for(int i=0;i<b.length;i++){
			sum += b[i];
		}
		return sum;
	}
}

    （4）運行：輸出數組求和的值

    注意：可變參數只能用於形式參數（方法定義時），能夠把可變參數看成數組來處理；一個方法在最多隻能有一個可變參數，可變參數必須做爲最後一個參數；調用帶可變參數的方法時，數據類型必須與可變參數的類型對應。

    好了，上面經過幾個案例已經熟悉了數組的基本使用，這裏再也不詳述了。