Arrays类

1、常用方法

Arrays 里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。

1. toString 返回数组的字符串形式 Arrays.toString(arr)【案例1】
   

2. sort 排序(自然排序和定制排序) Integer arr[]={1, -1, 7, 0, 89};【案例2】

3. binarySearch通过二分搜索法进行查找，要求必须排好序【案例3】
   int index = Arrays.binarySearch(arr,3);

4. copyOf 数组元素的复制【案例4】
   Integer[] newArr = Arrays.copyOf(arr, arr.length);

5. fill 数组元素的填充【案例5】
   Integer[] num = new Integer[]{9, 3, 2};
   Arrays.fill(num, 99);

6. equals 比较两个数组元素内容是否完全一致【案例6】
   boolean equals = Arrays.equals(arr, arr2);

7. asList 将一组值，转换成list【案例7】
   List asList = Arrays.asList(2, 3, 4, 5, 6, 1);
   System.out.println(“asList=” + asList);

案例

【案例1】

源码：public static String toString(Object[] a)

Integer[] integers = {1, 20, 90};
//遍历数组
for(int i = 0; i < integers.length; i++) {
    System.out.println(integers[i]);
}
//直接使用Arrays.toString方法，显示数组
System.out.println(Arrays.toString(integers));//

【案例2】排序

源码：public static void sort(Object[] a)

1、排序方法一：可以直接使用之前学过的冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
2、排序方法二：使用Arrays提供的方法sort()，因为数组是引用类型，所以通过sort 排序后，会 直接影响 到实参 arr

Integer arr[] = {1, -1, 7, 0, 89};
Arrays.sort(arr);
System.out.println("===排序后===");
for(int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + "\t");
}

3. 排序方法三：
【定制排序】 sort 是重载的，也可以通过传入一个接口 Comparator 实现定制排序。
调用定制排序 时，传入两个参数 (1) 排序的数组 arr (2) 实现了Comparator接口的匿名内部类 , 要求实现 compare方法
定制排序的作用是：默认的 sort 方法是按照从小到大的顺序，如果我们想按照从大到小怎么办？——使用下面的代码：

//定制排序
Integer arr[] = {1, -1, 7, 0, 89};
Arrays.sort(arr, new Comparator() { //匿名内部类
    @Override
    public int compare(Object o1, Object o2) {
        Integer i1 = (Integer) o1;
        Integer i2 = (Integer) o2;
        return i2 - i1;
    }
});
System.out.println("===排序后===");
System.out.println(Arrays.toString(arr));

【分析】
这里体现了接口编程的方式 , 看看源码，就明白【下断点分析】
知识点是：接口Comparator的匿名内部类(重写了compare方法)，作为参数，传入sort方法中。
sort方法最底层的函数，用Comparator c来接收这个匿名内部类。c.compare调用重写的方法。自制体现在：我们可以通过compare的不同重写方式，规定sort是由大到小排序，还是由小到大。
让接口中的compare方法决定排序由大到小排序，还是由小到大。

【源码分析】
(1) Arrays.sort(arr, new Comparator())
(2) 最终到 TimSort类的 private static void binarySort(T[] a, int lo, int hi, int start,Comparator<? super T> c)()
(3) 注意这里的 Comparator 是接口。其中定义的方法 int compare(T o1, T o2); 根据源码中对于这个方法的注释：实现 “比较其两个参数的顺序” 的要求。implements实现 Comparator 这个接口的 类，必须实现接口中声明的所有函数。
(4) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare() 执行我们传入的匿名内部类的 compare ()。这里虽然上下文的代码没有详细分析，但是通过 if 条件可以看出 分别是对 right 和 left进行赋值。

// binarySort
while (left < right) {
     int mid = (left + right) >>> 1;
     if (c.compare(pivot, a[mid]) < 0)
         right = mid;
     else
         left = mid + 1;
 }

在 binarySort 方法底层，会通过匿名内部类的compare方法来决定排序的顺序

new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
       Integer i1 = (Integer) o1;
        Integer i2 = (Integer) o2;
        return i2 - i1;
   }
}

(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
会影响整个排序结果，这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用。
将来的底层框架和源码的使用方式，会非常常见。

没太看懂，点击链接跳转P482看韩老师讲解

【案例3】

1. 使用 binarySearch 二叉查找
2. 要求该数组是有序的. 如果该数组是无序（从小到大或者从大到小）的，不能使用binarySearch
3. 如果数组中不存在该元素，就返回 return -(low + 1); // key not found.
   -(low + 1)中 low的意思是它应该在的位置

Integer[] arr = {1, 2, 90, 123, 567};
int index = Arrays.binarySearch(arr, 567);
System.out.println("index=" + index);

【案例4】

1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException
4. 该方法的底层使用的是 System.arraycopy()

Integer[] arr = {1, 2, 90, 123, 567};
Integer[] newArr = Arrays.copyOf(arr, arr.length-3);
System.out.println("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));

如果这里超过了arr的长度，那么会用数组元素内容是 null。

【案例5】

使用 99 去填充 num数组，可以理解成是替换原理的元素

Integer[] num = new Integer[]{9,3,2};
//1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num数组填充后==");
System.out.println(Arrays.toString(num));

【案例6】

equals 比较两个数组元素内容是否完全一致

1. 如果arr 和 arr2 数组的元素一样，则方法true;
2. 如果不是完全一样，就返回 false

Integer[] arr = {1, 2, 90, 123, 567};
Integer[] arr2 = {1, 2, 90, 123};
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);

【案例7】

asList 将一组值，转换成list

1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
2. 返回的
   asList 编译类型 List(接口)
   asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的静态内部类
   private static class ArrayList extends AbstractList
   implements RandomAccess, java.io.Serializable

List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList=" + asList);
System.out.println("asList的运行类型" + asList.getClass());