java学习---数组与排序

复制数组：把一个数组的值，复制到另一个数组中

System.arraycopy(src,srcPos,dest,destPos,length)
src:原数组
srcPos:从原数组复制数据的起始位置
dest:目标数组
destPos:复制到目标数组的起始位置
length:复制的长度

实例：

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		int[] b=new int[3];
		System.arraycopy(a, 0, b, 0, 3);
		for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
	}
结果：
18 62 68

与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。

实例：

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		int[] b= Arrays.copyOfRange(a, 0, 3);
		for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
结果为：
18 62 68 

转换为字符串：

如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印
但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		String content = Arrays.toString(a);
		System.out.println(content);
	}
结果为：
[18, 62, 68, 82, 65, 9]

选择法排序：

选择法排序的思路： 
把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来 
比较完后，第一位就是最小的 
然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来 
比较完后，第二位就是第二小的 
以此类推

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		//选择法排序
		//第一步：把第一位和其他所有位进行比较
		//如果发现其他位置的数据比第一位小，就进行比较
		for (int j = 0; j < a.length-1; j++) {
			for (int i = j+1; i < a.length; i++) {
				if(a[i]<a[j]){
					int temp = a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
		}
		//打印内容
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println(" ");
	}
结果为：
9 
18 
62 
65 
68 
82 

冒泡法排序：

冒泡法排序的思路： 
第一步：从第一位开始，把相邻两位进行比较 
如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的 
第二步： 再来一次，只不过不用比较最后一位 
以此类推

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		//选择法排序
		//第一步：把第一位和其他所有位进行比较
		//如果发现其他位置的数据比第一位小，就进行比较
		for (int j = 0; j < a.length; j++) {
			for (int i = 0; i < a.length-j-1; i++) {
				if(a[i] > a[i+1]){
					int temp = a[i];
					a[i]=a[i+1];
					a[i+1]=temp;
				}
			}
		}
		//打印内容
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println(" ");
	}
结果为：
9 
18 
62 
65 
68 
82 

排序方法：sort()

Arrays.sort()使用的是经过调优的快速排序法
Arrays.sort()主要原理：

针对基本数据类型，Array.sort()采用DualPivotQuickSort算法排序；
	DualPivotQuickSort基本流程：
	元素个数：不超过插入排序阈值(默认47)，选用插入排序；
	元素个数：插入排序阈值-快排阈值（默认286），选用DualPivotQuickSort
	元素个数：超过快排阈值，选用TimSort归并排序；
	DualPivotQuickSort性能
	DualPivotQuickSort在经典快排基础上改进，时间复杂度稳定为O(n logn)
针对Object类型和泛型：TimSort
	TimSort基本流程
	用户通过系统参数LegacyMergeSort.userRequested选定排序方式：
	LegacyMergeSort.userRequested为TRUE，进行经典二路归并；
	LegacyMergeSort.userRequested为FALSE，进行TimSort归并排序；
	TimSort性能
	TimSort算法平均时间复杂度为O(n logn)，最优情况下为O(n)好于经典归并排序O(n logn)，空间复杂度与经典归并排序一样均为O(n)；
	因此在JDK1.8中，Java对对象和泛型使用TimSort的原因是：
	TimSort性能稳定，而快速排序不稳定；
	TimSort最优情况下时间复杂度为O(n)好于经典归并排序O(n logn)

实例：

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		System.out.println("排序前：");
		System.out.println(Arrays.toString(a));
		Arrays.sort(a);
		System.out.println("排序之后：");
		System.out.println(Arrays.toString(a));
		
	}
结果为：
排序前：
[18, 62, 68, 82, 65, 9]
排序之后：
[9, 18, 62, 65, 68, 82]

搜索：

查询元素出现的位置
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的

实例：

public static void main(String[] args) {
		int[] a = new int[]{18,62,68,82,65,9};
		Arrays.sort(a);
		System.out.println("排序之后："+Arrays.toString(a));
		System.out.println("数字62出现的位置："+Arrays.binarySearch(a, 62));
	}
结果为：
排序之后：[9, 18, 62, 65, 68, 82]
数字62出现的位置：2

填充：使用同一个值，填充整个数组

public static void main(String[] args) {
		int[] a = new int[10];
		Arrays.fill(a, 5);
		System.out.println("排序之后："+Arrays.toString(a));
	}
结果为：
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]