指引网

当前位置: 主页 > 编程开发 > Java >

J2SE综合:对java.util的总结 六

来源:网络 作者:佚名 点击: 时间:2017-11-14 06:27
[摘要] 15.9 Arrays (数组) Java 2在java.util中新增加了一个叫做Arrays的类。这个类提供了各种在进行数组运算时很有用的方法。尽管这些方法在技术上不属于类集框架,但它们提供了跨越类集和数组的桥
J2SE

  15.9 Arrays (数组)
  
  Java 2在java.util中新增加了一个叫做Arrays的类。这个类提供了各种在进行数组运算时很有用的方法。尽管这些方法在技术上不属于类集框架,但它们提供了跨越类集和数组的桥梁。在这一节中,分析由Arrays定义的每一种方法。
  
  asList( )方法返回一个被指定数组支持的List.换句话说,列表和数组访问的是同一个单元。它具有如下的形式:
  
  static List asList(Object[ ] array)
  
  这里array是包含了数据的数组。
  
  binarySearch( )方法使用二进制搜索寻找指定的值。该方法必须应用于排序数组。它具有如下的形式:
  
  static int binarySearch(byte[ ] array, byte value)
  
  static int binarySearch(char[ ] array, char value)
  
  static int binarySearch(double[ ] array, double value)
  
  static int binarySearch(float[ ] array, float value)
  
  static int binarySearch(int[ ] array, int value)
  
  static int binarySearch(long[ ] array, long value)
  
  static int binarySearch(short[ ] array, short value)
  
  static int binarySearch(Object[ ] array, Object value)
  
  static int binarySearch(Object[ ] array, Object value, Comparator c)
  
  这里,array是被搜索的数组,而value是被查找的值。当array中包含的元素是不可比较的(例如Double和StringBuffer)或者当value与array中的类型不兼容时,后两种形式引发一个ClassCastException异常。在最后一种形式中,比较函数(Comparator)c用于确定array中的元素的顺序。在所有的形式中,如果array中含有value,则返回该元素的下标。否则,返回一个负值。
  
  当两个数组相等时,equals( )方法返回true;否则返回false.equals( )方法具有下面的一些形式:
  
  static boolean equals(boolean array1[ ], boolean array2[ ])
  
  static boolean equals(byte array1[ ], byte array2[ ])
  
  static boolean equals(char array1[ ], char array2[ ])
  
  static boolean equals(double array1[ ], double array2[ ])
  
  static boolean equals(float array1[ ], float array2[ ])
  
  static boolean equals(int array1[ ], int array2[ ])
  
  static boolean equals(long array1[ ], long array2[ ])
  
  static boolean equals(short array1[ ], short array2[ ])
  
  static boolean equals(Object array1[ ], Object array2[ ])
  
  这里array1和array2是两个用来比较看是否相等的数组。
  
  fill( )方法将一个值赋给数组中的所有元素。换句话说,它用一个指定的值填充数组。
  
  fill( )方法有两种形式。第一种形式具有下面的一些形式,填充整个数组:
  
  static void fill(boolean array[ ], boolean value)
  
  static void fill(byte array[ ], byte value)
  
  static void fill(char array[ ], char value)
  
  static void fill(double array[ ], double value)
  
  static void fill(float array[ ], float value)
  
  static void fill(int array[ ], int value)
  
  static void fill(long array[ ], long value)
  
  static void fill(short array[ ], short value)
  
  static void fill(Object array[ ], Object value)
  
  这里value被赋给数组array中的每一个元素。
  
  fill( )方法的第二种形式将一个值赋给数组的一个子集。它的几种形式如下:
  
  static void fill(boolean array[ ], int start, int end, boolean value)
  
  static void fill(byte array[ ], int start, int end, byte value)
  
  static void fill(char array[ ], int start, int end, char value)
  
  static void fill(double array[ ], int start, int end, double value)
  
  static void fill(float array[ ], int start, int end, float value)
  
  static void fill(int array[ ], int start, int end, int value)
  
  static void fill(long array[ ], int start, int end, long value)
  
  static void fill(short array[ ], int start, int end, short value)
  
  static void fill(Object array[ ], int start, int end, Object value)
  
  这里,value是赋给数组array中从start开始到end?1结束的子集的值。这些方法当start大于end时,都能引发一个IllegalArgumentException异常;而当start或end出界时,都能引发一个ArrayIndexOutOfBoundsException异常。
  
  sort( )方法对数组进行排序,以便数组能够按升序进行排列。sort( )方法有两种形式。
  
  下面给出的第一种形式对整个数组进行排序:
  
  static void sort(byte array[ ])
  
  static void sort(char array[ ])
  
  static void sort(double array[ ])
  
  static void sort(float array[ ])
  
  static void sort(int array[ ])
  
  static void sort(long array[ ])
  
  static void sort(short array[ ])
  
  static void sort(Object array[ ])
  
  static void sort(Object array[ ], Comparator c)
  
  这里,array是被排序的数组。在最后的一种形式中,c是一个用来规定array中元素顺序的比较函数(Comparator)。当用于排序的数组中的元素不可比较时,这些对Object的数组进行排序的sort( )方法将引发一个ClassCastException异常。
  
  sort( )方法的第二种形式允许在一个数组内,指定一个想要进行排序的范围。它的具体形式如下:
  
  static void sort(byte array[ ], int start, int end)
  
  static void sort(char array[ ], int start, int end)
  
  static void sort(double array[ ], int start, int end)
  
  static void sort(float array[ ], int start, int end)
  
  static void sort(int array[ ], int start, int end)
  
  static void sort(long array[ ], int start, int end)
  
  static void sort(short array[ ], int start, int end)
  
  static void sort(Object array[ ], int start, int end)
  
  static void sort(Object array[ ], int start, int end, Comparator c)
  
  这里,数组中想要进行排序的范围从start到end?1.在最后一种形式中,c是一个用来规定array中元素顺序的Comparator.如果start大于end ,所有这些方法都能引发一个IllegalArgumentException 异常; 而当start 或end 出界时, 又都能引发一个ArrayIndexOutOfBoundsException异常。当用于排序的数组中的元素不可比较时,最后两种形式也能引发一个ClassCastException异常。
  
  下面的程序举例说明了如何使用Arrays类中的一些方法:
  
  // Demonstrate Arrays
  
  import java.util.*;
  
  class ArraysDemo {
  
  public static void main(String args[]) {
  
  // allocate and initialize array
  
  int array[] = new int[10];
  
  for(int i = 0; i < 10; i++)
  
  array[i] = -3 * i;
  
  // display, sort, display
  
  System.out.print("Original contents: ");
  
  display(array);
  
  Arrays.sort(array);
  
  System.out.print("Sorted: ");
  
  display(array);
  
  // fill and display
  
  Arrays.fill(array, 2, 6, -1);
  
  System.out.print("After fill(): ");
  
  display(array);
  
  // sort and display
  
  Arrays.sort(array);
  
  System.out.print("After sorting again: ");
  
  display(array);
  
  // binary search for -9
  
  System.out.print("The value -9 is at location ");
  
  int index =
  
  Arrays.binarySearch(array, -9);
  
  System.out.println(index);
  
  }
  
  static void display(int array[]) {
  
  for(int i = 0; i < array.length; i++)
  
  System.out.print(array[i] + " ");
  
  System.out.println("");
  
  }
  
  }
  
  下面是该程序的输出结果:
  
  Original contents: 0 -3 -6 -9 -12 -15 -18 -21 -24 -27
  
  Sorted: -27 -24 -21 -18 -15 -12 -9 -6 -3 0
  
  After fill(): -27 -24 -1 -1 -1 -1 -9 -6 -3 0
  
  After sorting again: -27 -24 -9 -6 -3 -1 -1 -1 -1 0
  
  The value -9 is at location 2
------分隔线----------------------------