Java基礎---> 數組

第一 一維數組

一、概述：

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}}

二、數組長度：

獲取數組長度方法：int[][] arr = {{1,5,7},{4,8},{3}}；arr.length得到的值爲3，說明二維數組中有三個一位數組arr[2].length獲取的長度爲1，說明arr中的第三個一維數組長度爲1；

三、數組中的常見操作：

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

2、獲取最值：

/*
	 * 一般獲取最值需要進行比較，每次比較都會有一個較大的值，用變量進行臨時存儲 數組中的每個元素都和這個變量進行比較，並記錄交大的
	 */
	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];
	}

3、排序

/*
	 * 選擇排序 先拿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;
				}
			}
		}
	}

4、查找

/*
	 * 一般查找方式
	 */
	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;
	}