Arrays 类

在 java.util 类库中可以找到 Arrays 类，它有一套 static 方法，提供操作数组的实用功能。
其中有四个基本方法：equals()，比较两个数组是否相等；fill()，用某个值填充整个数组；
sort()，对数组排序；还有 binarySearch()，在已经排序的数组中查找元素。所有这些方
法都被各种基本类型和 Object 类重载过。此外，方法 asList()接受任意的数组为参数，并
将其转变为 List 容器（稍后会学到 List）。


Arrays 类虽然很有用，但是它却仍然不具备完备的功能。例如，如果能够很容易地打印数
组的所有元素，而不需要每次都需要自己去编写 for 循环的代码，那就太好了。而且你会看
到，方法 fill()只能以某个单一的值填充整个数组，如果你想用随机生成的若干数字填充数
组，fill()就无能为力了。


所以为 Arrays 类添加这样一些实用功能会很有帮助，我将它们打包放入
com.bruceeckel.util 包中，以便于使用。利用它们可以打印任意类型的数组，以不同的
值或对象填充数组，这些对象由你定义的“生成器（generator）”对象创建。


因为要为每一种基本类型和对象都要编写代码，所以有许多重复的代码3。例如，要为每一
种类型编写一个“生成器（generator）”接口，因为next()的返回类型各不相同：


//: com:bruceeckel:util:Generator.java
package com.bruceeckel.util; 
public interface Generator { Object next(); } ///:~
//: com:bruceeckel:util:BooleanGenerator.java
package com.bruceeckel.util; 
public interface BooleanGenerator {boolean next(); } ///:~
//: com:bruceeckel:util:ByteGenerator.java
package com.bruceeckel.util; 
public interface ByteGenerator {byte next(); } ///:~
//: com:bruceeckel:util:CharGenerator.java
package com.bruceeckel.util; 

public interface CharGenerator {char next(); } ///:~

//: com:bruceeckel:util:ShortGenerator.java
package com.bruceeckel.util; 
public interface ShortGenerator {short next(); } ///:~








//: com:bruceeckel:util:IntGenerator.java
package com.bruceeckel.util; 
public interface IntGenerator { int next(); }///:~








//: com:bruceeckel:util:LongGenerator.java
package com.bruceeckel.util; 
public interface LongGenerator {long next(); } ///:~








//: com:bruceeckel:util:FloatGenerator.java
package com.bruceeckel.util; 
public interface FloatGenerator {float next(); } ///:~








//: com:bruceeckel:util:DoubleGenerator.java
package com.bruceeckel.util; 
public interface DoubleGenerator { double next(); } ///:~


Arrays2 为各种类型都重载了 toString()方法。这些方法使得打印数组毫不费力。
toString()的代码展示了如何使用 StringBuffer 代替 String 对象，这是基于效率考虑；
如果你多次调用一个方法，其中需要组装字符串，那么使用更高效的 StringBuffer 取代
String 就是明智之举。此处的 StringBuffer，在创建的时候就带有初始值，然后再向其中
添加 String。最后，将 result 转换成 String 再返回：


//: com:bruceeckel:util:Arrays2.java
// A supplement to java.util.Arrays, to provide additional
// useful functionality when working with arrays. Allows
// any array to be converted to a String, and to be filled
// via a user-defined "generator" object.
package com.bruceeckel.util; 
import java.util.*; 

public class Arrays2 {

public static String toString(boolean[] a) {
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(byte[] a) {
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(char[] a) {
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(short[] a) { 
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(int[] a) {
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
 






if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(long[] a) {
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(float[] a) { 
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
public static String toString(double[] a) { 
    StringBuffer result = new StringBuffer("[");
for(int i = 0; i < a.length; i++) { 
      result.append(a[i]); 
if(i < a.length - 1) 
        result.append(", ");
    }
    result.append("]"); 
return result.toString(); 
  }
// Fill an array using a generator:
public static void fill(Object[] a, Generator gen) {
    fill(a, 0, a.length, gen); 
  }
public static void
  fill(Object[] a, int from, int to, Generator gen) { 
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
 






  }
public static void
  fill(boolean[] a, BooleanGenerator gen) {
      fill(a, 0, a.length, gen);
  }
public static void
  fill(boolean[] a, int from, int to,BooleanGenerator gen){ 
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(byte[] a, ByteGenerator gen) { 
    fill(a, 0, a.length, gen); 
  }
public static void
  fill(byte[] a, int from,int to, ByteGenerator gen) {
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(char[] a, CharGenerator gen) { 
    fill(a, 0, a.length, gen); 
  }
public static void
  fill(char[] a, int from,int to, CharGenerator gen) {
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(short[] a, ShortGenerator gen) { 
    fill(a, 0, a.length, gen); 
  }
public static void
  fill(short[] a, int from, int to, ShortGenerator gen) { 
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(int[] a, IntGenerator gen) {
      fill(a, 0, a.length, gen);
  }
public static void
  fill(int[] a, int from, int to, IntGenerator gen) { 
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(long[] a, LongGenerator gen) { 
    fill(a, 0, a.length, gen); 
 






  }
public static void
  fill(long[] a, int from,int to, LongGenerator gen) {
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(float[] a, FloatGenerator gen) { 
    fill(a, 0, a.length, gen); 
  }
public static void
  fill(float[] a, int from, int to, FloatGenerator gen) { 
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
public static void fill(double[] a, DoubleGenerator gen){ 
    fill(a, 0, a.length, gen); 
  }
public static void
  fill(double[] a, int from, int to, DoubleGenerator gen) { 
for(int i = from; i < to; i++) 
      a[i] = gen.next(); 
  }
private static Random r = new Random(); 
public static class
  RandBooleanGenerator implements BooleanGenerator {
public boolean next() { return r.nextBoolean(); } 
  }
public static class
  RandByteGenerator implements ByteGenerator { 
public byte next() { return (byte)r.nextInt(); } 
  }
private static String ssource =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
private staticchar[] src = ssource.toCharArray(); 
public static class
  RandCharGenerator implements CharGenerator { 
public char next() {
return src[r.nextInt(src.length)]; 
    }
  }
public static class
  RandStringGenerator implements Generator {
private int len;
private RandCharGenerator cg = new RandCharGenerator(); 
 






public RandStringGenerator(int length) {
      len = length;
    }
public Object next() { 
char[] buf = new char[len];
for(int i = 0; i < len; i++) 
        buf[i] = cg.next(); 
return new String(buf); 
    }
  }
public static class
  RandShortGenerator implements ShortGenerator { 
public short next() { return (short)r.nextInt(); }
  }
public static class
  RandIntGenerator implements IntGenerator {
private int mod = 10000;
public RandIntGenerator() {}
public RandIntGenerator(int modulo) { mod = modulo; } 
public int next() { return r.nextInt(mod); } 
  }
public static class
  RandLongGenerator implements LongGenerator { 
public long next() { return r.nextLong(); } 
  }
public static class
  RandFloatGenerator implements FloatGenerator { 
public float next() { return r.nextFloat(); } 
  }
public static class
  RandDoubleGenerator implements DoubleGenerator { 
public double next() {return r.nextDouble();} 
  }
} ///:~


为了使用生成器生成的元素填充数组，fill()方法以恰当类型的生成器接口的引用作为参数，
生成器的 next()方法生成一个类型正确的对象（依赖于接口如何实现）。fill()方法直接调
用 next()，填充所需的范围。现在，实现恰当的接口即可制作一个生成器，并在 fill()中使
用自己的生成器。


随机数据生成器对于测试很有用。所以，这里使用了一组内部类，实现基本类型的生成器
接口。同时，使用 String 生成器作为 Object 的代表。可以看到 RandStringGenerator
使用 RandCharGenerator 填充一个字符数组，然后将其转成 String。此数组的大小由构
造器的参数决定。
 






RandIntGenerator 默认以 10,000 为模数，如果不需要生成太大的数字，可以重载构造
器选择一个稍小的值。


下面的程序测试并演示了如何使用此类库：


//: c11:TestArrays2.java
// Test and demonstrate Arrays2 utilities.
import com.bruceeckel.util.*; 


public class TestArrays2 { 
public static void main(String[] args) { 
int size = 6; 
// Or get the size from the command line:
if(args.length != 0) { 
      size = Integer.parseInt(args[0]); 
if(size < 3) { 
        System.out.println("arg must be >= 3"); 
        System.exit(1); 
      }
    }
boolean[] a1 = newboolean[size]; 
byte[] a2 = newbyte[size];
char[] a3 = newchar[size];
short[] a4 = new short[size]; 
int[] a5 = new int[size];
long[] a6 = newlong[size];
float[] a7 = new float[size]; 
double[] a8 = newdouble[size];
    Arrays2.fill(a1, new Arrays2.RandBooleanGenerator()); 
    System.out.println("a1 = " + Arrays2.toString(a1));
    Arrays2.fill(a2, new Arrays2.RandByteGenerator());
    System.out.println("a2 = " + Arrays2.toString(a2));
    Arrays2.fill(a3, new Arrays2.RandCharGenerator());
    System.out.println("a3 = " + Arrays2.toString(a3));
    Arrays2.fill(a4, new Arrays2.RandShortGenerator());
    System.out.println("a4 = " + Arrays2.toString(a4));
    Arrays2.fill(a5, new Arrays2.RandIntGenerator()); 
    System.out.println("a5 = " + Arrays2.toString(a5));
    Arrays2.fill(a6, new Arrays2.RandLongGenerator());
    System.out.println("a6 = " + Arrays2.toString(a6));
    Arrays2.fill(a7, new Arrays2.RandFloatGenerator());
    System.out.println("a7 = " + Arrays2.toString(a7));
    Arrays2.fill(a8, new Arrays2.RandDoubleGenerator()); 
    System.out.println("a8 = " + Arrays2.toString(a8));
  }
} ///:~


参数 size 有默认值，不过你也可以通过命令行参数设置它