附录：工具
包括编译本书（代码）用到的一些工具。其中一些可能是临时性的，如果以后基准代码移到CVS，它们可能会从这里消失。
Ant 扩展
Ant 提供扩展API，你可以利用它们用java创建你自己的任务。你可以从Ant的官方文档或者已出版的关于Ant的书籍中找到详尽的信息。
作为另外一种选择，你可以简单的写一个java程序，并且在Ant里调用；使用这种方法，你就用不着学习扩展API了。例如，为了编译本书的代码，我们需要确定用户使用的Java版本是JDK 1.3 或者更高，所以就有了下面的程序：
//: com:bruceeckel:tools:CheckVersion.java
// {RunByHand}
package com.bruceeckel.tools;
public class CheckVersion {
public static void main(String[] args) {
String version = System.getProperty("java.version");
char minor = version.charAt(2);
char point = version.charAt(4);
if(minor < '3' || point < '0')
throw new RuntimeException("JDK 1.3.0 or higher " +
"is required to run the examples in this book.");
System.out.println("JDK version "+ version + " found");
}
} ///:~
这个程序只是简单的使用System.getProperty( )来获取java版本，如果版本号小于1.3就抛出一个异常。当Ant碰到这个异常的时候，它就会停下来。这么一来，在想要检测版本号的时候，你就可以在任何buildfile里加上下面几行脚本：
<java
taskname="CheckVersion"
classname="com.bruceeckel.tools.CheckVersion"
classpath="${basedir}"
fork="true"
failonerror="true"
/>
用这种方法添加新的工具，你可以很快的完成从编码到测试。如果它们被证明是合理的话，你可以再花些力气写个Ant的扩展程序。
Array utilities
尽管有用，（java自带的）Arrays类还是功能不够全面。例如，如果能够直接打印一个数组的所有元素，而不是每次必须手写for循环才能完成，那就好了。你会看到，fill（）方法只能把一个值放到数组里面，假如说你想用一组随即产生的数字来填充一个数组，fill（）方法就无能为力了。
这样一来，写一些额外的实用程序（utilities）作为Arrays类的补充就显的有意义了，方便起见，我把它们放到了com.bruceeckel.util这个package里。这些小程序可以打印一个任意类型的数组，也可以填充由你所定义的一个叫做generator的东东产生的值或者对象。
因为（实用程序的）代码需要支持每一种基本类型（primitive type）和Object类型，所以就产生了许多近乎重复的代码。例如，每种类型都需要一个“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(); } ///:~
Array2包括一系列为每种类型重载过的toString()方法。这些方法使你可以很容易的打印一个数组。ToString（）的代码用了StringBuffer对象而不是String对象。这是出于效率的原因；当你是在某个可能会被多次调用的方法里装配一个字符串，更明智的做法是采用效率更高的StringBuffer而不是使用起来比较方便的String类型的那些操作。在这里，创建StringBuffger的时候给它一个初始值，然后把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 static char[] 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();}
}
} ///:~
为了使用generator对象填充一个数组的所有元素，fill（）方法使用一个合适的generator接口，这个接口的next（）方法以某种方式产生一个特定类型的对象（这取决于这个接口是如何实现的）。fill（）方法只是简单的调用next（）方法直到预期的范围都被填充。现在你就可以通过实现合适的接口自己来创建任意的generator并通过调用fill（）方法来使用你自己的generator。
随机数据发生器（Random data generators）对于测试来说是非常有用的，所有就有了一系列的内部类（inner classes）用来实现所有基本类型的generator接口，此外还有一个String发生器用以代表Object类型。你会看到随机字符串发生器（RandStringGenerator ）使用了随机字符发生器（RandCharGenerator）来填充一个字符数组，然后这个数组会被转换成一个String。数组的大小是由（RandStringGenerator ）的构造函数参数决定的。
如果需要产生的数字不是非常的大，RandIntGenerator 在默认情况下会以10,000为系数（modulus）产生随机数，但是重载的构造函数允许你选择更小的值作为系数。
目录
本文地址：http://com.8s8s.com/it/it12778.htm