第一 一維陣列

一、概述：

1、定義：簡單來說，就是一個存放同種型別的容器。陣列中能放任意型別，但是同一個陣列中只能存放同一種資料。

2、使用陣列的好處：陣列可將其中的每一個值自動新增對應的編號，每個元素都有其對應的角標，方便與運算元組。

二、格式：

1、格式一：

資料元素型別[]  變數名  =  new 元素型別[引數個數];

如：int[] a = new int[10];(int a[] = new int[10]這樣寫也可以)這樣的定義方式是在堆記憶體中給分配了一個大小為10的陣列，但是沒有顯示的初始化，而在堆記憶體中的資料都是有初始化值的，所以陣列中每個元素的值為0(元素的預設值根據元素的型別而定)。

2、格式二：

元素型別[] 變數名 = new 元素型別[]{元素1,元素2,......}; 

如：int[] a = new int[]{0,1,2,3,4,5,6,7,8,9};

3、陣列之間的賦值：int[] a = new int[10];int[] b = a;因為a指向的是new int[10]在堆記憶體中的引用，而a又賦值給了b，所以b也就指向了new int[10]在堆記憶體中的引用，此時a與b都操作的同一個陣列。

第二 二維陣列

一、格式：

1、格式一：int[][] arr = new int[2][3];

定義了一個名為arr的陣列，陣列中有2個一維陣列，每個一維陣列中含有3

可以對其賦值：arr[0][0] = 3;即對第一個一位陣列的第一個元素賦值。

2、格式二：int[][] arr = new int[3][];

此二維陣列中含有3個一維陣列，每個一維陣列的預設初始化值都為null，每個一維陣列中的元素值都為0；可對每個陣列進行定義，如：

       arr[0] = new int[3];

       arr[1] = new int[2];

       arr[2] = new int[1];

3、格式三：

顯式初始化二維陣列：int[][] arr = {{1,5,7},{4,8},{3}}

二、陣列長度：

三、陣列中的常見操作：

1、列印陣列，即為獲取陣列中的值

private static void print(int[] arr) {

		for (int x = 0; x < arr.length; x++) {
			if (x != arr.length - 1)
				System.out.print(arr[x] + ",");
			else
				System.out.println(arr[x]);
		}
	}

/*
	 * 一般獲取最值需要進行比較，每次比較都會有一個較大的值，用變數進行臨時儲存 陣列中的每個元素都和這個變數進行比較，並記錄交大的
	 */
	private static int compare(int[] arr) {
		int max = arr[0];
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > max) {
				max = arr[x];
			}
		}
		return max;
	}

/*
	 * 用陣列角標的方式
	 */
	private static int compare_2(int[] arr) {
		int max = 0;
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > arr[max]) {
				max = x;
			}
		}
		return arr[max];
	}

/*
	 * 選擇排序 先拿arr[0]與後面的每個元素相比，再拿arr[1]與後面的每個元素相比.... 最值首先出現在第一位
	 */
	private static void selectSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = x + 1; y < arr.length; y++) {
				if (arr[x] > arr[y]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}

/*
	 * 氣泡排序 相鄰兩個元素相比，arr[0]與arr[1]相比，arr[1]與arr[2]相比........ 最值首先出現在最末尾
	 */
	private static void bubbleSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - x - 1; y++) {// -x：比較元素減少，-1：避免角標越界
				if (arr[y] > arr[y + 1]) {
					int temp = arr[y];
					arr[y] = arr[y + 1];
					arr[y + 1] = temp;
				}
			}
		}
	}

/*
	 * 一般查詢方式
	 */
	private static int getIndex(int[] arr, int key) {
		for (int x = 0; x < arr.length; x++) {
			if (arr[x] == key) {
				return x;
			}
		}
		return -1;
	}

/*
	 * 折半查詢 可以提高效率，但是陣列必須有序
	 */
	private static int halfSearch(int[] arr, int key) {
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		mid = (min + max) / 2;

		while (arr[mid] != key) {
			if (key > arr[mid]) {
				min = mid + 1;
			} else if (key < arr[mid]) {
				max = mid - 1;
			}
			if (min > max) {
				return -1;
			}
			mid = (min + max) / 2;
		}
		return mid;
	}

/*
	 * 折半查詢的第二種方式 可以提高效率，但是陣列必須有序
	 */
	private static int halfSearch_2(int[] arr, int key) {
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		// mid = (min + max)/2;

		while (min <= max) {
			mid = (min + max) / 2;

			if (key > arr[mid]) {
				min = mid + 1;
			} else if (key < arr[mid]) {
				max = mid - 1;
			} else
				return mid;
		}
		return -1;
	}