介绍

Array是Java中一个常用的对数组进行操作的工具类。

常用方法

总览

public static String toString(数组) 把数组拼接成一个字符串
public static int binarySearch(数组，查找的元素) 二分查找法查找元素
public static int[] copyOf(原数组，新数组长度) 拷贝数组
public static int[] copyOfRanger(原数组，起始数组，结束索引) 拷贝数组（指定范围）
public static void fill(数组，元素) 填充数组
public static void sort(数组) 按照默认指定方式对数组进行排序
public static void sort(数组，排序规则) 按照指定的规则排序

代码演示

toString：将数组变成字符串

1 2	int[] arr = {1,2,3,4,5,6,7,8,9,10}; System.out.println(Arrays.toString(arr));//[1,2,3,4,5,6,7,8,9,10]

binarySearch:二分查找法查找元素
细节1：二分查找的前提：数组中的元素必须是有序的，数组中的元素必须是升序的
细节2：如果要查找的元素是存在的，那么返回的是真实的索引
但是：如果要查找的元素是不存在的，返回的是 -插入值 - 1//解释：为了避免查找0时发生的错误

1
2
3

System.out.println(Arrays.binarySearch(arr,10));//9  
System.out.println(Arrays.binarySearch(arr,2));//1  
System.out.println(Arrays.binarySearch(arr,20));//-11

copyOf:拷贝数组
参数一：老数组
参数二：新数组的长度
方法的底层会根据第二个参数来创建新的数组
如果新数组的长度是小于老数组的长度，会部分拷贝
如果新数组的长度是等于老数组的长度，会完全拷贝
如果新数组的长度是大于老数组的长度，会补上默认初始化

int newArr1[] = Arrays.copyOf(arr,2);//[1, 2]  
int newArr2[] = Arrays.copyOf(arr,10);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
int newArr3[] = Arrays.copyOf(arr,20);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]  
System.out.println(Arrays.toString(newArr1));  
System.out.println(Arrays.toString(newArr2));  
System.out.println(Arrays.toString(newArr3));

copyOfRange:拷贝数组（指定范围）
细节：包头不包尾，包左不包右

1 2	int newArr4[] = Arrays.copyOfRange(arr,0,9);//[1, 2, 3, 4, 5, 6, 7, 8, 9] System.out.println(Arrays.toString(newArr4));

fill:填充数组

1
2
3

int arr6[]= Arrays.copyOf(arr,arr.length);  
Arrays.fill(arr6,100);  
System.out.println(Arrays.toString(arr6));//[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]

sort：排序。默认情况下，给基本数据类型进行升序排序，底层使用的是快速排序

1
2
3

int arr7[] ={10,2,3,5,6,1,7,8,3,9,3};  
Arrays.sort(arr7);//[1, 2, 3, 3, 3, 5, 6, 7, 8, 9, 10]  
System.out.println(Arrays.toString(arr7));

排序扩展

public static void sort(数组,排序规则) 按照指定的规则顺序

参数一：要排序的数组
参数二：排序的规则
细节：
只能给引用数据类型的数组进行排序如果数组是基本数据类型的，需要变成其对于的包装类

Integer[] arr = {2,3,1,6,5,7,1,4,7,3};

第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则
但是这个实现类，我只要使用一次，所以就没有必要单独的写一个类，直接采取匿名内部类的方法就可以了

**底层原理：
利用插入排序 + 二分查找的方式进行排序的。
默认把0索引的数据当作是有序的序列。1索引到最后认为是无序的序列
遍历无需的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点
拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
如果方法的返回值是整数，拿着A继续跟后面的数据进行比较
如果方法的返回值是0，也拿着A跟后面的数据进行比较
直到能确定A的最终位置为止。

compare方法的形式参数：
参数一：o1：表示在无序序列中，遍历得到的每一个元素
参数二： o2：有序序列中的元素

返回值：负数：表示当前要插入的元素是最小的，放在前面正数：表示当前要插入的元素是最大的，放在后面 0：表示当前要插入的元素跟现在比是一样的也会放在后面

代码演示：

Integer[] arr = {2,3,1,6,5,7,1,4,7,3};
Arrays.sort(arr,new Comparator<Integer>(){  
    @Override  
    public int compare(Integer o1,Integer o2){  
        return o1 -o2;  
    }  
});  
System.out.println(Arrays.toString(arr));