对象的容纳

生成能自动判别类型的Vector：

import java.util.*;
class Gopher {
    private int gopherNumber;
    Gopher(int i) {
        gopherNumber = i;
    }
    void print(String msg) {
        if(msg != null) 
            System.out.println(msg);
        System.out.println("Gopher number " + gopherNumber);
    }
}
class GopherTrap {
    static void caughtYa(Gopher g) {
        g.print("Caught one!");
    }
}
public class test {
    private Vector v = new Vector();
    public void addElement(Gopher m) {
        v.addElement(m);
    }
    public Gopher elementAt(int index) {
        return (Gopher)v.elementAt(index);
    }
    public int size() {
        return v.size(); 
    }
    public static void main(String[] args) {
        test gophers = new test();
        for(int i = 0; i < 3; i++)
            gophers.addElement(new Gopher(i));
        for(int i = 0; i < gophers.size(); i++)
            GopherTrap.caughtYa(gophers.elementAt(i));
    }
}

下面的代码，因为在调用toString()方法的时候，其中的this那块会调用this.toString()。所以这段代码会无穷递归下去，然后导致Java崩溃。

import java.util.Vector;

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

BitSet的用法，要注意BitSet扩展的情况（初始化为64位）：

import java.util.*;
public class test {
    public static void main(String[] args) {
        Random rand = new Random();
        //     Take the LSB of nextInt():
        byte bt = (byte)rand.nextInt();
        BitSet bb = new BitSet();
        for(int i = 7; i >=0; i--)
            if(((1 << i) & bt) != 0)
                bb.set(i);
            else
                bb.clear(i);
        System.out.println("byte value: " + bt);
        printBitSet(bb);
        short st = (short)rand.nextInt();
        BitSet bs = new BitSet();
        for(int i = 15; i >=0; i--)
            if(((1 << i) & st) != 0)
                bs.set(i);
            else
                bs.clear(i);
        System.out.println("short value: " + st);
        printBitSet(bs);
        int it = rand.nextInt();
        BitSet bi = new BitSet();
        for(int i = 31; i >=0; i--)
            if(((1 << i) & it) != 0)
                bi.set(i);
            else
                bi.clear(i);
        System.out.println("int value: " + it);
        printBitSet(bi);
        //     Test bitsets >= 64 bits:
        BitSet b127 = new BitSet();
        b127.set(127);
        System.out.println("set bit 127: " + b127);
        BitSet b255 = new BitSet(65);
        b255.set(255);
        System.out.println("set bit 255: " + b255);
        BitSet b1023 = new BitSet(512);
        //     Without the following, an exception is thrown
        // in the Java 1.0 implementation of BitSet:
        // b1023.set(1023);
        b1023.set(1024);
        System.out.println("set bit 1023: " + b1023);
    }
    static void printBitSet(BitSet b) {
        System.out.println("bits: " + b);
        String bbits = new String();
        for(int j = 0; j < b.size() ; j++)
            bbits += (b.get(j) ? "1" : "0");
        System.out.println("bit pattern: " + bbits);
    }
}

Stack的用法：

import java.util.*;
public class test {
    static String[] months = {
        "January", "February", "March", "April",
        "May", "June", "July", "August", "September",
        "October", "November", "December" };
    public static void main(String[] args) {
        Stack stk = new Stack();
        for(int i = 0; i < months.length; i++)
            stk.push(months[i] + " ");
        System.out.println("stk = " + stk);
        //     Treating a stack as a Vector:
        stk.addElement("The last line");
        System.out.println("element 5 = " + stk.elementAt(5));
        System.out.println("popping elements:");
        while(!stk.empty())
            System.out.println(stk.pop());
    }
}

Dictionary的用法：

import java.util.*;
public class test extends Dictionary {
    private Vector keys = new Vector();
    private Vector values = new Vector();
    public int size() { return keys.size(); }
    public boolean isEmpty() {
        return keys.isEmpty();
    }
    public Object put(Object key, Object value) {
        keys.addElement(key);
        values.addElement(value);
        return key;
    }
    public Object get(Object key) {
        int index = keys.indexOf(key);
        if(index == -1) return null;
        return values.elementAt(index);
    }
    public Object remove(Object key) {
        int index = keys.indexOf(key);
        if(index == -1)
            return null;
        keys.removeElementAt(index);
        Object returnval = values.elementAt(index);
        values.removeElementAt(index);
        return returnval;
    }
    public Enumeration keys() {
        return keys.elements();
    }
    public Enumeration elements() {
        return values.elements();
    }
    public static void main(String[] args) {
        test aa = new test();
        for(char c = 'a'; c <= 'z'; c++)
            aa.put(String.valueOf(c),String.valueOf(c).toUpperCase());
        char[] ca = { 'a', 'e', 'i', 'o', 'u' };
        for(int i = 0; i < ca.length; i++)
            System.out.println("Uppercase: " + aa.get(String.valueOf(ca[i])));
    }
}

Hashtable的用法：

import java.util.*;
class Counter {
    int i = 1;
    public String toString() {
        return Integer.toString(i);
    }
}
public class test {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable();
        for(int i = 0; i < 10000; i++) {
            // Produce a number between 0 and 20:
            Integer r = new Integer((int)(Math.random() * 20));
            if(ht.containsKey(r))
                ((Counter)ht.get(r)).i++;
            else
                ht.put(r, new Counter());
        }
        System.out.println(ht);
    }
}

未完。