Arrays类，基本

Arrays类

使用方法：导包，然后具体方法调用就可以

Arrays:看名字就专门操作数组的工具类 导包 java.util.Arrays;

注意**“；”**不可以不写，不写会编译错误

•   **方法有: Arrays.sort(int[] arr):双轴快速排序，千万级以上的数据**  **注意**：Arrays.sort(int[] arr，int fromeindex,int toindex)：从从fromindex到toindex索引的元素进行排序
  

•         **Arrays.parallelSort(int[] arr):并行排序，分治思想，里面用到双轴快速排序，亿级以上的数据**
  

•         **Arrays.toString(int[] arr):把数组当成一个字符串输出**
  

•         **Arrays.binarySearch(int[] arr,int num):二分查找排序**
  

•         **数组的深复制（深拷贝）Arrays.copyOf(源数组，源数组长度)****注意：Arrays.copyOfRange(源数组，源数开始索引，结束索引)，从开始索引到结束索引复制值
  

•         **比较两个数组的内容是否相等Arrays.equals(数组1，数组2)**（arr 和arr2是相同的数组吗（包括长度和元素内容））
  

•         **Arrays.quickSort(数组名, 起始索引, 终止索引)快速排序**
  

•         **Arrays.fill(type[]a,type val):把a数组的所有元素都赋值为val**
  

•         **Arrays.fill(type[]a,int fromeindex,int toindex,type val):把a数组从fromindex到toindex索引的数组元素进行赋值为val**
  

一、当成字符串输出 toString[int[]arr]

//定义了一个数组
		int[] arr = {3,5,9,13};
		
		//当成字符串输出
		System.out.println(Arrays.toString(arr));

二、 数组复制 Arrays.copyOf(源数组，源数组长度)

//数组复制 要复制的数组 :newLength返回数组的长度
 		int[] arr = {3,5,9,13};
		int[] arr2 = Arrays.copyOf(arr, arr.length);
		System.out.println("arr:" + arr);
		System.out.println("arr2:" + arr2);

三、 这两个数组的内容是否相等 Arrays.equals(数组1，数组2)

//这两个数组的内容是否相等
		int[] arr = {3,5,9,13};
		int[] arr2 = Arrays.copyOf(arr, arr.length);
		boolean equals = Arrays.equals(arr, arr2);
		System.out.println("arr 和arr2是相同的数组吗（包括长度和元素内容）？" + equals);

四、二分搜索法 binarySearch(int[] arr,int num)

//二分搜索法
		int[] arr = {3,5,9,13};...
		int result = Arrays.binarySearch(arr, 99);
		System.out.println("result:" + result);
//返回的是对应元素的索引

五、双轴快速排序 Arrays.sort(int[] arr)

//双轴快速排序 
		int[] arr = {3,5,9,13};
		Arrays.sort(arr);

六、快速排序 quickSort(数组名, 起始索引, 终止索引)

//快速排序
		int[] arr = {3,5,9,13};
		quickSort(arr, 0, arr.length - 1);

七、查看运行时间 System.currentTimeMillis() 单位毫秒ms

	//TODO 开始时间 
		long start = System.currentTimeMillis();
		//可以换成其它代码
		int[] arr = {3,5,9,13};
		quickSort(arr, 0, arr.length - 1);

	//TODO 结束时间 
		long end = System.currentTimeMillis();

具体代码1

public static void main(String[] args) {
		//定义了一个数组
		int[] arr = {3,5,9,13};
		
		//当成字符串输出
		System.out.println(Arrays.toString(arr));
		
		//数组复制 要复制的数组 :newLength返回数组的长度
		int[] arr2 = Arrays.copyOf(arr, arr.length);
		System.out.println("arr:" + arr);
		System.out.println("arr2:" + arr2);
		
		//这两个数组的内容是否相等
		boolean equals = Arrays.equals(arr, arr2);
		System.out.println("arr 和arr2是相同的数组吗（包括长度和元素内容）？" + equals);
		
		//二分搜索法
		int result = Arrays.binarySearch(arr, 99);
		System.out.println("result:" + result);
	}

具体代码2

public static void main(String[] args) {
		int num = 100000000;
		//定义数组
		int[] arr = new int[num];
		
		Random r = new Random();
		
		//循环
		for(int i = 0;i < num;i++) {
			arr[i] = r.nextInt(num);
		}
		
		//TODO 开始时间 
		long start = System.currentTimeMillis();
		
		//双层循环 外层循环搞定的是轮数 ，会经历多少次外面的排序 里层的两两比较的趟次
		// arr.length-1 最右边那个最大数不用参与进来再次比较
		/*
		 for(int i = 0;i < arr.length -1;i++) {
			//arr.length-1-i 两两比较 
			for(int j=0;j<arr.length-1-i;j++) {
				//相邻的两个数比较 
				int left = arr[j];// arr[j] j:0 arr[j]:2  
				int right = arr[j+1];// arr[j+1]: j:0  arr[1]
				//判断
				if(left > right) {
					//换位置
					
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		 */
		/* 选择排序
		 * for (int i = 0; i < arr.length; i++) {
		 
			// 假设一个数，它就是最小的
			int min_index = i;
			for (int j = i + 1; j < arr.length; j++) {
				// 找到最小的数
				if (arr[min_index] > arr[j]) {
					// j在这里是索引
					min_index = j;
				}
			}

			// temp是临时变量
			int temp = arr[i];

			// 把最小的值 赋值给arr[i]
			arr[i] = arr[min_index];
			// 把临时变量的值赋值给arr[min_index] 两个数就交换过来
			arr[min_index] = temp;
			
		}*/
		
		//快速排序
		//quickSort(arr, 0, arr.length - 1);
		
		//双轴快速排序 //3 
		Arrays.sort(arr);
		//Arrays.parallelSort(arr);
		
		//TODO 结束时间 
		long end = System.currentTimeMillis();
		//打印时间复杂度（耗费的时间 ）
		// 冒泡排序：125、169、175  选择排序：36、34、32  快速排序:2、2、2
		System.out.println("排序" + num+ "个元素的数组花了:" + (end - start));
	}
	
	private static void quickSort(int[] arr, int leftIndex, int rightIndex) {
		// 判断
		if (leftIndex > rightIndex) {
			return;
		}

		// 定左边和右边
		int i = leftIndex;
		int j = rightIndex;

		// 基准数
		int p = arr[i];
		// 循环 判断
		// 从左到右交替扫描
		while (i < j) {
			while (i < j && arr[j] >= p) {
				// 从右边往左扫描，找到一个基准小的元素
				j--;
			}

			// 找到这个元素并交换位置
			arr[i] = arr[j];

			while (i < j && arr[i] <= p) {
				// 从右边往左扫描，找到一个基准小的元素
				i++;
			}

			// 找到这个元素并交换位置
			arr[j] = arr[i];
		}

		// 基准归位
		arr[i] = p;
		// 对基准左边的元素进行递归（调用自己的方法 1）要有一个方向 2）要有一个结束的条件 ）排序
		quickSort(arr, leftIndex, i - 1);
		// 对基准右边的元素进行递归排序
		quickSort(arr, j + 1, rightIndex);
		
	}