Thinking in Java, 3rd ed. Revision 4.0

//: c11:ArraySize.java
// Initialisation & réassignation des tableaux.
import com.bruceeckel.simpletest.*;

class Weeble {} // Une petite créature mythique

public class ArraySize {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        // Tableaux d'objets :
        Weeble[] a; // variable locale non initialisée
        Weeble[] b = new Weeble[5]; // Référence Null
        Weeble[] c = new Weeble[4];
        for(int i = 0; i < c.length; i++)
            if(c[i] == null) // test pour les références null
                c[i] = new Weeble();
        // Initialisation par agrégat :
        Weeble[] d = {
            new Weeble(), new Weeble(), new Weeble()
        };
        // Initialisation dynamique par agrégat :
        a = new Weeble[] {
            new Weeble(), new Weeble()
        };
        System.out.println("a.length=" + a.length);
        System.out.println("b.length = " + b.length);
        // Les références à l'intérieur du tableau sont
        // automatiquement initialisées à null :
        for(int i = 0; i < b.length; i++)
            System.out.println("b[" + i + "]=" + b[i]);
        System.out.println("c.length = " + c.length);
        System.out.println("d.length = " + d.length);
        a = d;
        System.out.println("a.length = " + a.length);
        
        // tableau de types primitifs :
        int[] e; // Référence Null
        int[] f = new int[5];
        int[] g = new int[4];
        for(int i = 0; i < g.length; i++)
            g[i] = i*i;
        int[] h = { 11, 47, 93 };
        // Erreur de compilation : variable e non initialisée :
        //!System.out.println("e.length=" + e.length);
        System.out.println("f.length = " + f.length);
        // Les primitives dans le tableau sont
        // automatiquement initialisées à zéro :
        for(int i = 0; i < f.length; i++)
            System.out.println("f[" + i + "]=" + f[i]);
        System.out.println("g.length = " + g.length);
        System.out.println("h.length = " + h.length);
        e = h;
        System.out.println("e.length = " + e.length);
        e = new int[] { 1, 2 };
        System.out.println("e.length = " + e.length);
        monitor.expect(new String[] {
            "a.length=2",
            "b.length = 5",
            "b[0]=null",
            "b[1]=null",
            "b[2]=null",
            "b[3]=null",
            "b[4]=null",
            "c.length = 4",
            "d.length = 3",
            "a.length = 3",
            "f.length = 5",
            "f[0]=0",
            "f[1]=0",
            "f[2]=0",
            "f[3]=0",
            "f[4]=0",
            "g.length = 4",
            "h.length = 3",
            "e.length = 3",
            "e.length = 2"
        });
    }
} ///:~

hide(d);

hide(new Weeble[] { new Weeble(), new Weeble() });

a = d;

//: c11:IceCream.java
// Renvoyer un tableau depuis des méthodes.
import com.bruceeckel.simpletest.*;
import java.util.*;

public class IceCream {
    private static Test monitor = new Test();
    private static Random rand = new Random();
    public static final String[] flavors = {
        "Chocolate", "Strawberry", "Vanilla Fudge Swirl",
        "Mint Chip", "Mocha Almond Fudge", "Rum Raisin",
        "Praline Cream", "Mud Pie"
    };
    public static String[] flavorSet(int n) {
        String[] results = new String[n];
        boolean[] picked = new boolean[flavors.length];
        for(int i = 0; i < n; i++) {
            int t;
            do
                t = rand.nextInt(flavors.length);
            while(picked[t]);
            results[i] = flavors[t];
            picked[t] = true;
        }
        return results;
    }
    public static void main(String[] args) {
        for(int i = 0; i < 20; i++) {
            System.out.println(
                "flavorSet(" + i + ") = ");
            String[] fl = flavorSet(flavors.length);
            for(int j = 0; j < fl.length; j++)
                System.out.println("\t" + fl[j]);
            monitor.expect(new Object[] {
                "%% flavorSet\\(\\d+\\) = ",
                new TestExpression("%% \\t(Chocolate|Strawberry|"
                    + "Vanilla Fudge Swirl|Mint Chip|Mocha Almond "
                    + "Fudge|Rum Raisin|Praline Cream|Mud Pie)", 8)
            });
        }
    }
} ///:~

//: 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(); } ///:~

//: com:bruceeckel:util:Arrays2.java
// Un complément à java.util.Arrays, pour fournir
// de nouvelles fonctionnalités utiles lorsqu'on
// travaille avec des tableaux. Permet d'afficher
// n'importe quel tableau, et de le remplir via un
// objet « générateur » personnalisable.
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();}
    }
} ///:~

<![CDATA[
//: c11:TestArrays2.java
// Teste et illustre les utilitaires d'Arrays2.
import com.bruceeckel.util.*;

public class TestArrays2 {
    public static void main(String[] args) {
        int size = 6;
        // Ou récupère la taille depuis la ligne de commande :
        if(args.length != 0) {
            size = Integer.parseInt(args[0]);
            if(size &lt; 3) {
                System.out.println("arg must be &gt;= 3");
                System.exit(1);
            }
        }
        boolean[] a1 = new boolean[size];
        byte[] a2 = new byte[size];
        char[] a3 = new char[size];
        short[] a4 = new short[size];
        int[] a5 = new int[size];
        long[] a6 = new long[size];
        float[] a7 = new float[size];
        double[] a8 = new double[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));
    }
} ///:~

//: c11:FillingArrays.java
// Utilisation de Arrays.fill()
import com.bruceeckel.simpletest.*;
import com.bruceeckel.util.*;
import java.util.*;

public class FillingArrays {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        int size = 6;
        // Ou récupère la taille depuis la ligne de commande :
        if(args.length != 0)
            size = Integer.parseInt(args[0]);
        boolean[] a1 = new boolean[size];
        byte[] a2 = new byte[size];
        char[] a3 = new char[size];
        short[] a4 = new short[size];
        int[] a5 = new int[size];
        long[] a6 = new long[size];
        float[] a7 = new float[size];
        double[] a8 = new double[size];
        String[] a9 = new String[size];
        Arrays.fill(a1, true);
        System.out.println("a1 = " + Arrays2.toString(a1));
        Arrays.fill(a2, (byte)11);
        System.out.println("a2 = " + Arrays2.toString(a2));
        Arrays.fill(a3, 'x');
        System.out.println("a3 = " + Arrays2.toString(a3));
        Arrays.fill(a4, (short)17);
        System.out.println("a4 = " + Arrays2.toString(a4));
        Arrays.fill(a5, 19);
        System.out.println("a5 = " + Arrays2.toString(a5));
        Arrays.fill(a6, 23);
        System.out.println("a6 = " + Arrays2.toString(a6));
        Arrays.fill(a7, 29);
        System.out.println("a7 = " + Arrays2.toString(a7));
        Arrays.fill(a8, 47);
        System.out.println("a8 = " + Arrays2.toString(a8));
        Arrays.fill(a9, "Hello");
        System.out.println("a9 = " + Arrays.asList(a9));
        // Manipulation de plages d'index :
        Arrays.fill(a9, 3, 5, "World");
        System.out.println("a9 = " + Arrays.asList(a9));
        monitor.expect(new String[] {
            "a1 = [true, true, true, true, true, true]",
            "a2 = [11, 11, 11, 11, 11, 11]",
            "a3 = [x, x, x, x, x, x]",
            "a4 = [17, 17, 17, 17, 17, 17]",
            "a5 = [19, 19, 19, 19, 19, 19]",
            "a6 = [23, 23, 23, 23, 23, 23]",
            "a7 = [29.0, 29.0, 29.0, 29.0, 29.0, 29.0]",
            "a8 = [47.0, 47.0, 47.0, 47.0, 47.0, 47.0]",
            "a9 = [Hello, Hello, Hello, Hello, Hello, Hello]",
            "a9 = [Hello, Hello, Hello, World, World, Hello]"
        });
    }
} ///:~

//: c11:CopyingArrays.java
// Utilisation de System.arraycopy()
import com.bruceeckel.simpletest.*;
import com.bruceeckel.util.*;
import java.util.*;

public class CopyingArrays {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        int[] i = new int[7];
        int[] j = new int[10];
        Arrays.fill(i, 47);
        Arrays.fill(j, 99);
        System.out.println("i = " + Arrays2.toString(i));
        System.out.println("j = " + Arrays2.toString(j));
        System.arraycopy(i, 0, j, 0, i.length);
        System.out.println("j = " + Arrays2.toString(j));
        int[] k = new int[5];
        Arrays.fill(k, 103);
        System.arraycopy(i, 0, k, 0, k.length);
        System.out.println("k = " + Arrays2.toString(k));
        Arrays.fill(k, 103);
        System.arraycopy(k, 0, i, 0, k.length);
        System.out.println("i = " + Arrays2.toString(i));
        // Objects:
        Integer[] u = new Integer[10];
        Integer[] v = new Integer[5];
        Arrays.fill(u, new Integer(47));
        Arrays.fill(v, new Integer(99));
        System.out.println("u = " + Arrays.asList(u));
        System.out.println("v = " + Arrays.asList(v));
        System.arraycopy(v, 0, u, u.length/2, v.length);
        System.out.println("u = " + Arrays.asList(u));
        monitor.expect(new String[] {
            "i = [47, 47, 47, 47, 47, 47, 47]",
            "j = [99, 99, 99, 99, 99, 99, 99, 99, 99, 99]",
            "j = [47, 47, 47, 47, 47, 47, 47, 99, 99, 99]",
            "k = [47, 47, 47, 47, 47]",
            "i = [103, 103, 103, 103, 103, 47, 47]",
            "u = [47, 47, 47, 47, 47, 47, 47, 47, 47, 47]",
            "v = [99, 99, 99, 99, 99]",
            "u = [47, 47, 47, 47, 47, 99, 99, 99, 99, 99]"
        });
    }
} ///:~

//: c11:ComparingArrays.java
// Utilisation de Arrays.equals()
import com.bruceeckel.simpletest.*;
import java.util.*;

public class ComparingArrays {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        int[] a1 = new int[10];
        int[] a2 = new int[10];
        Arrays.fill(a1, 47);
        Arrays.fill(a2, 47);
        System.out.println(Arrays.equals(a1, a2));
        a2[3] = 11;
        System.out.println(Arrays.equals(a1, a2));
        String[] s1 = new String[5];
        Arrays.fill(s1, "Hi");
        String[] s2 = {"Hi", "Hi", "Hi", "Hi", "Hi"};
        System.out.println(Arrays.equals(s1, s2));
        monitor.expect(new String[] {
            "true",
            "false",
            "true"
        });
    }
} ///:~

//: c11:CompType.java
// Implémenter Comparable dans une classe.
import com.bruceeckel.util.*;
import java.util.*;

public class CompType implements Comparable {
    int i;
    int j;
    public CompType(int n1, int n2) {
        i = n1;
        j = n2;
    }
    public String toString() {
        return "[i = " + i + ", j = " + j + "]";
    }
    public int compareTo(Object rv) {
        int rvi = ((CompType)rv).i;
        return (i < rvi ? -1 : (i == rvi ? 0 : 1));
    }
    private static Random r = new Random();
    public static Generator generator() {
        return new Generator() {
            public Object next() {
                return new CompType(r.nextInt(100),r.nextInt(100));
            }
        };
    }
    public static void main(String[] args) {
        CompType[] a = new CompType[10];
        Arrays2.fill(a, generator());
        System.out.println(
            "avant tri, a = " + Arrays.asList(a));
        Arrays.sort(a);
        System.out.println(
            "après tri, a = " + Arrays.asList(a));
      }
} ///:~

//: c11:Reverse.java
// Le Comparator Collecions.reverseOrder().
import com.bruceeckel.util.*;
import java.util.*;

public class Reverse {
    public static void main(String[] args) {
        CompType[] a = new CompType[10];
        Arrays2.fill(a, CompType.generator());
        System.out.println(
            "avant le tri, a = " + Arrays.asList(a));
        Arrays.sort(a, Collections.reverseOrder());
        System.out.println(
            "après le tri, a = " + Arrays.asList(a));
    }
} ///:~

//: c11:ComparatorTest.java
// Implémenter un Comparator pour une classe.
import com.bruceeckel.util.*;
import java.util.*;

class CompTypeComparator implements Comparator {
    public int compare(Object o1, Object o2) {
        int j1 = ((CompType)o1).j;
        int j2 = ((CompType)o2).j;
        return (j1 < j2 ? -1 : (j1 == j2 ? 0 : 1));
    }
}

public class ComparatorTest {
    public static void main(String[] args) {
        CompType[] a = new CompType[10];
        Arrays2.fill(a, CompType.generator());
        System.out.println(
            "avant le tri, a = " + Arrays.asList(a));
        Arrays.sort(a, new CompTypeComparator());
        System.out.println(
            "après le tri, a = " + Arrays.asList(a));
    }
} ///:~

//: c11:StringSorting.java
// Trier un tableau de Strings.
import com.bruceeckel.util.*;
import java.util.*;

public class StringSorting {
    public static void main(String[] args) {
        String[] sa = new String[30];
        Arrays2.fill(sa, new Arrays2.RandStringGenerator(5));
        System.out.println(
            "Before sorting: " + Arrays.asList(sa));
        Arrays.sort(sa);
        System.out.println(
            "After sorting: " + Arrays.asList(sa));
    }
} ///:~

//: com:bruceeckel:util:AlphabeticComparator.java
// Garder les lettres majuscules et minuscules ensemble.
package com.bruceeckel.util;
import java.util.*;

public class AlphabeticComparator implements Comparator {
    public int compare(Object o1, Object o2) {
        String s1 = (String)o1;
        String s2 = (String)o2;
        return s1.toLowerCase().compareTo(s2.toLowerCase());
    }
} ///:~

//: c11:AlphabeticSorting.java
// Garder les lettres majuscules et minuscules ensemble.
import com.bruceeckel.util.*;
import java.util.*;

public class AlphabeticSorting {
    public static void main(String[] args) {
        String[] sa = new String[30];
        Arrays2.fill(sa, new Arrays2.RandStringGenerator(5));
        System.out.println(
            "Before sorting: " + Arrays.asList(sa));
        Arrays.sort(sa, new AlphabeticComparator());
        System.out.println(
            "After sorting: " + Arrays.asList(sa));
    }
} ///:~

//: c11:ArraySearching.java
// Utilisation de Arrays.binarySearch().
import com.bruceeckel.util.*;
import java.util.*;

public class ArraySearching {
    public static void main(String[] args) {
        int[] a = new int[100];
        Arrays2.RandIntGenerator gen =
            new Arrays2.RandIntGenerator(1000);
        Arrays2.fill(a, gen);
        Arrays.sort(a);
        System.out.println(
            "Sorted array: " + Arrays2.toString(a));
        while(true) {
            int r = gen.next();
            int location = Arrays.binarySearch(a, r);
            if(location >= 0) {
                System.out.println("Location of " + r +
                    " is " + location + ", a[" +
                    location + "] = " + a[location]);
                break; // Sortie de la boucle while
            }
        }
    }
} ///:~

-(insertion point) - 1

//: c11:AlphabeticSearch.java
// Rechercher avec un Comparator.
import com.bruceeckel.simpletest.*;
import com.bruceeckel.util.*;
import java.util.*;

public class AlphabeticSearch {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        String[] sa = new String[30];
        Arrays2.fill(sa, new Arrays2.RandStringGenerator(5));
        AlphabeticComparator comp = new AlphabeticComparator();
        Arrays.sort(sa, comp);
        int index = Arrays.binarySearch(sa, sa[10], comp);
        System.out.println("Index = " + index);
        monitor.expect(new String[] {
            "Index = 10"
        });
    }
} ///:~

//: c11:PrintingContainers.java
// Containers print themselves automatically.
import com.bruceeckel.simpletest.*;
import java.util.*;

public class PrintingContainers {
    private static Test monitor = new Test();
    static Collection fill(Collection c) {
        c.add("dog");
        c.add("dog");
        c.add("cat");
        return c;
    }
    static Map fill(Map m) {
        m.put("dog", "Bosco");
        m.put("dog", "Spot");
        m.put("cat", "Rags");
        return m;
    }
    public static void main(String[] args) {
        System.out.println(fill(new ArrayList()));
        System.out.println(fill(new HashSet()));
        System.out.println(fill(new HashMap()));
        monitor.expect(new String[] {
            "[dog, dog, cat]",
            "[dog, cat]",
            "{dog=Spot, cat=Rags}"
        });
    }
} ///:~

//: c11:FillingLists.java
// La méthode Collections.fill()
import com.bruceeckel.simpletest.*;
import java.util.*;

public class FillingLists {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        List list = new ArrayList();
        for(int i = 0; i < 10; i++)
            list.add("");
        Collections.fill(list, "Hello");
        System.out.println(list);
        monitor.expect(new String[] {
            "[Hello, Hello, Hello, Hello, Hello, " +
                "Hello, Hello, Hello, Hello, Hello]"
        });
    }
} ///:~

//: com:bruceeckel:util:Pair.java
package com.bruceeckel.util;

public class Pair {
    public Object key, value;
    public Pair(Object k, Object v) {
        key = k;
        value = v;
    }
} ///:~

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

//: com:bruceeckel:util:Collections2.java
// Remplir n'importe quel type de conteneur en utilisant un objet générateur.
package com.bruceeckel.util;
import java.util.*;

public class Collections2 {
    // Fill an array using a generator:
    public static void
    fill(Collection c, Generator gen, int count) {
        for(int i = 0; i < count; i++)
            c.add(gen.next());
    }
    public static void
    fill(Map m, MapGenerator gen, int count) {
        for(int i = 0; i < count; i++) {
            Pair p = gen.next();
            m.put(p.key, p.value);
        }
    }
    public static class
    RandStringPairGenerator implements MapGenerator {
        private Arrays2.RandStringGenerator gen;
        public RandStringPairGenerator(int len) {
            gen = new Arrays2.RandStringGenerator(len);
        }
        public Pair next() {
            return new Pair(gen.next(), gen.next());
        }
    }
    // Objet par défaut afin de ne pas avoir à créer le votre
    public static RandStringPairGenerator rsp =
        new RandStringPairGenerator(10);
    public static class
    StringPairGenerator implements MapGenerator {
        private int index = -1;
        private String[][] d;
        public StringPairGenerator(String[][] data) {
            d = data;
        }
        public Pair next() {
            // Force l'index dans la plage de valeurs :
            index = (index + 1) % d.length;
            return new Pair(d[index][0], d[index][1]);
        }
        public StringPairGenerator reset() {
            index = -1;
            return this;
        }
    }
    // Utilisation d'un ensemble de données prédéfinies :
    public static StringPairGenerator geography =
        new StringPairGenerator(CountryCapitals.pairs);
    // Produit une séquence à partir d'un tableau 2D :
    public static class StringGenerator implements Generator{
        private String[][] d;
        private int position;
        private int index = -1;
        public StringGenerator(String[][] data, int pos) {
            d = data;
            position = pos;
        }
        public Object next() {
            // Force l'index dans la plage de valeurs :
            index = (index + 1) % d.length;
            return d[index][position];
        }
        public StringGenerator reset() {
            index = -1;
            return this;
        }
    }
    // Utilisation d'un ensemble de données prédéfinies :
    public static StringGenerator countries =
        new StringGenerator(CountryCapitals.pairs, 0);
    public static StringGenerator capitals =
        new StringGenerator(CountryCapitals.pairs, 1);
} ///:~

//: com:bruceeckel:util:CountryCapitals.java
package com.bruceeckel.util;

public class CountryCapitals {
    public static final String[][] pairs = {
        // Afrique
        {"ALGERIA","Algiers"}, {"ANGOLA","Luanda"},
        {"BENIN","Porto-Novo"}, {"BOTSWANA","Gaberone"},
        {"BURKINA FASO","Ouagadougou"},
        {"BURUNDI","Bujumbura"},
        {"CAMEROON","Yaounde"}, {"CAPE VERDE","Praia"},
        {"CENTRAL AFRICAN REPUBLIC","Bangui"},
        {"CHAD","N'djamena"},  {"COMOROS","Moroni"},
        {"CONGO","Brazzaville"}, {"DJIBOUTI","Dijibouti"},
        {"EGYPT","Cairo"}, {"EQUATORIAL GUINEA","Malabo"},
        {"ERITREA","Asmara"}, {"ETHIOPIA","Addis Ababa"},
        {"GABON","Libreville"}, {"THE GAMBIA","Banjul"},
        {"GHANA","Accra"}, {"GUINEA","Conakry"},
        {"GUINEA","-"}, {"BISSAU","Bissau"},
        {"COTE D'IVOIR (IVORY COAST)","Yamoussoukro"},
        {"KENYA","Nairobi"}, {"LESOTHO","Maseru"},
        {"LIBERIA","Monrovia"}, {"LIBYA","Tripoli"},
        {"MADAGASCAR","Antananarivo"}, {"MALAWI","Lilongwe"},
        {"MALI","Bamako"}, {"MAURITANIA","Nouakchott"},
        {"MAURITIUS","Port Louis"}, {"MOROCCO","Rabat"},
        {"MOZAMBIQUE","Maputo"}, {"NAMIBIA","Windhoek"},
        {"NIGER","Niamey"}, {"NIGERIA","Abuja"},
        {"RWANDA","Kigali"},
        {"SAO TOME E PRINCIPE","Sao Tome"},
        {"SENEGAL","Dakar"}, {"SEYCHELLES","Victoria"},
        {"SIERRA LEONE","Freetown"}, {"SOMALIA","Mogadishu"},
        {"SOUTH AFRICA","Pretoria/Cape Town"},
        {"SUDAN","Khartoum"},
        {"SWAZILAND","Mbabane"}, {"TANZANIA","Dodoma"},
        {"TOGO","Lome"}, {"TUNISIA","Tunis"},
        {"UGANDA","Kampala"},
        {"DEMOCRATIC REPUBLIC OF THE CONGO (ZAIRE)",
         "Kinshasa"},
        {"ZAMBIA","Lusaka"}, {"ZIMBABWE","Harare"},
        // Asie
        {"AFGHANISTAN","Kabul"}, {"BAHRAIN","Manama"},
        {"BANGLADESH","Dhaka"}, {"BHUTAN","Thimphu"},
        {"BRUNEI","Bandar Seri Begawan"},
        {"CAMBODIA","Phnom Penh"},
        {"CHINA","Beijing"}, {"CYPRUS","Nicosia"},
        {"INDIA","New Delhi"}, {"INDONESIA","Jakarta"},
        {"IRAN","Tehran"}, {"IRAQ","Baghdad"},
        {"ISRAEL","Tel Aviv"}, {"JAPAN","Tokyo"},
        {"JORDAN","Amman"}, {"KUWAIT","Kuwait City"},
        {"LAOS","Vientiane"}, {"LEBANON","Beirut"},
        {"MALAYSIA","Kuala Lumpur"}, {"THE MALDIVES","Male"},
        {"MONGOLIA","Ulan Bator"},
        {"MYANMAR (BURMA)","Rangoon"},
        {"NEPAL","Katmandu"}, {"NORTH KOREA","P'yongyang"},
        {"OMAN","Muscat"}, {"PAKISTAN","Islamabad"},
        {"PHILIPPINES","Manila"}, {"QATAR","Doha"},
        {"SAUDI ARABIA","Riyadh"}, {"SINGAPORE","Singapore"},
        {"SOUTH KOREA","Seoul"}, {"SRI LANKA","Colombo"},
        {"SYRIA","Damascus"},
        {"TAIWAN (REPUBLIC OF CHINA)","Taipei"},
        {"THAILAND","Bangkok"}, {"TURKEY","Ankara"},
        {"UNITED ARAB EMIRATES","Abu Dhabi"},
        {"VIETNAM","Hanoi"}, {"YEMEN","Sana'a"},
        // Australie et Océanie
        {"AUSTRALIA","Canberra"}, {"FIJI","Suva"},
        {"KIRIBATI","Bairiki"},
        {"MARSHALL ISLANDS","Dalap-Uliga-Darrit"},
        {"MICRONESIA","Palikir"}, {"NAURU","Yaren"},
        {"NEW ZEALAND","Wellington"}, {"PALAU","Koror"},
        {"PAPUA NEW GUINEA","Port Moresby"},
        {"SOLOMON ISLANDS","Honaira"}, {"TONGA","Nuku'alofa"},
        {"TUVALU","Fongafale"}, {"VANUATU","< Port-Vila"},
        {"WESTERN SAMOA","Apia"},
        // Europe de l'Est et ancienne URSS
        {"ARMENIA","Yerevan"}, {"AZERBAIJAN","Baku"},
        {"BELARUS (BYELORUSSIA)","Minsk"},
        {"GEORGIA","Tbilisi"},
        {"KAZAKSTAN","Almaty"}, {"KYRGYZSTAN","Alma-Ata"},
        {"MOLDOVA","Chisinau"}, {"RUSSIA","Moscow"},
        {"TAJIKISTAN","Dushanbe"}, {"TURKMENISTAN","Ashkabad"},
        {"UKRAINE","Kyiv"}, {"UZBEKISTAN","Tashkent"},
        // Europe
        {"ALBANIA","Tirana"}, {"ANDORRA","Andorra la Vella"},
        {"AUSTRIA","Vienna"}, {"BELGIUM","Brussels"},
        {"BOSNIA","-"}, {"HERZEGOVINA","Sarajevo"},
        {"CROATIA","Zagreb"}, {"CZECH REPUBLIC","Prague"},
        {"DENMARK","Copenhagen"}, {"ESTONIA","Tallinn"},
        {"FINLAND","Helsinki"}, {"FRANCE","Paris"},
        {"GERMANY","Berlin"}, {"GREECE","Athens"},
        {"HUNGARY","Budapest"}, {"ICELAND","Reykjavik"},
        {"IRELAND","Dublin"}, {"ITALY","Rome"},
        {"LATVIA","Riga"}, {"LIECHTENSTEIN","Vaduz"},
        {"LITHUANIA","Vilnius"}, {"LUXEMBOURG","Luxembourg"},
        {"MACEDONIA","Skopje"}, {"MALTA","Valletta"},
        {"MONACO","Monaco"}, {"MONTENEGRO","Podgorica"},
        {"THE NETHERLANDS","Amsterdam"}, {"NORWAY","Oslo"},
        {"POLAND","Warsaw"}, {"PORTUGAL","Lisbon"},
        {"ROMANIA","Bucharest"}, {"SAN MARINO","San Marino"},
        {"SERBIA","Belgrade"}, {"SLOVAKIA","Bratislava"},
        {"SLOVENIA","Ljujiana"}, {"SPAIN","Madrid"},
        {"SWEDEN","Stockholm"}, {"SWITZERLAND","Berne"},
        {"UNITED KINGDOM","London"}, {"VATICAN CITY","---"},
        // Amérique du Nord et Amérique Centrale
        {"ANTIGUA AND BARBUDA","Saint John's"},
        {"BAHAMAS","Nassau"},
        {"BARBADOS","Bridgetown"}, {"BELIZE","Belmopan"},
        {"CANADA","Ottawa"}, {"COSTA RICA","San Jose"},
        {"CUBA","Havana"}, {"DOMINICA","Roseau"},
        {"DOMINICAN REPUBLIC","Santo Domingo"},
        {"EL SALVADOR","San Salvador"},
        {"GRENADA","Saint George's"},
        {"GUATEMALA","Guatemala City"},
        {"HAITI","Port-au-Prince"},
        {"HONDURAS","Tegucigalpa"}, {"JAMAICA","Kingston"},
        {"MEXICO","Mexico City"}, {"NICARAGUA","Managua"},
        {"PANAMA","Panama City"}, {"ST. KITTS","-"},
        {"NEVIS","Basseterre"}, {"ST. LUCIA","Castries"},
        {"ST. VINCENT AND THE GRENADINES","Kingstown"},
        {"UNITED STATES OF AMERICA","Washington, D.C."},
        // Amérique du Sud
        {"ARGENTINA","Buenos Aires"},
        {"BOLIVIA","Sucre (legal)/La Paz(administrative)"},
        {"BRAZIL","Brasilia"}, {"CHILE","Santiago"},
        {"COLOMBIA","Bogota"}, {"ECUADOR","Quito"},
        {"GUYANA","Georgetown"}, {"PARAGUAY","Asuncion"},
        {"PERU","Lima"}, {"SURINAME","Paramaribo"},
        {"TRINIDAD AND TOBAGO","Port of Spain"},
        {"URUGUAY","Montevideo"}, {"VENEZUELA","Caracas"},
    };
} ///:~

//: c11:FillTest.java
import com.bruceeckel.util.*;
import java.util.*;

public class FillTest {
    private static Generator sg =
        new Arrays2.RandStringGenerator(7);
    public static void main(String[] args) {
        List list = new ArrayList();
        Collections2.fill(list, sg, 25);
        System.out.println(list + "\n");
        List list2 = new ArrayList();
        Collections2.fill(list2, Collections2.capitals, 25);
        System.out.println(list2 + "\n");
        Set set = new HashSet();
        Collections2.fill(set, sg, 25);
        System.out.println(set + "\n");
        Map m = new HashMap();
        Collections2.fill(m, Collections2.rsp, 25);
        System.out.println(m + "\n");
        Map m2 = new HashMap();
        Collections2.fill(m2, Collections2.geography, 25);
        System.out.println(m2);
    }
} ///:~

//: c11:Mouse.java
// Redéfinition de toString().

public class Mouse {
    private int mouseNumber;
    public Mouse(int i) { mouseNumber = i; }
    // Surcharge de Object.toString():
    public String toString() {
        return "This is Mouse #" + mouseNumber;
    }
    public int getNumber() { return mouseNumber; }
} ///:~

//: c11:MouseTrap.java

public class MouseTrap {
    static void caughtYa(Object m) {
        Mouse mouse = (Mouse)m; // Transtypage depuis un Object
        System.out.println("Mouse: " + mouse.getNumber());
    }
} ///:~

//: c11:WorksAnyway.java
// Dans certains cas spéciaux, les choses semblent fonctionner correctement.
import com.bruceeckel.simpletest.*;
import java.util.*;

public class WorksAnyway {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        List mice = new ArrayList();
        for(int i = 0; i < 3; i++)
            mice.add(new Mouse(i));
        for(int i = 0; i < mice.size(); i++) {
            // Aucun transtypage nécessaire, appel
            // automatique à Object.toString() :
            System.out.println("Free mouse: " + mice.get(i));
            MouseTrap.caughtYa(mice.get(i));
        }
        monitor.expect(new String[] {
            "Free mouse: This is Mouse #0",
            "Mouse: 0",
            "Free mouse: This is Mouse #1",
            "Mouse: 1",
            "Free mouse: This is Mouse #2",
            "Mouse: 2"
        });
    }
} ///:~

System.out.println("Free mouse: " + mice.get(i));

MouseTrap.caughtYa(mice.get(i));

//: c11:MouseList.java
// Une ArrayList consciente du type.
import java.util.*;

public class MouseList {
    private List list = new ArrayList();
    public void add(Mouse m) { list.add(m); }
    public Mouse get(int index) {
        return (Mouse)list.get(index);
    }
    public int size() { return list.size(); }
} ///:~

//: c11:MouseListTest.java
import com.bruceeckel.simpletest.*;

public class MouseListTest {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        MouseList mice = new MouseList();
        for(int i = 0; i < 3; i++)
            mice.add(new Mouse(i));
        for(int i = 0; i < mice.size(); i++)
            MouseTrap.caughtYa(mice.get(i));
        monitor.expect(new String[] {
            "Mouse: 0",
            "Mouse: 1",
            "Mouse: 2"
        });
    }
} ///:~

mice.add(new Pigeon());

//: c11:InfiniteRecursion.java
// Recursion accidentelle
import java.util.*;

public class InfiniteRecursion {
    public String toString() {
        return " InfiniteRecursion address: " + this + "\n";
    }
    public static void main(String[] args) {
        List v = new ArrayList();
        for(int i = 0; i < 10; i++)
            v.add(new InfiniteRecursion());
        System.out.println(v);
    }
} ///:~

"InfiniteRecursion address: " + this

//: c11:StackL.java
// Réaliser une pile à partir d'une LinkedList.
import com.bruceeckel.simpletest.*;
import java.util.*;
import com.bruceeckel.util.*;

public class StackL {
    private static Test monitor = new Test();
    private LinkedList list = new LinkedList();
    public void push(Object v) { list.addFirst(v); }
    public Object top() { return list.getFirst(); }
    public Object pop() { return list.removeFirst(); }
    public static void main(String[] args) {
        StackL stack = new StackL();
        for(int i = 0; i < 10; i++)
            stack.push(Collections2.countries.next());
        System.out.println(stack.top());
        System.out.println(stack.top());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        monitor.expect(new String[] {
            "CHAD",
            "CHAD",
            "CHAD",
            "CENTRAL AFRICAN REPUBLIC",
            "CAPE VERDE"
        });
    }
} ///:~

//: c11:Queue.java
// Réaliser une file à partir d'une LinkedList.
import com.bruceeckel.simpletest.*;
import java.util.*;

public class Queue {
    private static Test monitor = new Test();
    private LinkedList list = new LinkedList();
    public void put(Object v) { list.addFirst(v); }
    public Object get() { return list.removeLast(); }
    public boolean isEmpty() { return list.isEmpty(); }
    public static void main(String[] args) {
        Queue queue = new Queue();
        for(int i = 0; i < 10; i++)
            queue.put(Integer.toString(i));
        while(!queue.isEmpty())
            System.out.println(queue.get());
        monitor.expect(new String[] {
            "0",
            "1",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9"
        });
    }
} ///:~

//: c11:SortedSetDemo.java
// Ce qui vous pouvez faire avec un TreeSet
import com.bruceeckel.simpletest.*;
import java.util.*;

public class SortedSetDemo {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        SortedSet sortedSet = new TreeSet(Arrays.asList(
        "one two three four five six seven eight".split(" ")));
        System.out.println(sortedSet);
        Object
            low = sortedSet.first(),
            high = sortedSet.last();
        System.out.println(low);
        System.out.println(high);
        Iterator it = sortedSet.iterator();
        for(int i = 0; i <= 6; i++) {
            if(i == 3) low = it.next();
            if(i == 6) high = it.next();
            else it.next();
        }
        System.out.println(low);
        System.out.println(high);
        System.out.println(sortedSet.subSet(low, high));
        System.out.println(sortedSet.headSet(high));
        System.out.println(sortedSet.tailSet(low));
        monitor.expect(new String[] {
            "[eight, five, four, one, seven, six, three, two]",
            "eight",
            "two",
            "one",
            "two",
            "[one, seven, six, three]",
            "[eight, five, four, one, seven, six, three]",
            "[one, seven, six, three, two]"
        });
    }
} ///:~

//: c11:SimplePairGenerator.java
import com.bruceeckel.util.*;
//import java.util.*;

public class SimplePairGenerator implements MapGenerator {
    public Pair[] items = {
        new Pair("one", "A"), new Pair("two", "B"),
        new Pair("three", "C"), new Pair("four", "D"),
        new Pair("five", "E"), new Pair("six", "F"),
        new Pair("seven", "G"), new Pair("eight", "H"),
        new Pair("nine", "I"), new Pair("ten", "J")
    };
    private int index = -1;
    public Pair next() {
        index = (index + 1) % items.length;
        return items[index];
    }
    public static SimplePairGenerator gen =
        new SimplePairGenerator();
} ///:~

//: c11:SortedMapDemo.java
// Ce que vous pouvez faire avec une TreeMap.
import com.bruceeckel.simpletest.*;
import com.bruceeckel.util.*;
import java.util.*;

public class SortedMapDemo {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        TreeMap sortedMap = new TreeMap();
        Collections2.fill(
            sortedMap, SimplePairGenerator.gen, 10);
        System.out.println(sortedMap);
        Object
            low = sortedMap.firstKey(),
            high = sortedMap.lastKey();
        System.out.println(low);
        System.out.println(high);
        Iterator it = sortedMap.keySet().iterator();
        for(int i = 0; i <= 6; i++) {
            if(i == 3) low = it.next();
            if(i == 6) high = it.next();
            else it.next();
        }
        System.out.println(low);
        System.out.println(high);
        System.out.println(sortedMap.subMap(low, high));
        System.out.println(sortedMap.headMap(high));
        System.out.println(sortedMap.tailMap(low));
        monitor.expect(new String[] {
            "{eight=H, five=E, four=D, nine=I, one=A, seven=G," +
            " six=F, ten=J, three=C, two=B}",
            "eight",
            "two",
            "nine",
            "ten",
            "{nine=I, one=A, seven=G, six=F}",
            "{eight=H, five=E, four=D, nine=I, " +
            "one=A, seven=G, six=F}",
            "{nine=I, one=A, seven=G, six=F, " +
            "ten=J, three=C, two=B}"
        });
    }
} ///:~

//: c11:LinkedHashMapDemo.java
// Ce que vous pouvez faire avec une LinkedHashMap.
import com.bruceeckel.simpletest.*;
import com.bruceeckel.util.*;
import java.util.*;

public class LinkedHashMapDemo {
    private static Test monitor = new Test();
    public static void main(String[] args) {
        LinkedHashMap linkedMap = new LinkedHashMap();
        Collections2.fill(
            linkedMap, SimplePairGenerator.gen, 10);
        System.out.println(linkedMap);
        // Ordre le moins récent d'utilisation 
        linkedMap = new LinkedHashMap(16, 0.75f, true);
        Collections2.fill(
            linkedMap, SimplePairGenerator.gen, 10);
        System.out.println(linkedMap);
        for(int i = 0; i < 7; i++) // accès
            linkedMap.get(SimplePairGenerator.gen.items[i].key);
        System.out.println(linkedMap);
        linkedMap.get(SimplePairGenerator.gen.items[0].key);
        System.out.println(linkedMap);
        monitor.expect(new String[] {
            "{one=À, two=B, three=C, four=D, five=E, " +
            "six=F, seven=G, eight=H, nine=I, ten=J}",
            "{one=A, two=B, three=C, four=D, five=E, " +
            "six=F, seven=G, eight=H, nine=I, ten=J}",
            "{eight=H, nine=I, ten=J, one=A, two=B, " +
            "three=C, four=D, five=E, six=F, seven=G}",
            "{eight=H, nine=I, ten=J, two=B, three=C, " +
            "four=D, five=E, six=F, seven=G, one=A}"
        });
    }
} ///:~

//: c11:Groundhog.java
// Looks plausible, but doesn't work as a HashMap key.

public class Groundhog {
    protected int number;
    public Groundhog(int n) { number = n; }
    public String toString() {
        return "Groundhog #" + number;
    }
} ///:~

//: c11:Prediction.java
// Predicting the weather with groundhogs.

public class Prediction {
    private boolean shadow = Math.random() > 0.5;
    public String toString() {
        if(shadow)
            return "Six more weeks of Winter!";
        else
            return "Early Spring!";
    }
} ///:~

//: c11:SpringDetector.java
// What will the weather be?
import com.bruceeckel.simpletest.*;
import java.util.*;
import java.lang.reflect.*;

public class SpringDetector {
    private static Test monitor = new Test();
    // Uses a Groundhog or class derived from Groundhog:
    public static void
    detectSpring(Class groundHogClass) throws Exception {
        Constructor ghog = groundHogClass.getConstructor(
            new Class[] {int.class});
        Map map = new HashMap();
        for(int i = 0; i < 10; i++)
            map.put(ghog.newInstance(
                new Object[]{ new Integer(i) }), new Prediction());
        System.out.println("map = " + map + "\n");
        Groundhog gh = (Groundhog)
            ghog.newInstance(new Object[]{ new Integer(3) });
        System.out.println("Looking up prediction for " + gh);
        if(map.containsKey(gh))
            System.out.println((Prediction)map.get(gh));
        else
            System.out.println("Key not found: " + gh);
    }
    public static void main(String[] args) throws Exception {
        detectSpring(Groundhog.class);
        monitor.expect(new String[] {
            "%% map = \\{(Groundhog #\\d=" +
            "(Early Spring!|Six more weeks of Winter!)" +
            "(, )?){10}\\}",
            "",
            "Looking up prediction for Groundhog #3",
            "Key not found: Groundhog #3"
        });
    }
} ///:~

//: c11:Groundhog2.java
// A class that's used as a key in a HashMap
// must override hashCode() and equals().

public class Groundhog2 extends Groundhog {
    public Groundhog2(int n) { super(n); }
    public int hashCode() { return number; }
    public boolean equals(Object o) {
        return (o instanceof Groundhog2)
            && (number == ((Groundhog2)o).number);
    }
} ///:~

//: c11:SpringDetector2.java
// A working key.
import com.bruceeckel.simpletest.*;
import java.util.*;

public class SpringDetector2 {
    private static Test monitor = new Test();
    public static void main(String[] args) throws Exception {
        SpringDetector.detectSpring(Groundhog2.class);
        monitor.expect(new String[] {
            "%% map = \\{(Groundhog #\\d=" +
            "(Early Spring!|Six more weeks of Winter!)" +
            "(, )?){10}\\}",
            "",
            "Looking up prediction for Groundhog #3",
            "%% Early Spring!|Six more weeks of Winter!"
        });
    }
} ///:~