Java基础--Arrays类多个常见方法

Java中Arrays的常用方法

Arrays类位于java.untils包中

import java.util.Arrays

主要包含了操作数组的各种方法，提供了二分搜索、排序、复制、比较、填充，输出数组内容、截取数组等静态方法

二分查找：

首先我们来查看一下源码：下面这段代码截取于源码

public static int binarySearch(long[] a, long key) {
        return binarySearch0(a, 0, a.length, key);//
    }
//这段代码只能查找不存在目标不存在重复的有序数组，例如下列数组查找4，返回的是7，第一次出现4的下标为6
//int [] nums={1,1,2,2,3,3,4,4,4,4,4,4,5,5,6};
private static int binarySearch0(long[] a, int fromIndex, int toIndex, long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;//无符号右移一位，相当于除以2，为什么不写成low+((high-low)>>>1),上面那种写法不怕溢出？
            long midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else//当找到符合的目标
                return mid; // key found，返回目标下标
        }
        return -(low + 1);  // key not found.
    }

在这里重写一下上面的函数，当存在多个目标数字，返回其左右端点

//寻找左端点
private static int binarySearchLeftBound(long[] a, int fromIndex, int toIndex, long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = low+(high-low)/2;
            long midVal = a[mid];
			if(midVal==key){
				//不断向左端点逼近
				high=mid-1;
			}
			else if(key<midVal){
                high=mid-1;
            }
            else if(key>midVal){
                low=mid+1;
            }
        }
        //检查是否越界和数组是否存在该数
        if(left>=nums.length || nums[left]!=key)
        	return -1;
        return low;
    }

//寻找右端点
private static int binarySearchLeftBound(long[] a, int fromIndex, int toIndex, long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = low+(high-low)/2;
            long midVal = a[mid];
			if(midval==key){
				//不断向左端点逼近
				low=mid+1;
			}
			else if(key<midVal){
                high=mid-1;
            }
            else if(key>midVal){
                low=mid+1;
            }
        }
        //检查数组是否越界和是否存在该数
        if(right<0 || nums[left]!=key)
        	return -1;
        return right;
    }

排序：默认按升序排列

大部分编译器关于底层排序几乎都是快速排序，在这里我们复习一波快速排序

1、操作数列中所有的数字，在所有数字中选择一个数字作为排序的基准(pivot)，pivot通常是随机选择的
2、选择好pivot后，在操作数列中选择最左边的数字标记为左标记，最右边的数字标记为右标记
3、将左边的标记向右移动
4、当左标记到达超过privot的数字时，停止移动
5然后将右边的标记向左移动
6、当右标记到达小于privot的数字，停止移动
7、当左右标记停止，更改标记的数字
8、左标记的作用是找到一个大于pivot的数字，右标记的作用是找到一个小于pivot的数字
9、通过交换数字，可以在数列的左边收集到小于pivot的数字集合，最右边收集大于pivot的数字集合
10、交换以后，继续移动左标记
11、然后将右标记向左移动
12、当右标记碰到左标记时也停止移动
13、当左右侧的标记都停止时，并且都在同一个位置，将这个数字和pivot交换
14、这就完成了第一次操作
15、随后递归这分成的两部分执行相同的操作
16、完成快速排序

//快速排序
public class QuickSort(){
	public int[] sort(int[] sourceArray){
		int[] arr=Arrays.copyOf(sourceArray,sourceArray.length);
		return quickSort(arr,0,arr.length-1);
	}
	private int[] quickSort(int[] arr,int left,int right){
		if(left<right){
			int partitionIndex=partition(arr,int left,int right);
			quickSort(arr,left,paritionIndex-1);
			quickSort(arr,partitionIndex+1,right);
		}
		return arr;
	}
	private int partition(int[] arr,int left,int right){
	//设定基准值
	int pivot=left;
	int index=pivot+1;
	for(int i=index;i<=right;++i){
		if(arr[i]<arr[pivot]){
			swap(arr,i,index);
			++index;
		}
	}
		swap(arr,pivot,index-1);
		return index-1;
	}
	private void swap(int[] arr,int i,int j){
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
}

//使用sort完成排序
public class TempTest {
    public static void main(String[] args) {
        int[] arr={1,23,5,4,6,8,9,10,45};
        System.out.println("排序前: ");
        System.out.println(Arrays.toString(arr));

        System.out.println("排序后: ");
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
		//指定范围排序，下方的输出没有输出这行的结果，了解即可
		Arrays.sort(arr,0,3);//给第0位（0开始）到第3位（不包括）排序
    }
}

//那么如何降序输出呢
//方式1
//使用Collections.reverseOrder()，我还没学到这个，百度意思就可以输出一个反向
Arrays.sort(arr,Collections.reverseOrder());

//方式2：
//将int行数组转成对应的包装类Integer数组，再自定义一个比较器即可
Integer[] arr1=new Integer[arr.length];
Comparator<Integer> cmp=new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
	return o2-o1;
	}
};
for (int i=0;i<arr.length;++i){
	arr1[i]=arr[i];
}
Arrays.sort(arr1,cmp);

复制

功能：拷贝生成一个新数组

public class TempTest {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] arrayCopy = Arrays.copyOf(array,8);  // 拷贝并生成一个新的数组对象，并设置长度为8
        System.out.println(Arrays.toString(arrayCopy));
		//范围拷贝
        int []arr1 = Arrays.copyOfRange(array,1,3);
        System.out.println(Arrays.toString(arr1));

    }
}

填充

功能：对数组中指定的索引范围进行填充，如果索引处有值，进行覆盖

public class TempTest {
    public static void main(String[] args) {
        int[] array = new int[5];
        Arrays.fill(array,0,3,9); // 给数组下标 0～2的元素填充9
        System.out.println(Arrays.toString(array));  // 输出[9, 9, 9, 0, 0]

        int [] array1={1,2,3,4,5};
        Arrays.fill(array1,0,3,9); // 给数组下标 0～2的元素填充9
        System.out.println(Arrays.toString(array1));  // 输出[9, 9, 9, 4, 5]
    }
}

比较

①Arrays.equals 比较一维数组
②Arrays.deepEquals 比较多维数组

public class TempTest {
    public static void main(String[] args) {
        int[] array1 = {1,2,3};
        int[] array2 = {1,2,3};
        int[] array3 = {1,2,4};
        System.out.println(Arrays.equals(array1,array2));  // 数组的比较，返回true
        System.out.println(Arrays.equals(array1,array3));  // 数组的比较，返回false
    }
}

public static void main(String[] args) {
        Integer[][] array1 = {{1,2,3}};
        Integer[][] array2 = {{1,2,3}};
        Integer[][] array3 = {{1,2,4}};
        System.out.println(Arrays.equals(array1,array2));  // 多维数组的比较，返回false
        System.out.println(Arrays.equals(array1,array3));  // 多维数组的比较，返回false
        System.out.println(Arrays.deepEquals(array1,array2));  // 多维数组深比较，判断是否是同一个对象,返回true
    }

输出数组内容

输出数组内容

Arrays.toString方法，比较简单

public static void main(String[] args) {
        int[] array = {3,2,1,4,5};
        System.out.println(array);  // 输出 [I@61bbe9ba
        System.out.println(Arrays.toString(array));  // 输出 [3, 2, 1, 4, 5]
    }

注：以上内容参考了一部分其他博客的内容，由于不小心点没了，没法提出引用，在此表示感谢。记录学习的每一天，加油！