在JAVA小知识17中我们详细的讲述了关于数组的定义以及使用方法，今天来讲一个关于操作数组的工具类。java.util.Arrays是一个专门用于操作数组的工具类，它封装了非常多的方法方便我们操作数组。

一、常用方法

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

二、详细解释 

 1、toString：把数组拼接成一个字符串

public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d", "e"};
    String s1 = Arrays.toString(arr);
    System.out.println(s1);//[a, b, c, d, e]
}

很好理解，就是将数组元素转化为了外面有方括号的字符串元素 ，我们可以看一下toString的源码：

2、 copyOf(原数组,新数组长度)：拷贝数组

public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d", "e"};
    String[] s1 = Arrays.copyOf(arr, 2);
    String[] s2 = Arrays.copyOf(arr, 6);
    System.out.println(Arrays.toString(s1));// [a, b]
    System.out.println(Arrays.toString(s2));// [a, b, c, d, e, null]
}

如果新数组的长度是小于老数组的长度，会部分拷贝

如果新数组的长度是等于老数组的长度，会完全拷贝

如果新数组的长度是大于老数组的长度，会补上默认初始值（每个类型初始值不一样）

3、copyOfRange(原数组,起始索引,结束索引)：拷贝指定长度数组

public static void main(String[] args) {
    String[] arr = {"a", "b", "c", "d", "e"};
    String[] s1 = Arrays.copyOfRange(arr,0,2);
    String[] s2 = Arrays.copyOfRange(arr, 0,6);
    System.out.println(Arrays.toString(s1));// [a, b]
    System.out.println(Arrays.toString(s2));// [a, b, c, d, e, null]
}

其索引下标从0开始，遵循左闭右开原则，也就是包括第一个索引元素但是不包括最后一个索引元素（（0,2）就是索引0与索引1，不包括索引2 ），同样超出数组元素的话会填充初始值。

4、binarySearch(数组，查找的元素)：二分查找法查找元素

public static void main(String[] args) {
    int[] arr ={1,2,4,5,6,7};
    int i = Arrays.binarySearch(arr, 0);
    int i2 = Arrays.binarySearch(arr, 4);
    System.out.println(i);//-1
    System.out.println(i2);//2
}

二分查找的前提:数组中的元素必须是有序，数组中的元素必须是升序的
如果要查找的元素是存在的，那么返回的是真实的索引

但是，如果要查找的元素是不存在的，返回的是  负的插入点-,1 如图：

例如查找元素5，数组中没有5，由于是升序排序，数组会将指针移动到最后，此时插入点就是5，如果要查找3，在元素2之后就应该是元素3，此时元素2之后是元素4，那么插入点就应该是元素4的索引3，所以此时插入点是3。

至于为什么要减一，如果查找元素是0，那么第一个元素就应该是0，如果没有插入点也是0此时如果不减一，那就是-0，-0也是0，就会造成误解，所以要-1。

5、fill(数组,元素：填充数组

public static void main(String[] args) {
    int[] arr ={1,2,4,5,6,7};
    Arrays.fill(arr,0);
    System.out.println(Arrays.toString(arr));//[0, 0, 0, 0, 0, 0]
}

填充全部元素，会将原数组覆盖。

6、sort(数组)：排序

public static void main(String[] args) {
    int[] arr ={2,1,5,7,3,10,5,4};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 5, 7, 10]
}

给基本数据类型进行升序排列。底层使用的是快速排序。

7、 sort(数组，排序规则)：按照指定规则排序

参数一:要排序的数组
参数二:排序的规则
细节:
        只能给引用数据类型的数组进行排序

        如果数组是基本数据类型的，需要变成其对于的包装类

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

底层原理:

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

10. 返回值:
    负数:表示当前要插入的元素是小的，放在前面

    正数:表示当前要插入的元素是大的，放在后面

    0:表示当前要插入的元素跟现在的元素比是一样的们也会放在后面

Arrays.sort(arr, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return 0;
    }
});

所以 如果想实现降序，只需要o2-o1即可。

public static void main(String[] args) {
    Integer[] arr ={2,1,5,7,3,10,5,4};
    // 正常写法
    Arrays.sort(arr, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    });
    // lambda表达式
    Arrays.sort(arr, (Integer o1, Integer o2)-> o2-o1);
    System.out.println(Arrays.toString(arr));//[10, 7, 5, 5, 4, 3, 2, 1]
}

8、 Arrays.asList(数组)：数组转List

尽管数组非常强大，但它自身可以操作的工具方法很少，如果能转成 List 的话，就简便多了。

public static void main(String[] args) {
    int[] arr ={2,1,5,7,3,10,5,4};
    List<int[]> ints = Arrays.asList(arr);
}

不过需要注意的是，Arrays.asList() 返回的是 java.util.Arrays.ArrayList，它的长度是固定的，无法进行元素的删除或者添加。如果使用add/remove等会抛出异常

此时可以多进行转换一步，但是注意需要数组类型为包装类。

public static void main(String[] args) {
    Integer[] arr ={2,1,5,7,3,10,5,4};
    List<Integer> arrlist = new ArrayList<Integer>(Arrays.asList(arr));
    arrlist.stream().forEach(e-> System.out.println(e));
}

9、setAll()：填充数组 

operand 意味着数组的索引，长度为十的话就是从0开始到9结束返回每个加一就是 填充数组索引+1。

public static void main(String[] args) {
    int[] arr = new int[10];
    Arrays.setAll(arr, new IntUnaryOperator() {
        @Override
        //operand 意味着数组的索引，长度为十的话就是从0开始到9结束
        // 返回每个加一就是 填充数组索引+1
        public int applyAsInt(int operand) {
            return operand+1;
        }
    });
    System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}

 下面来看：

public static void main(String[] args) {
    int[] arr ={1,2,3,4,5,6,7};
    Arrays.setAll(arr,e->e*2);
    System.out.println(Arrays.toString(arr));//[0, 2, 4, 6, 8, 10, 12]
}

可以看到啊，不会以原来数组的元素作为基准，只会以索引来填充。