java.util包中的Arrays类是Java Collection Framework的一部分。此类提供了静态方法来动态创建和访问Java数组。它仅由静态方法和Object类的方法组成。此类的方法可由类名称本身使用。
类层次结构：

java.lang.Object
 ↳ java.util.Arrays

类声明：

public class Arrays
    extends Object

使用数组的语法：

Arrays.;

对Java-Arrays类的需求：
很多时候使用循环对数组执行某些任务，例如：

• 用特定值填充数组。
• 对数组进行排序。
• 在数组中搜索。
• 还有很多。

Arrays类提供了几种静态方法，这些方法可直接用于执行这些任务，而无需使用循环。
Java Array中的方法：
java.util包的Arrays类包含几个静态方法，可用于在数组中填充，排序，搜索等。这些是：

1. static List asList(T… a): 此方法返回由指定数组支持的固定大小的列表。

   // Java展示使用
   // Arrays.asList()
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 得到Array
           int intArr[] = { 10, 20, 15, 22, 35 };
           // 转化成数组
           System.out.println("int数组转成list: "
                              + Arrays.asList(intArr));
       }
   }

   输出：

   int数组转成list: [[I@232204a1]

2. static int binarySearch(elementToBeSearched)：这些方法借助二进制搜索binarySearch算法在数组中搜索指定的元素。

   // Java展示使用
   // Arrays.binarySearch()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取Array
           int intArr[] = { 10, 20, 15, 22, 35 };
           Arrays.sort(intArr);
           int intKey = 22;
           System.out.println(intKey
                              + " 被找到，index = "
                              + Arrays
                                    .binarySearch(intArr, intKey));
       }
   }

   输出：

   22 被找到，index = 3

3. static int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator c): ：此方法使用二进制搜索算法在指定数组的范围内搜索指定对象。

   // Java展示使用
   // Arrays.binarySearch()方法·
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取Array
           int intArr[] = { 10, 20, 15, 22, 35 };
           Arrays.sort(intArr);
           int intKey = 22;
           System.out.println(
               intKey
               + " 被找到，index = "
               + Arrays
                     .binarySearch(intArr, 1, 3, intKey));
       }
   }

   输出：

   22 被找到，index = -4

4. compare(array 1，array 2)：此方法按字典顺序比较作为参数传递的两个数组。

   // Java展示
   // Arrays.compare()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取Array
           int intArr[] = { 10, 20, 15, 22, 35 };
           // 获取第二个Array
           int intArr1[] = { 10, 15, 22 };
           // 比较两个arrays
           System.out.println("整型数组比较: "
                              + Arrays.compare(intArr, intArr1));
       }
   }

   输出：

   整型数组比较: 1

5. compareUnsigned(array 1，array 2)：此方法按字典顺序比较两个数组，将元素数字转化为无符号。

   // Java展示
   // Arrays.compareUnsigned()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取Arrays
           int intArr[] = { 10, 20, 15, 22, 35 };
           // 获取第二个Arrays
           int intArr1[] = { 10, 15, 22 };
           // 比较两个数组
           System.out.println("比较两个数组: "
                              + Arrays.compareUnsigned(intArr, intArr1));
       }
   }

   输出：

   比较两个数组: 1

6. copyOf(originalArray，newLength)：此方法复制指定的数组，并使用默认值(必要时将其截断或填充)，以便副本具有指定的长度。

   // Java展示
   // Arrays.copyOf()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取数组
           int intArr[] = { 10, 20, 15, 22, 35 };
           // 打印元素
           System.out.println("整数数组: "
                              + Arrays.toString(intArr));
           System.out.println("\n使用copyOf的新数组:\n");
           System.out.println("整数数组: "
                              + Arrays.toString(
                                    Arrays.copyOf(intArr, 10)));
       }
   }

   输出：

   整数数组: [10, 20, 15, 22, 35]
   使用copyOf的新数组:
   整数数组: [10, 20, 15, 22, 35, 0, 0, 0, 0, 0]

7. copyOfRange(originalArray，fromIndex，endIndex)：此方法将指定数组的指定范围复制到新的Arrays中。

   // Java展示使用
   // Arrays.copyOfRange()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取数组
           int intArr[] = { 10, 20, 15, 22, 35 };
           // 打印元素
           System.out.println("整型数组: "
                              + Arrays.toString(intArr));
           System.out.println("\n新数组被copyOfRange创建:\n");
           // To copy the array into an array of new length
           System.out.println("整型数组: "
                              + Arrays.toString(
                                    Arrays.copyOfRange(intArr, 1, 3)));
       }
   }

   输出：

   整型数组: [10, 20, 15, 22, 35]
   新数组被copyOfRange创建:
   整型数组: [20, 15]

8. static boolean deepEquals(Object[] a1, Object[] a2):：如果两个指定的数组彼此深度相等，则此方法返回true。

   // Java展示使用
   // Arrays.deepEquals()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取数组
           int intArr[][] = { { 10, 20, 15, 22, 35 } };
           // 获取第二个数组
           int intArr1[][] = { { 10, 15, 22 } };
           // 比较两数组
           System.out.println("两个数组比较: "
                              + Arrays.deepEquals(intArr, intArr1));
       }
   }

   输出：

   两个数组比较: false

9. static int deepHashCode(Object [] a)：此方法基于指定数组的“深层内容”返回哈希码。

   // Java展示使用
   // Arrays.deepHashCode()方法
   import java.util.Arrays;
   public class Main {
       public static void main(String[] args)
       {
           // 获取数组
           int intArr[][] = { { 10, 20, 15, 22, 35 } };
           // 返回深层的哈希码
           System.out.println("整型数组: "
                              + Arrays.deepHashCode(intArr));
       }
   }

   输出：

   整型数组: 38475344

10. static String deepToString(Object[] a)：此方法返回指定Array的“深层内容”的字符串表示形式。

    // Java展示使用
    // Arrays.deepToString()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[][] = { { 10, 20, 15, 22, 35 } };
            // 返回指定Array的“深层内容"的字符串表示形式
            System.out.println("整型数组: "
                               + Arrays.deepToString(intArr));
        }
    }

    输出：

    整型数组: [[10, 20, 15, 22, 35]]

11. equals(array1，array2)：此方法检查两个数组是否相等。

    // Java展示使用
    // Arrays.equals()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 获取第二个数组
            int intArr1[] = { 10, 15, 22 };
            // 比较两个数组
            System.out.println("比较两个数组: "
                               + Arrays.equals(intArr, intArr1));
        }
    }

    输出：

    比较两个数组: false

12. fill(originalArray，fillValue)：此方法将此fillValue分配给此Arrays的每个索引。

    // Java展示使用
    // Arrays.fill()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组s
            int intArr[] = { 10, 20, 15, 22, 35 };
            int intKey = 22;
            Arrays.fill(intArr, intKey);
            // 填充数组
            System.out.println("填充后的数组: "
                               + Arrays.toString(intArr));
        }
    }

    输出：

    填充后的数组: [22, 22, 22, 22, 22]

13. hashCode(originalArray)：此方法返回此数组实例的整数hashCode。

    // Java展示使用
    // Arrays.hashCode()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 返回此数组实例的整数hashCode。
            System.out.println("整型数组: "
                               + Arrays.hashCode(intArr));
        }
    }

    输出：

    整型数组: 38475313

14. mismatch(array1，array2)：此方法查找并返回两个指定数组之间第一个不匹配元素的索引。

    // Java展示使用
    // Arrays.mismatch()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 获取第二个数组
            int intArr1[] = { 10, 15, 22 };
            // 比较两个数组
            System.out.println("第一个不匹配的index: "
                               + Arrays.mismatch(intArr, intArr1));
        }
    }

    输出：

    第一个不匹配的index: 1

15. parallelPrefix(originalArray，fromIndex，endIndex，functionalOperator)：此方法使用指定的函数运算符对数组的给定范围执行parallelPrefix。
16. parallelPrefix(originalArray，operator)：此方法对具有指定功能运算符的完整数组执行parallelPrefix。
17. parallelSetAll(originalArray，functionalGenerator)：此方法使用提供的生成器函数并行设置此数组的所有元素。
18. parallelSort(originalArray)：此方法使用并行排序对指定的数组进行排序。

    // Java展示使用
    // Arrays.parallelSort()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 使用parallelSort对数组排序
            Arrays.parallelSort(intArr);
            System.out.println("整型数组: "
                               + Arrays.toString(intArr));
        }
    }

    输出：

    整型数组: [10, 15, 20, 22, 35]

19. setAll(originalArray，functionalGenerator)：此方法使用提供的生成器函数设置指定数组的所有元素。
20. sort(originalArray)：此方法以升序对整个数组进行排序。

    // Java展示使用
    // Arrays.sort()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 生序排序
            Arrays.sort(intArr);
            System.out.println("整型数组: "
                               + Arrays.toString(intArr));
        }
    }

    输出：

    整型数组: [10, 15, 20, 22, 35]

21. sort(originalArray，fromIndex，endIndex)：此方法将指定范围的数组按升序排序。

    // Java展示使用
    // Arrays.sort()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 排序数组
            Arrays.sort(intArr, 1, 3);
            System.out.println("整型数组: "
                               + Arrays.toString(intArr));
        }
    }

    输出：

    整型数组: [10, 15, 20, 22, 35]

22. static void sort(T[] a, int fromIndex, int toIndex, Comparator< super T> c)：此方法根据指定比较器的顺序对指定对象数组的指定范围进行排序。

    // Java展示使用Comparator
    import java.util.*;
    import java.lang.*;
    import Java.io.*;
    // student类
    class Student {
        int rollno;
        String name, address;
        // 构造函数
        public Student(int rollno, String name,
                       String address)
        {
            this.rollno = rollno;
            this.name = name;
            this.address = address;
        }
        // 在main()当中，打印student信息
        public String toString()
        {
            return this.rollno + " "
                + this.name + " "
                + this.address;
        }
    }
    class Sortbyroll implements Comparator {
        // 生序排序
        public int compare(Student a, Student b)
        {
            return a.rollno - b.rollno;
        }
    }
    // 测试代码
    class Main {
        public static void main(String[] args)
        {
            Student[] arr = { new Student(111, "bbbb", "london"),
                              new Student(131, "aaaa", "nyc"),
                              new Student(121, "cccc", "jaipur") };
            System.out.println("Unsorted");
            for (int i = 0; i < arr.length; i++)
                System.out.println(arr[i]);
            Arrays.sort(arr, 1, 2, new Sortbyroll());
            System.out.println("\nSorted by rollno");
            for (int i = 0; i < arr.length; i++)
                System.out.println(arr[i]);
        }
    }

    输出：

    Unsorted
    111 bbbb london
    131 aaaa nyc
    121 cccc jaipur
    Sorted by rollno
    111 bbbb london
    131 aaaa nyc
    121 cccc jaipur
    

     

23. static void sort(T[] a, Comparator< super T> c)：此方法根据指定比较器的顺序对指定对象数组进行排序。

    // Java展示使用 Comparator
    
    import java.util.*;
    import java.lang.*;
    import Java.io.*;
    // student类
    class Student {
        int rollno;
        String name, address;
        // 构造函数
        public Student(int rollno, String name,
                       String address)
        {
            this.rollno = rollno;
            this.name = name;
            this.address = address;
        }
        // 在main()打印student信息
        public String toString()
        {
            return this.rollno + " "
                + this.name + " "
                + this.address;
        }
    }
    class Sortbyroll implements Comparator {
        // 生序排序
        public int compare(Student a, Student b)
        {
            return a.rollno - b.rollno;
        }
    }
    // 测试代码
    class Main {
        public static void main(String[] args)
        {
            Student[] arr = { new Student(111, "bbbb", "london"),
                              new Student(131, "aaaa", "nyc"),
                              new Student(121, "cccc", "jaipur") };
            System.out.println("Unsorted");
            for (int i = 0; i < arr.length; i++)
                System.out.println(arr[i]);
            Arrays.sort(arr, new Sortbyroll());
            System.out.println("\nSorted by rollno");
            for (int i = 0; i < arr.length; i++)
                System.out.println(arr[i]);
        }
    }

    输出：

    Unsorted
    111 bbbb london
    131 aaaa nyc
    121 cccc jaipur
    Sorted by rollno
    111 bbbb london
    121 cccc jaipur
    131 aaaa nyc

24. spliterator(originalArray)：此方法返回一个重写所有指定Array的Spliterator。

    // Java展示使用
    // Arrays.spliterator()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 排序数组
            System.out.println("整数数组: "
                               + Arrays.spliterator(intArr));
        }
    }

    输出：

    Integer Array: java.util.Spliterators$IntArraySpliterator@232204a1
    

25. spliterator(originalArray，fromIndex，endIndex)：此方法返回一个重写指定数组范围的数组类型的Spliterator。

    // Java展示使用
    // Arrays.spliterator()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 常规方法排序
            System.out.println("整数数组: "
                               + Arrays.spliterator(intArr, 1, 3));
        }
    }

    输出：

    整数数组: java.util.Spliterators$IntArraySpliterator@232204a1
    

26. stream(originalArray)：此方法返回以指定数组为源的顺序流。

    // Java展示使用
    // Arrays.stream()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 从数组得到stream
            System.out.println("整数数组: "
                               + Arrays.stream(intArr));
        }
    }

    输出：

    整数数组: java.util.stream.IntPipeline$Head@4aa298b7

27. toString(originalArray)：此方法返回此数组内容的String表示形式。字符串表示形式由数组元素列表组成，并用方括号(“ []”)括起来。相邻元素之间用逗号分隔，后跟一个空格。元素通过String.valueOf()函数转换为字符串。

    // Java展示使用
    // Arrays.toString()方法
    import java.util.Arrays;
    public class Main {
        public static void main(String[] args)
        {
            // 获取数组
            int intArr[] = { 10, 20, 15, 22, 35 };
            // 打印元素
            System.out.println("数组: "
                               + Arrays.toString(intArr));
        }
    }

    输出：

    数组: [10, 20, 15, 22, 35]