概述

Arrays类是关于数组的方法类，提供了一些常用的关于数组的操作。都是静态方法，可以通过类名直接调用。

常用方法

Arrays类中常用操作数组的方法如下：

静态方法	说明
static String toString(int[] a)	打印八大基本数据类型和引用数据类型对象数组。
static <T> List<T> asList(T... a)	根据数组创建List集合。
static void fill(int[] a, int val)	将数组中所有元素填充为同一个值。
static void fill(char[] a, int fromIndex, int toIndex, char val)	将数组从指定索引fromIndex到结束索引toIndex之间的所有元素都赋为val值，注意索引从0开始，包括fromIndex，而不包括toIndex。
static void sort(int[] a)	对八大基本数据类型和引用数据类型进行排序。如果是数字则默认排序是从小到大；如果是字母则是先大写字母再小写字母。
static <T> void sort(T[] a, Comparator<? super T> c)	使用Comparator比较器来进行排序。String.CASE_INSENSITIVE_ORDER表示严格按照字母表排序，忽略大小写的影响，例如：["z","a","B"]——>["a","B","z"]；Collections.reverseOrder()表示反向排序，例如：["a","B","e"]——>["e","a","B"]。
static void sort(int[] a, int fromIndex, int toIndex)	对数组中指定起始索引fromIndex（包括）到结束索引toIndex（不包括）之间的所有元素进行排序。
static boolean equals(int[] a, int[] a2)	比较两个数组中所有元素是否相等，可以比较的数组包括八大基本数据类型数组和引用数据类型对象数组。
static int binarySearch(int[] a, int key)	在已经排序好的数组a中通过二分查找指定元素key在数组中的下标索引，如果找不到元素则返回负数。
static int binarySearch(int[] a, int fromIndex, int toIndex, int key)	在已经排序好的数组中通过二分查找从指定起始索引fromIndex到结束索引toIndex之间指定元素key的下标索引，注意包括fromIndex所在的元素而不包括toIndex所在的元素。
static IntStream stream(int[] array)	将数组转换成Stream流，数组类型可以是八大基本数据类型和引用数据类型对象。
static int hashCode(int a[])	返回数组的哈希值。
static int[] copyOf(int[] original, int newLength)	复制original数组中前newLength个元素到新数组中，返回新数组。
static int[] copyOfRange(int[] original, int from, int to)	复制original数组中从下标from到下标to之间的所有元素（包括from所表示的元素，而不包括to所表示的元素）。

注意，虽然上面方法中参数是int[]类型的，但数组类型可以是八大基本数据类型数组和Object对象数组，即又可以是引用数据类型对象数组，如Person[]、User[]等。

实例

 上面各方法的实例如下：

public class Demo {
    public static void main(String[] args) throws ParseException {
        // Arrays.toString(Object[] obj)，打印八大基本数据类型和引用数据类型对象数组
        String intArrayString = Arrays.toString(new int[]{1, 2, 3, 4, 5, 6});
        System.out.println(intArrayString);

        // Arrays.asList(T...a)，根据数组创建List集合
        List<String> list = Arrays.asList(new String[]{"a", "b", "c", "d", "e"});
        System.out.println(list);

        // fill(int[] a, int val)，将数组中所有元素填充为同一个值
        int[] ints = new int[5];
        Arrays.fill(ints, 99);// 将ints数组中所有元素都赋为99
        System.out.println(Arrays.toString(ints));

        // fill(Object[] a, int fromIndex, int toIndex, Object val)，将数组从指定索引fromIndex到结束索引toIndex之间的所有元素都赋为val值，注意索引从0开始，包括fromIndex，而不包括toIndex
        char[] chars = new char[6];
        Arrays.fill(chars, 2, 4, 'X');
        System.out.println(Arrays.toString(chars));

        // sort(int[] a)，对八大基本数据类型和引用数据类型进行排序。如果是数字则默认排序是从小到大；如果是字母则是先大写字母再小写字母
        int[] ints2 = new int[]{2, 9, 1, 6, 4, 0};
        Arrays.sort(ints2);
        System.out.println(Arrays.toString(ints2));
        String[] strings = new String[]{"z", "c", "D", "A"};
        Arrays.sort(strings);
        System.out.println(Arrays.toString(strings));

        // sort(T[] a, Comparator<? super T> c)，使用Comparator比较器来进行排序
        // String.CASE_INSENSITIVE_ORDER表示严格按照字母表排序，忽略大小写的影响。例如：["z","a","B"]——>["a","B","z"]
        String[] strings2 = new String[]{"z", "a", "B"};
        Arrays.sort(strings2, String.CASE_INSENSITIVE_ORDER);
        System.out.println(Arrays.toString(strings2));
        // Collections.reverseOrder()表示反向排序。例如：["a","B","e"]——>["e","a","B"]
        String[] strings3 = new String[]{"a", "B", "e"};
        Arrays.sort(strings3, Collections.reverseOrder());// ["a","B","e"]排序后是["B","a","e"]，反排序后是["e","a","B"]
        System.out.println(Arrays.toString(strings3));

        // sort(int[] a, int fromIndex, int toIndex)，对数组中指定起始索引fromIndex（包括）到结束索引toIndex（不包括）之间的所有元素进行排序
        int[] ints3 = new int[]{2, 9, 1, 6, 4, 0};
        Arrays.sort(ints3, 1, 4);// 数组中第1位（包括，索引从0开始）到第4位（不包括）之间的所有元素进行排序
        System.out.println(Arrays.toString(ints3));// [2, 1, 6, 9, 4, 0]

        // equals(int[] a, int[] a2)，比较两个数组中所有元素是否相等，可以比较的数组包括八大基本数据类型数组和引用数据类型对象数组
        boolean equals = Arrays.equals(new int[]{1, 2, 3}, new int[]{3, 2, 1});
        System.out.println(equals);

        // binarySearch(int[] a, int key)，在已经排序好的数组a中通过二分查找指定元素key在数组中的下标索引，如果找不到元素则返回负数
        int i = Arrays.binarySearch(new int[]{1, 2, 3, 4, 5}, 2);
        System.out.println(i);
        // binarySearch(int[] a, int fromIndex, int toIndex, int key)，在已经排序好的数组中通过二分查找从指定起始索引fromIndex到结束索引toIndex之间指定元素key的下标索引，注意包括fromIndex所在的元素而不包括toIndex所在的元素
        int i2 = Arrays.binarySearch(new int[]{1, 2, 3, 4, 5}, 2, 4, 1);
        System.out.println(i2);

        // Arrays.stream(int[] array)，将数组转换成Stream流，数组类型可以是八大基本数据类型和引用数据类型对象
        IntStream intStream = Arrays.stream(new int[]{1, 2, 3, 4});
        intStream.filter((val) -> val > 3);

        // hashCode(int a[])，返回数组的哈希值
        int hashCode = Arrays.hashCode(new int[]{1, 2, 3});
        System.out.println(hashCode);

        // copyOf(int[] original, int newLength)，复制original数组中前newLength个元素到新数组中，返回新数组
        int[] ints4 = Arrays.copyOf(new int[]{1, 2, 3, 4, 5, 6, 7}, 3);// 从数组中第0个元素开始复制
        System.out.println(Arrays.toString(ints4));

        // copyOfRange(int[] original, int from, int to)，复制original数组中从下标from到下标to之间的所有元素（包括from所表示的元素，而不包括to所表示的元素）
        int[] ints5 = Arrays.copyOfRange(new int[]{1, 2, 3, 4, 5, 6, 7}, 2, 5);
        System.out.println(Arrays.toString(ints5));// [3, 4, 5]
    }
}
/*打印结果：
    [1, 2, 3, 4, 5, 6]
    [a, b, c, d, e]
    [99, 99, 99, 99, 99]
    [ ,  , X, X,  ,  ]
    [0, 1, 2, 4, 6, 9]
    [A, D, c, z]
    [a, B, z]
    [e, a, B]
    [2, 1, 6, 9, 4, 0]
    false
    1
    -3
    30817
    [1, 2, 3]
    [3, 4, 5]
 */