Arrays 类

---

常用方法

方法	描述
Arrays.toString ( )	返回数组的字符串形式
Arrays.sort (arr，0，n，比较器)	在 0 - n -1 的位置上排序（自然排序和定制排序）
Arrays.asList ( )	将一维数组，转换成 List 集合
Arrays.fill (数组，填充值)	数组元素的填充
Arrays.copyOf (原数组，拷贝长度)	数组元素的复制
Arrays.binarySearch ( )	通过二分搜索法进行查找（前提：数组是有序的）
Arrays.equals (数组一。数组二 )	比较两个数组内容是否完全一致

toString（）

方便查看数组内容，避免了通过遍历来输出内容的繁琐

代码示例

import java.util.Arrays;
public class main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(arr));
    }
}

// 输出结果
[1, 2, 3, 4, 5, 6]

sort（）

自然排序

底层实现：快速排序

import java.util.Arrays;
public class main {
    public static void main(String[] args) {
        int[] arr = {6,5,9,8,32,1,4};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

// 输出结果
[1, 4, 5, 6, 8, 9, 32]

定制排序

引入接口：Comprator；实现接口方法：compare

⚠️ 注意：Arrays . sort（）方法中，利用 Comprator 接口实现自定义排序，应该传入对象数组

对象数组：数组的类型是包装类（Integer，Double...），而非基本数据类型

（1）Comprator 接口实现方法：compare （），返回一个整数

返回负数：o1 小于 o2（升序）

返回 0：o1 等于 o2

返回正数：o1 大于 o2（降序）

（2）返回值写法

整数型：在值非常大时，o1 - o2 可能会内存溢出，推荐使用 Integer.compare（）方法

public int compare(T o1, T o2){
    // return o1 - o2;
    return Integer.compare(o1,o2);
}

字符串型：调用 compareTo（）方法

public int compare(T o1, T o2){
    // return o1 - o2;
    return ((String)o1).compareTo((String)o2);
}

（3）Integer.compare（）方法底层源码

public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

（4）String 的 compareTo（）方法底层源码

public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

（1）如果长度相同，并且每个个字符也相同，就返回 0

（2）如果长度相同或者不相同，但是在比较时，可以区分大小

（3）如果前面的部分都相同，就返回长度之差（ str1 . len - str2 . len ）

代码示例：使用 Comparator 接口实现降序排序

public class Sort {
    public static void main(String[] args) {
        Integer[] numbers = {1, 4, 3, 8, 6, 5};

        // 使用 Comparator 接口实现降序排序
        Arrays.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);  // 实现降序排序
            }
        });

        System.out.println("降序排序结果: " + Arrays.toString(numbers));
    }
}

binarySearch（）

基本介绍

二分查找，返回查找元素下标索引

（1）使用前提：数组是有序的

（2）使用方法：Arrays.binarySearch(数组，查找元素)

（3）注意点

若查找元素存在：返回下标索引

若查找元素不存在：返回 -（low + 1），low 是应该插入的位置

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println(Arrays.binarySearch(arr, 2));

        System.out.println(Arrays.binarySearch(arr, 10));
    }
}

// 输出结果
1
-4

代码分析

查找的元素 10 不存在，应该插入的位置为 3（下标索引），返回 - (low + 1)，即- (3 + 1)，所以返回-4

底层源码

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                    int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        int 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.
}

copyOf（）

基本介绍

（1）作用：数组的拷贝

（2）使用方法：Arrays.copyOf(原数组，拷贝长度)

（3）注意点

（1）如果拷贝的长度大于原数组，会在新数组的后面增加 null

（2）如果拷贝长度小于 0，，会抛出 NegativeArraySizeException 异常

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] new_arr = Arrays.copyOf(arr,arr.length);
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("new_arr：" + Arrays.toString(new_arr));
    }
}

// 输出结果
arr: [1, 2, 3]
new_arr：[1, 2, 3]

fill（）

（1）使用方法：Arrays.fill(目标数组，填充值)

（2）作用：把原数组中的所有数替换成填充数

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        Arrays.fill(arr,1);
        System.out.println("after_fill：" + Arrays.toString(arr));
    }
}

// 输出结果
after_fill：[1, 1, 1]

equals（）

基本介绍

（1）使用方法：Arrays.equals(数组一，数组二)

（2）作用：比较两个数组的内容是否一致

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] arr1 = {4,5,6};
        System.out.println("arr.equals(arr1)？ " + Arrays.equals(arr,arr1));
    }
}

// 输出结果
arr.equals(arr1)？ false

asList（）

基本介绍

（1）作用：将一维数组转成 List 集合

（2）编译类型：List（接口）

（3） 运行类型：java.util.Arrays#ArrayList，是 Arrays 类的静态内部类

private static class ArrayList<E> extends AbstractList<E>implements RandomAccess, java.io.Serializable

代码示例

import java.util.Arrays;
import java.util.List;

public class main {
    public static void main(String[] args) {
        List aslist = Arrays.asList(1,2,3);
        System.out.println("aslist：" + aslist);
        System.out.println("getclass()：" + aslist.getClass());
    }
}

// 运行结果
aslist：[1, 2, 3]
getclass()：class java.util.Arrays$ArrayList