001_java中的Arrays类

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

下面简单介绍下

1、给数组赋值：通过fill方法

2、对数组排序：通过sort方法,按升序

3、比较数组：通过equals方法比较数组中元素值是否相等

4、查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

/给数组赋值：通过fill方法。//

1、全体fill
public static void fill(boolean[] a,
                        boolean val)将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
                        推广出去，不仅仅是boolean
参数：
a - 要填充的数组
val - 要存储在数组所有元素中的值

2、指定范围填充

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

参数：
a - 要填充的数组
fromIndex - 要使用指定值填充的第一个元素的索引（包括）
toIndex - 要使用指定值填充的最后一个元素的索引（不包括）
val - 要存储在数组所有元素中的值
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

/对数组排序：通过sort方法,按升序/
1、全体排序
sort
public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序。
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和
M. Douglas McIlroy 合著的 Engineering a Sort Function",
Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。
此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：
a - 要排序的数组

*/

2、指定范围排序
/*
sort
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)对指定 int 型数组的指定范围按数字升序进行排序。
  排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的
 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。
 此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。


参数：
a - 要排序的数组
fromIndex - 要排序的第一个元素的索引（包括）
toIndex - 要排序的最后一个元素的索引（不包括）
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

//比较数组：通过equals方法比较数组中元素值是否相等
 public static boolean equals(int[] a,
                             int[] a2)如果两个指定的 int 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，
                             并且两个数组中的所有相应元素对都是相等的，
                             则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，
                             则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。


参数：
a - 将测试其相等性的一个数组
a2 - 将测试其相等性的另一个数组
返回：
如果两个数组相等，则返回 true

///查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作/   
1、全局binarySearch

public static int binarySearch(int[] a,
                               int key)使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：
a - 要搜索的数组
key - 要搜索的值
返回：
如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0（结果是下标，找不到返回值就小于0）。

2、指定范围binarySearch      
public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。必须在进行此调用之前对范围进行排序（通过 sort(int[], int, int) 方法）。如果没有对范围进行排序，则结果是不确定的。如果范围包含多个带有指定值的元素，则无法保证找到的是哪一个。

参数：
a - 要搜索的数组
fromIndex - 要搜索的第一个元素的索引（包括）
toIndex - 要搜索的最后一个元素的索引（不包括）
key - 要搜索的值
返回：
如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，
则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0（结果是下标，找不到返回值就小于0）。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

下面是测试代码///

import java.util.Arrays;            //Arrays
import java.math.*;                 //随机数

public class TestArrays
{
    public static void output(int[] arrays)
    {
        if( arrays != null)
        {
            for( int i = 0; i < arrays.length; ++i )
            {
                System.out.print(arrays[i] + "\t");
            } 
            System.out.println();
        }
    }
    public static void main(String[] args)
    {
/给数组赋值：通过fill方法。//
//1、全体fill
/*
public static void fill(boolean[] a,
                        boolean val)将指定的 boolean 值分配给指定 boolean 型数组的每个元素。 
                        推广出去，不仅仅是boolean
参数：
a - 要填充的数组
val - 要存储在数组所有元素中的值
*/
        System.out.println("下面测试全体fill（Arrays.fill(arrays,10)： ");
        int[] arrays = new int[5];
        Arrays.fill(arrays,10);
        TestArrays.output(arrays);
//2、指定范围填充
/*
public static void fill(boolean[] a,
                        int fromIndex,
                        int toIndex,
                        boolean val)
将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。
（如果 fromIndex==toIndex，则填充范围为空。） 

参数：
a - 要填充的数组
fromIndex - 要使用指定值填充的第一个元素的索引（包括）
toIndex - 要使用指定值填充的最后一个元素的索引（不包括）
val - 要存储在数组所有元素中的值 
抛出： 
IllegalArgumentException - 如果 fromIndex > toIndex 
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
*/
        System.out.println("下面测试指定范围fill（Arrays.fill(arrays1,0,6,20)）： ");
        int[] arrays1 = new int[20];
        Arrays.fill(arrays1,0,6,20);
        TestArrays.output(arrays1);
/对数组排序：通过sort方法,按升序/
//1、全体排序
/*
sort
public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序。
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 
M. Douglas McIlroy 合著的 Engineering a Sort Function", 
Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。
此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。 

参数：
a - 要排序的数组

*/
        System.out.println("下面测试全体sort： ");
        int[] arrays2 = new int[10];
        for( int i = 0; i < arrays2.length; ++i )
        {
            arrays2[i] = (int)Math.round(Math.random()*100);            //产生1-100的随机数，进行结果取余，并强转成int
        }
        System.out.println("排序前数组值： ");
        TestArrays.output(arrays2);
        Arrays.sort(arrays2);                   //使用的快排，从小到大
        System.out.println("排序后的结果是（Arrays.sort(arrays2)）： ");
        TestArrays.output(arrays2);
        
//2、指定范围排序
/*
sort
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)对指定 int 型数组的指定范围按数字升序进行排序。
  排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的
 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。
 此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。 


参数：
a - 要排序的数组
fromIndex - 要排序的第一个元素的索引（包括）
toIndex - 要排序的最后一个元素的索引（不包括） 
抛出： 
IllegalArgumentException - 如果 fromIndex > toIndex 
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
*/
        System.out.println("下面测试指定范围sort： ");
        int[] arrays3 = new int[10];
        for( int i = 0; i < arrays3.length; ++i )
        {
            arrays3[i] = (int)Math.round(Math.random()*100);
        }
        System.out.println("排序前数组值： ");
        TestArrays.output(arrays3);
        Arrays.sort(arrays3,0,6);
        System.out.println("排序后数组值（Arrays.sort(arrays3,0,6)） ：");
        TestArrays.output(arrays3);
        
 //比较数组：通过equals方法比较数组中元素值是否相等
 /*
 public static boolean equals(int[] a,
                             int[] a2)如果两个指定的 int 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，
                             并且两个数组中的所有相应元素对都是相等的，
                             则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，
                             则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。


参数：
a - 将测试其相等性的一个数组
a2 - 将测试其相等性的另一个数组 
返回：
如果两个数组相等，则返回 true

 */       
        System.out.println("下面测试equals： ");
        if( Arrays.equals(arrays2,arrays3) )
        {
            System.out.println("数组arrays2与数组arrays3相等！");
        }else
        {
            System.out.println("数组arrays2与数组arrays3不相等！");
        }
        System.out.println("arrays2：");
        TestArrays.output(arrays2);
        System.out.println("arrays3：");
        TestArrays.output(arrays3);
        
        
///查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作/   
//1、全局binarySearch
/*
public static int binarySearch(int[] a,
                               int key)使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。 

参数：
a - 要搜索的数组
key - 要搜索的值 
返回：
如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0（结果是下标，找不到返回值就小于0）。

*/    
        System.out.println("下面测试全体binarySearch（Arrays.binarySearch(arrays3,10);）：");
        Arrays.sort(arrays3);                                                       //进行binarySearch之前，必须先进行排序
        int i = Arrays.binarySearch(arrays3,10);
        if( i>= 0 )
        {
            System.out.println("10在arrays3数组的下标 " + i+" 处！");
        }else
        {
            System.out.println("10不存在与数组arrays3中！！");
        }
        TestArrays.output(arrays3);

//2、指定范围binarySearch       
/*
public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。必须在进行此调用之前对范围进行排序（通过 sort(int[], int, int) 方法）。如果没有对范围进行排序，则结果是不确定的。如果范围包含多个带有指定值的元素，则无法保证找到的是哪一个。 

参数：
a - 要搜索的数组
fromIndex - 要搜索的第一个元素的索引（包括）
toIndex - 要搜索的最后一个元素的索引（不包括）
key - 要搜索的值 
返回：
如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，
则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0（结果是下标，找不到返回值就小于0）。 
抛出： 
IllegalArgumentException - 如果 fromIndex > toIndex 
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

*/
        System.out.println("下面测试指定范围binarySearch（Arrays.binarySearch(arrays2,0,6,15)）：");
        Arrays.sort(arrays2);
        int j = Arrays.binarySearch(arrays2,0,6,15);
        if( j >= 0 )
        {
            System.out.println("15在arrays2数组的下标 " + j+" 处！");
        }else
        {
            System.out.println("15不存在与数组arrays3(0-5)中！！");
        }
        TestArrays.output(arrays2);
        
    }
}

下面是测试结果

F:\code\Java\Course\016_Arrays类>java TestArrays
下面测试全体fill（Arrays.fill(arrays,10)：
10      10      10      10      10
下面测试指定范围fill（Arrays.fill(arrays1,0,6,20)）：
20      20      20      20      20      20      0       0       0       0
0       0       0       0       0       0       0       0       0       0

下面测试全体sort：
排序前数组值：
39      39      66      56      36      72      35      72      9       29

排序后的结果是（Arrays.sort(arrays2)）：
9       29      35      36      39      39      56      66      72      72

下面测试指定范围sort：
排序前数组值：
93      78      73      55      0       59      78      67      6       16

排序后数组值（Arrays.sort(arrays3,0,6)） ：
0       55      59      73      78      93      78      67      6       16

下面测试equals：
数组arrays2与数组arrays3不相等！
arrays2：
9       29      35      36      39      39      56      66      72      72

arrays3：
0       55      59      73      78      93      78      67      6       16

下面测试全体binarySearch（Arrays.binarySearch(arrays3,10);）：
10不存在与数组arrays3中！！
0       6       16      55      59      67      73      78      78      93

下面测试指定范围binarySearch（Arrays.binarySearch(arrays2,0,6,15)）：
15不存在与数组arrays3(0-5)中！！
9       29      35      36      39      39      56      66      72      72