数组相关知识(包括各种常见的排序原理及其实现，冒泡排序、交换排序、快速排序)

jdk为我们提供了一个辅助功能的类java,util.Arrays，这个类专门用于帮助我们完成一些数组的相关的一些方法的判断，比如数组的比较(比较各种数据类型的两个数组里面存放的内容是否相等)、排序、查询...之类的，这个类里面提供的所有方法全都是static的。
例如：比较两个数组的内容是否相同：

		int[] c = new int[]{1,2,3};
		int[] d = new int[]{1,2,3};
		System.out.println(Arrays.equals(c,d));

System类是java.util包里面的一个类，其中有这样一个方法：

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

这个方法可以复制数组，将一个数组里面的内容复制到另一个数组里面。


【说明】：System.out.println(a instanceof Object);为真，说明数组a也是一个对象。

System.out.println(a instanceof int[][][]);为真，说明数组a是一个三维数组,类型是int[][][]。
System.out.println(a[0] instanceof int[][]);为真，说明数组a[0]是一个二维数组，类型是int[][]。
System.out.println(a[0][0] instanceof int[]);为真，说明数组a[0][0]是一个一维数组，类型是int[]。



下面一个小的知识点：数组是一个对象，

		int[][] arr = new int[2][3];
		if (arr instanceof int[][]) {
			System.out.print(123);
		}
		if (arr[0] instanceof int[]) {
			System.out.print(456);
		}

打印结果为123456，两个判断都为真。

时常熟悉下下面这些代码：

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

		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				System.out.print(a[i][j] + " ");
			}
			System.out.println();
		}

		char[] ch = { 'A', 'C' };
		swap(ch, ch[1]);
		for (int i = 0; i < ch.length; i++) {
			System.out.println(ch[i]);
		}

		System.out
				.println(compare(new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 }));

		System.out.println("------------------------------------");
		int[] c = new int[] { 1, 2, 3 };
		int[] d = new int[] { 1, 2, 3 };
		System.out.println(Arrays.equals(c, d));

		System.out.println("-------------------------------------");
		int[] aa = new int[] { 1, 2, 3, 4 };
		int[] bb = new int[4];
		System.arraycopy(aa, 0, bb, 0, 4);
		for (int i = 0; i < bb.length; i++) {
			System.out.println(bb[i]);
		}

下面讲解冒泡排序：
原理：比如想要升序排列，对数组里面的数字相邻的两两进行比较，如果前面的数大，他们两个就交换位置，否则不变，继续执行，循环完第一轮之后最大的数就到最后一个了，接下来开始第二轮，第二轮之后第二大的数据也到了倒数第二个位置了，第三轮之后第三大的数据也到了倒数第三大位置了.....，下面举一个例子：
对5,4,7,9,3这一组数据按照从大到小进行排序：
第一轮：45793;
       45793;
       45793;
       45739;
第二轮：......
       45379;
第三轮：......
       43579;
第四轮：......
       34579;


代码如下：

	/**
	 * 冒泡排序(对一个数组里的数据进行升序排列)
	 * 方法: sort <br>
	 * 描述: TODO <br>
	 * 作者: 
	 * 时间: 
	 * @param a
	 * @return
	 */
	public static int[] sort(int[] a) {
		// 数组里面有length个数就循环(length-1)轮，每轮完成之后从后向前依次得到一个最大数，循环到最后一个数就不用循环了，因为只剩一个数了，它肯定是排在第一位的最小的数，所以循环(length-1)轮
		for (int i = 0; i < (a.length - 1); i++) {
			// 这里循环(a.length - 1 - i)次,进行相邻的两数之间的比较，并且对不符合升序的组合互换位置，而前面已经从后向前依次得到了(i+1)个最大数，所以后面已经确定的数就不用再进行两两比较了。
			for (int j = 0; j < (a.length - 1 - i); j++) {
				if (a[j] > a[j + 1]) {
					int demp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = demp;
				} else {
					continue;
				}
			}
		}
		return a;
	}

另外：很多人针对冒泡排序提出一个更高效率的小的改进，原理是，如果第一趟比较完之后，发现没有交换数据的动作，说明这个数组本身就是有序的，就不需要做下面的比较了，直接跳出循环结束即可。代码里的修改，只需在if里面加一个boolean类型的标志位，然后根据此标志位判断第一趟执行完之后有没有交换数据的动作，如果没有就直接跳出循环结束排序即可，如果有就按正常情况执行下面多趟的比较、交换数据等操纵。

交换排序是一个大的类，冒泡排序和快速排序都属于交换排序。


还有其他算法，见iteye博客文章：“快速排序算法”，“二分查找法”