Java Arrays 方法详解

1.Java Arrays.fill()方法详解

2.Java Arrays.copyOf()方法详解

3.Java Arrays.copyOfRange()方法详解

4.Java Arrays.sort()方法详解

1.sort(T[] a)

2.sort(T[] a,int formIndex,int toIndex)

3.sort(T[] a,Comparator c)

(1)按第一维元素比较二维数组：

(2)按第二维元素比较二维数组：

4.sort(T[] a,int formIndex,int toIndex,Comparator c)

1.Java Arrays.fill()方法详解

在Java API中的public static void fill(Object[ ] a,int fromIndex,int toIndex,Object val)将指定的Object引用分配给指定Object数组指定范围中的每个元素，填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括），如果fromIndex==toIndex，则填充范围为空。

参数	说明
a	要填充的数组
fromIndex	要使用指定值填充的第一个元素的索引(包括)
toIndex	要使用指定值填充的最后一个元素的索引(不包括)
val	要存储在数组的所有元素中的值

具体方法如下：

方法	描述
fill(boolean[ ] a,boolean val)	将指定的布尔值分配给指定的布尔数组的每个元素
fill(boolean[ ] a,int fromIndex,int toIndex,boolean val)	将指定的布尔值分配给指定布尔数组的指定范围的每个元素
fill(byte[ ] a,byte val)	将指定的字节值分配给指定字节数组的每个元素
fill(byte[ ] a,int fromIndex,int toIndex,byte val)	将指定的字节值分配给指定字节数组的指定范围的每个元素
fill(char[ ] a,char val)	将指定的char值分配给指定的char数组的每个元素
fill(char[ ] a,int fromIndex,int toIndex,char val)	将指定的char值分配给指定char数组的指定范围的每个元素
fill(double[ ] a,double val)	将指定的double值分配给指定的double数组的每个元素
fill(double[ ] a,int fromIndex,int toIndex,double val)	将指定的double值分配给指定的double数组的指定范围内的每个元素
fill(float[ ] a,float val)	将指定的浮点值分配给指定浮点数组的每个元素
fill(float[ ] a,int fromIndex,int toIndex,float val)	将指定的浮点值分配给指定浮点数组的指定范围的每个元素
fill(int[ ] a,int val)	将指定的int值分配给指定的int数组的每个元素
fill(int[ ] a,int fromIndex,int toIndex,int val)	将指定的int值分配给指定int数组的指定范围的每个元素
fill(long[ ] a,long val)	将指定的long值分配给指定的long数组的每个元素
fill(long[ ] a,int fromIndex,int toIndex,long val)	将指定的long值分配给指定long数组的指定范围的每个元素
fill(short[ ] a,short val)	将指定的short值分配给指定的short数组的每个元素
fill(short[ ] a,int fromIndex,int toIndex,short val)	将指定的short值分配给指定的short数组的指定范围的每个元素

例如：

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] a = new int[6];
        int[] b = new int[6];
        Arrays.fill(a,2);
        Arrays.fill(b,2,4,6);
        for(int i=0;i<a.length;i++)
        System.out.print(a[i]+",");
        System.out.print("\n");
        for(int i=0;i<b.length;i++)
        System.out.print(b[i]+",");
        System.out.print("\n");
    }
}

运行结果如下：

2,2,2,2,2,2,
0,0,6,6,0,0,

2.Java Arrays.copyOf()方法详解

该方法传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组，其中第一个变量表示原来的数组对象，第二个变量表示新的数组的长度，如果新的数组的长度超过原来的数组的长度，保留数组元素的默认基本类型的值。

方法	描述
copyOf(boolean[] original,int newLength)	复制指定的数组，截断或填充false(如有必要)，使副本具有指定的长度
copyOf(byte[] original,int newLength)	复制指定的数组，截断或填充0(如有必要)，使副本具有指定的长度
copyOf(char[] original,int newLength)	复制指定的数组,截断或填充空字符(如有必要)，使副本具有指定的长度
copyOf(double[] original,int newLength)	复制指定的数组，截断或填充0(如有必要)，使副本具有指定的长度
copy0f(float[] original,int newLength)	复制指定的数组，截断或填充0(如有必要)，使副本具有指定的长度
copyOf(int[] original,int newLength)	复制指定的数组，截断或填充0(如有必要)，使副本具有指定的长度
copyOf(long[] original,int newLength)	复制指定的数组，截断或填充0(如有必要)，使副本具有指定的长度
copyOf(short[] original,int newLength)	复制指定的数组，截断或填充0(如有必要)，使副本具有指定的长度
copyOf(T[] original,int newLength)	复制指定的数组，截断或填充空值(如有必要)，使副本具有指定的长度
copy0f(U[] original,int newLength,Class<? extends T[]> newType)	复制指定的数组，截断或填充空值(如有必要)，使副本具有指定的长度

例如：

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        int[] arr2 = Arrays.copyOf(arr1,4);
        int[] arr3 = Arrays.copyOf(arr1,8);
        for(int i=0;i<arr2.length;i++)
            System.out.print(arr2[i]+" ");
        System.out.println();
        for(int i=0;i<arr3.length;i++)
            System.out.print(arr3[i]+" ");
    }
}

运行结果如下：

1 2 3 4
1 2 3 4 5 0 0 0

3.Java Arrays.copyOfRange()方法详解

该方法用于对一个已有的数组进行截取复制，复制出一个左闭右开区间的数组。将一个原始的数组original，从下标from开始复制，复制到上标to，生成一个新的数组返回。

注意：这里包括from，不包括to，即[from,to)。

方法	描述
copyOfRange(boolean[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(byte[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(char[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange (double[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(float[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(int[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(long[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(short[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(T[] original,int from,int to)	将指定数组的指定范围复制到新数组中
copyOfRange(U[] original,int from,int to,Class<? extends T[]> newType)	将指定数组的指定范围复制到新数组中

例如：

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,6,7,8};
       System.out.println(Arrays.toString(arr));
       //复制整个数组
       int[] allArr = Arrays.copyOfRange(arr,0,8);
       String allString = Arrays.toString(allArr);
       //复制部分数组
       int[] partArr = Arrays.copyOfRange(arr,2,6);
       String partString = Arrays.toString(partArr);
       System.out.println(allString);
       System.out.println(partString);
    }
}

运行结果如下：

[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]
[3, 4, 5, 6]

4.Java Arrays.sort()方法详解

该方法是Arrays类的静态方法，用于对数组进行排序，时间复杂度O(n*logn)，方法返回值为void。排序后，数组中存放的是排序后的结果。由于该方法是在原来数组的空间基础上进行升序排序，因此不需要定义一个数组接收它，即不需要返回值。

Arrays.sort()重载了四类方法：

1.sort(T[] a)

对指定T型数组按数字升序排序，例如：

import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[] a = {2,5,1,8,12};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

运行结果如下：

[1, 2, 5, 8, 12]

2.sort(T[] a,int formIndex,int toIndex)

对指定T型数组的指定范围按数字升序排序，例如：

import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[] a = {8,2,15,4,7,1};
        Arrays.sort(a,1,5);
        System.out.println(Arrays.toString(a));
    }
}

运行结果如下：

[8, 2, 4, 7, 15, 1]

3.sort(T[] a,Comparator<? supre T> c)

根据指定比较器产生的顺序对T型数组进行排序。

(1)按第一维元素比较二维数组：

import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[][] nums = new int[][]{{1,3},{5,7},{9,5},{7,3}};
        Arrays.sort(nums,new Comparator<int[]>() {
            public int compare(int[] a,int[] b) {
                if(a[0]==b[0]) {
                    return a[1]-b[1];
                }else{
                    return a[0]-b[0];
                }
            }
        });
        for(int[] num : nums)
            System.out.println(Arrays.toString(num));
        int[] a = {8,2,15,4,7,1};
        Arrays.sort(a,1,5);
        System.out.println(Arrays.toString(a));
    }
}

运行结果如下：

[1, 3]
[5, 7]
[7, 3]
[9, 5]
[8, 2, 4, 7, 15, 1]

(2)按第二维元素比较二维数组：

import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[][] nums = new int[][]{{1,3},{5,7},{9,5},{7,3}};
        Arrays.sort(nums,new Comparator<int[]>() {
            public int compare(int[] a,int[] b) {
                if(a[1]==b[1]) {
                    return a[0]-b[0];
                }else{
                    return a[1]-b[1];
                }
            }
        });
        for(int[] num : nums)
            System.out.println(Arrays.toString(num));
    }
}

运行结果如下：

[1, 3]
[7, 3]
[9, 5]
[5, 7]

4.sort(T[] a,int formIndex,int toIndex,Comparator<? supre T> c)

根据指定比较器产生的顺序对T型数组的指定范围进行排序，例如：

import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        int[][] nums=new int[][]{{9,5},{7,3},{5,7},{1,3}};
        Arrays.sort(nums,1,4,new Comparator<int[]>() {
            public int compare(int[] a,int[] b) {
                if(a[0]==b[0]){
                    return a[1]-b[1];
                } else {
                    return a[0]-b[0];
                }
            }
        });
        for(int[] num : nums)
            System.out.println(Arrays.toString(num));
    }
}

运行结果如下：