Java8集合框架——集合工具类Arrays内部方法浅析

java.util.Arrays

备注：本文只对 Java8 中的 java.util.Arrays 中提供的基本功能进行大致介绍，并没有对其具体的实现原理进行深入的探讨和分析。详情可自己深入观摩源码。

本文的结构：

零、开场：Arrays的官方注释
一、数组排序：sort
二、二分法查找数组中的元素：binarySearch
三、比较两个数组是否相等：equals
四、填数组填充元素：fill，充对数组中的指定位置填充相同的元素内容
五、数组拷贝：copyOf
六、数组转链表：asList，将数组转换为一个固定的List链表对象
七、计算数组的哈希值：hashCode
八、数组转String：toString，以特定格式输出数组

零、开场：Arrays的官方注释

　　先来一段官方注释：

　　This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.

　　Arrays这个类提供了用于操作数组的不同方法(例如：排序和查找)，也包含了一个静态工厂，用于允许数组当作链表进行操作。

　　The methods in this class all throw a NullPointerException, if the specified array reference is null, except where noted.

　　除了有特殊标注的，这个类的所有方法都会在数组引用是 null 时抛出“NullPointerException”空指针异常。

这个注释也是为这个工具类的作用定了基调，其作用基本如下，即注释所体现的：

用于操作数组的方法：排序、二分查找、比较判断、填充、数组拷贝、数组转链表、数组hashCode、数组转字符串String等
静态工厂：将数组转化为链表进行操作

一、数组排序：sort

　　主要是对基本类型的数组进行排序，排序算法主要是Dual-Pivot Quicksort（双基准快排，暂且未研究，可以百度/谷歌了解下），而非经典的快排（one-pivot单基准）。在可以对原数组元素顺序进行改变时，可以使用这些现成的排序工具方法。

 // 对int型数组进行排序，会改变原数组中的元素位置

 public static void sort(int[] a){...}

 // 对数组fromIndex下标(包含)到toIndex下标(不包含)的元素进行排序，同样会改变原数组的元素

 public static void sort(int[] a, int fromIndex, int toIndex){...}

 // long型数组的排序

 public static void sort(long[] a){...}

 public static void sort(long[] a, int fromIndex, int toIndex){...}

 // short型数组的排序

 public static void sort(short[] a){...}

 public static void sort(short[] a, int fromIndex, int toIndex){...}

 // char型数组的排序

 public static void sort(char[] a){...}

 public static void sort(char[] a, int fromIndex, int toIndex){...}

 // byte型数组的排序

 public static void sort(byte[] a){...}

 public static void sort(byte[] a, int fromIndex, int toIndex){...}

 // float型数组的排序

 public static void sort(float[] a){...}

 public static void sort(float[] a, int fromIndex, int toIndex){...}

 // double型数组的排序

 public static void sort(double[] a){...}

 public static void sort(double[] a, int fromIndex, int toIndex){...}

　　还有Object数组和泛型(需要提供Comparator)的比较排序，用的是归并排序。

二、二分法查找数组中的元素：binarySearch

　　主要是在一排序的基本类型数组中进行二分查找，找不到指定元素时返回下标值小于0。

 // int排序数组中的二分查找

 public static int binarySearch(int[] a, int key){...}

 // 对int数组fromIndex下标数组fromIndex下标(包含)到toIndex下标(不包含)的元素的二分查找

 public static int binarySearch(int[] a, int fromIndex, int toIndex, int key){...}

 // short排序数组中的二分查找

 public static int binarySearch(short[] a, short key){...}

 public static int binarySearch(short[] a, int fromIndex, int toIndex, short key){...}

 // char排序数组中的二分查找

 public static int binarySearch(char[] a, char key){...}

 public static int binarySearch(char[] a, int fromIndex, int toIndex, char key){...}

 // byte排序数组中的二分查找

 public static int binarySearch(byte[] a, byte key){...}

 public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key){...}

 // double排序数组中的二分查找

 public static int binarySearch(double[] a, double key){...}

 public static int binarySearch(double[] a, int fromIndex, int toIndex, double key){...}

 // float排序数组中的二分查找

 public static int binarySearch(float[] a, float key){...}

 public static int binarySearch(float[] a, int fromIndex, int toIndex, float key){...}

　　还有对Object数组和泛型(需要提供Comparator)的二分查找。

三、比较两个数组是否相等：equals

　　判断两个数组是否相等。

 // long数组判断

 public static boolean equals(long[] a, long[] a2){...}

 // int数组判断

 public static boolean equals(int[] a, int[] a2){...}

 // short数组判断

 public static boolean equals(short[] a, short a2[]){...}

 // char数组判断

 public static boolean equals(char[] a, char[] a2){...}

 // byte数组判断

 public static boolean equals(byte[] a, byte[] a2){...}

 // boolean数组判断

 public static boolean equals(boolean[] a, boolean[] a2){...}

 // double数组判断

 public static boolean equals(double[] a, double[] a2){...}

 // float数组判断

 public static boolean equals(float[] a, float[] a2){...}

 // Object数组判断，主要使用equals进行判断

 public static boolean equals(Object[] a, Object[] a2){...}

四、填数组填充元素：fill，充对数组中的指定位置填充相同的元素内容

　　对数组（指定下标或者全部）填充某指定元素

 // long数组

 public static void fill(long[] a, long val){...}

 public static void fill(long[] a, int fromIndex, int toIndex, long val){...}

 // int数组

 public static void fill(int[] a, int val){...}

 public static void fill(int[] a, int fromIndex, int toIndex, int val){...}

 // short数组

 public static void fill(short[] a, short val){...}

 public static void fill(short[] a, int fromIndex, int toIndex, short val){...}

 // char数组

 public static void fill(char[] a, char val){...}

 public static void fill(char[] a, int fromIndex, int toIndex, char val){...}

 // byte数组

 public static void fill(byte[] a, byte val){...}

 public static void fill(byte[] a, int fromIndex, int toIndex, byte val){...}

 // boolean数组

 public static void fill(boolean[] a, boolean val){...}

 public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val){...}

 // double数组

 public static void fill(double[] a, double val){...}

 public static void fill(double[] a, int fromIndex, int toIndex,double val){...}

 // float数组

 public static void fill(float[] a, float val){...}

 public static void fill(float[] a, int fromIndex, int toIndex, float val){...}

 // Object数组

 public static void fill(Object[] a, Object val){...}

 public static void fill(Object[] a, int fromIndex, int toIndex, Object val){...}

五、数组拷贝：copyOf

　　数组的复制：

// 数组的全复制

public static byte[] copyOf(byte[] original, int newLength) {...}

public static short[] copyOf(short[] original, int newLength) {...}

public static int[] copyOf(int[] original, int newLength) {...}

public static long[] copyOf(long[] original, int newLength) {...}

public static char[] copyOf(char[] original, int newLength) {...}

public static float[] copyOf(float[] original, int newLength) {...}

public static double[] copyOf(double[] original, int newLength) {...}

public static boolean[] copyOf(boolean[] original, int newLength) {...}

public static <T> T[] copyOf(T[] original, int newLength) {...}

// 从from下标(包含)到to下标(不包含)的复制版本

public static short[] copyOfRange(xxx[] original, int from, int to) {...}

六、数组转链表：asList，将数组转换为一个固定的List链表对象

　　将数组转换成链表形式返回，返回的是内部类ArrayList。对于这个链表，更改操作只有set，而且会改变原来的数组内容；另外就是不支持add操作，对于add调用，会抛出 UnsupportedOperationException 异常(没有重写add实现时的默认实现)。

 public static <T> List<T> asList(T... a){...}

七、计算数组的哈希值：hashCode

　　计算数组的hashCode:

public static int hashCode(long a[]) {...}

public static int hashCode(int a[]) {...}

public static int hashCode(short a[]) {...}

public static int hashCode(char a[]) {...}

public static int hashCode(byte a[]) {...}

public static int hashCode(boolean a[]) {...}

public static int hashCode(float a[]) {...}

public static int hashCode(double a[]) {...}

public static int hashCode(Object a[]) {...}

八、数组转String：toString，以特定格式输出数组

　　将数组转化为String，格式为：[x, xx, xxx, xxxx]，若是数组为空，返回null：

public static String toString(long[] a)

public static String toString(int[] a)

public static String toString(short[] a)

public static String toString(char[] a)

public static String toString(byte[] a)

public static String toString(boolean[] a)

public static String toString(float[] a)

public static String toString(double[] a)

public static String toString(Object[] a)