Java：对象容纳

Hashtable

//: Statistics.java
// Simple demonstration of Hashtable
import java.util.*;

class Counter {
    int i = 1;
    public String toString() {
        return Integer.toString(i);
    }
}
public class test1 {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable(); //hashtable类
        Integer r =
                new Integer((int)(Math.random() * 20));//生成一个随机数

        if(ht.containsKey(r)) //检查是否已经存在这个Key的值
            ((Counter)ht.get(r)).i++;
        else {
            Counter a = new Counter();
            a.i = 100;
            ht.put(r, a);//没有的话，就已r为key值，保存对象a。
        }

        System.out.println("r = "+r+"\n"+ht.get(r).toString());

    }
} ///:~

Vector

import java.util.*;

public class test1 {
    public String toString() {
        return "CrashJava address: " + this + "\n";
    }
    public static void main(String[] args) {
        Vector v = new Vector();
        for(int i = 0; i < 10; i++)
            v.addElement(new test1()); //Vector.addElement()添加

        System.out.println(v.size());//Vector.size()返回大小
    }
} ///:~

Stacks

//: Stacks.java
// Demonstration of Stack Class
import java.util.*;
public class test1 {
    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] + " ");//push
        System.out.println("stk = " + stk);
        // Treating a stack as a Vector:
        stk.addElement("The last line");
        System.out.println(
                "element 5 = " + stk.elementAt(5)); //第六个element
        System.out.println("popping elements:");
        while(!stk.empty())//如果stack不为空
            System.out.println(stk.pop());
    }
} ///:~

Enumeration

(1) 用一个名为elements()的方法要求集合为我们提供一个Enumeration。我们首次调用它的nextElement()
时，这个Enumeration 会返回序列中的第一个元素。
(2) 用nextElement() 获得下一个对象。
(3) 用hasMoreElements()检查序列中是否还有更多的对象。

//: CatsAndDogs2.java
// Simple collection with Enumeration
import java.util.*;
class Cat2 {
    private int catNumber;
    Cat2(int i) {
        catNumber = i;
    }
    void print() {
        System.out.println("Cat number " +catNumber);
    }
}
class Dog2 {
    private int dogNumber;
    Dog2(int i) {
        dogNumber = i;
    }
    void print() {
        System.out.println("Dog number " +dogNumber);
    }
}
public class CatsAndDogs2 {
    public static void main(String[] args) {
        Vector cats = new Vector();
        for(int i = 0; i < 7; i++)
            cats.addElement(new Cat2(i));
// Not a problem to add a dog to cats:
        cats.addElement(new Dog2(7));
        Enumeration e = cats.elements();
        while(e.hasMoreElements())
            ((Cat2)e.nextElement()).print();
// Dog is detected only at run-time
    }
} ///:~

Collections

//: SimpleCollection.java
// A simple example using the new Collections
package c08.newcollections;
import java.util.*;
public class SimpleCollection {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        for(int i = 0; i < 10; i++)
            c.add(Integer.toString(i));
        Iterator it = c.iterator();
        while(it.hasNext())
            System.out.println(it.next());
    }
} ///:~

Lists

List（接口） 顺序是List 最重要的特性；它可保证元素按照规定的顺序排列。List 为Collection 添加了
大量方法，以便我们在List 中部插入和删除元素（只推荐对LinkedList 这样做）。List 也会生成一个
ListIterator（列表反复器），利用它可在一个列表里朝两个方向遍历，同时插入和删除位于列表中部的元
素（同样地，只建议对LinkedList 这样做）

//: List1.java
// Things you can do with Lists
package c08.newcollections;
import java.util.*;
public class List1 {
    // Wrap Collection1.fill() for convenience:
    public static List fill(List a) {
        return (List)Collection1.fill(a);
    }
    // You can use an Iterator, just as with a
// Collection, but you can also use random
// access with get():
    public static void print(List a) {
        for(int i = 0; i < a.size(); i++)
            System.out.print(a.get(i) + " ");
        System.out.println();
    }
    static boolean b;
    static Object o;
    static int i;
    static Iterator it;
    static ListIterator lit;
    public static void basicTest(List a) {
        a.add(1, "x"); // Add at location 1
        a.add("x"); // Add at end
// Add a collection:
        a.addAll(fill(new ArrayList()));
// Add a collection starting at location 3:
        a.addAll(3, fill(new ArrayList()));
        b = a.contains("1"); // Is it in there?
// Is the entire collection in there?
        b = a.containsAll(fill(new ArrayList()));
// Lists allow random access, which is cheap
// for ArrayList, expensive for LinkedList:
        o = a.get(1); // Get object at location 1
        i = a.indexOf("1"); // Tell index of object
// indexOf, starting search at location 2:
        i = a.indexOf("1", 2);
        b = a.isEmpty(); // Any elements inside?
        it = a.iterator(); // Ordinary Iterator
        lit = a.listIterator(); // ListIterator
        lit = a.listIterator(3); // Start at loc 3
        i = a.lastIndexOf("1"); // Last match
        i = a.lastIndexOf("1", 2); // ...after loc 2
        a.remove(1); // Remove location 1
        a.remove("3"); // Remove this object
        a.set(1, "y"); // Set location 1 to "y"
// Keep everything that's in the argument
// (the intersection of the two sets):
        a.retainAll(fill(new ArrayList()));
// Remove elements in this range:
        a.removeRange(0, 2);
// Remove everything that's in the argument:
        a.removeAll(fill(new ArrayList()));
        i = a.size(); // How big is it?
        a.clear(); // Remove all elements
    }
    public static void iterMotion(List a) {
        ListIterator it = a.listIterator();
        b = it.hasNext();
        b = it.hasPrevious();
        o = it.next();
        i = it.nextIndex();
        o = it.previous();
        i = it.previousIndex();
    }
    public static void iterManipulation(List a) {
        ListIterator it = a.listIterator();
        it.add("47");
        // Must move to an element after add():
        it.next();
// Remove the element that was just produced:
        it.remove();
// Must move to an element after remove():
        it.next();
// Change the element that was just produced:
        it.set("47");
    }
    public static void testVisual(List a) {
        print(a);
        List b = new ArrayList();
        fill(b);
        System.out.print("b = ");
        print(b);
        a.addAll(b);
        a.addAll(fill(new ArrayList()));
        print(a);
// Shrink the list by removing all the
// elements beyond the first 1/2 of the list
        System.out.println(a.size());
        System.out.println(a.size()/2);
        a.removeRange(a.size()/2, a.size()/2 + 2);
        print(a);
// Insert, remove, and replace elements
// using a ListIterator:
        ListIterator x = a.listIterator(a.size()/2);
        x.add("one");
        print(a);
        System.out.println(x.next());
        x.remove();
        System.out.println(x.next());
        x.set("47");
        print(a);
// Traverse the list backwards:
        x = a.listIterator(a.size());
        while(x.hasPrevious())
            System.out.print(x.previous() + " ");
        System.out.println();
        System.out.println("testVisual finished");
    }
    // There are some things that only
// LinkedLists can do:
    public static void testLinkedList() {
        LinkedList ll = new LinkedList();
        Collection1.fill(ll, 5);
        print(ll);
// Treat it like a stack, pushing:
        ll.addFirst("one");
        ll.addFirst("two");
        print(ll);
// Like "peeking" at the top of a stack:
        System.out.println(ll.getFirst());
// Like popping a stack:
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
// Treat it like a queue, pulling elements
// off the tail end:
        System.out.println(ll.removeLast());
// With the above operations, it's a dequeue!
        print(ll);
    }
    public static void main(String args[]) {
// Make and fill a new list each time:
        basicTest(fill(new LinkedList()));
        basicTest(fill(new ArrayList()));
        iterMotion(fill(new LinkedList()));
        iterMotion(fill(new ArrayList()));
        iterManipulation(fill(new LinkedList()));
        iterManipulation(fill(new ArrayList()));
        testVisual(fill(new LinkedList()));
        testLinkedList();
    }
} ///:~

Sets

import java.util.*;
public class Set1 {
    public static void testVisual(Set a) {
        Collection1.fill(a);
        Collection1.fill(a);
        Collection1.fill(a);
        Collection1.print(a); // No duplicates!
// Add another set to this one:
        a.addAll(a);
        a.add("one");
        a.add("one");
        a.add("one");
        Collection1.print(a);
// Look something up:
        System.out.println("a.contains(\"one\"): " +
                a.contains("one"));
    }
    public static void main(String[] args) {
        testVisual(new HashSet());
        testVisual(new TreeSet());
    }
} ///:~

Maps

//: Map1.java
// Things you can do with Maps
import java.util.*;

public class Map1 {
    public final static String[][] testData1 = {
            { "Happy", "Cheerful disposition" },
            { "Sleepy", "Prefers dark, quiet places" },
            { "Grumpy", "Needs to work on attitude" },
            { "Doc", "Fantasizes about advanced degree"},
            { "Dopey", "'A' for effort" },
            { "Sneezy", "Struggles with allergies" },
            { "Bashful", "Needs self-esteem workshop"},
    };
    public final static String[][] testData2 = {
            { "Belligerent", "Disruptive influence" },
            { "Lazy", "Motivational problems" },
            { "Comatose", "Excellent behavior" }
    };
    public static Map fill(Map m, Object[][] o) {
        for(int i = 0; i < o.length; i++)
            m.put(o[i][0], o[i][1]);
        return m;
    }
    // Producing a Set of the keys:
    public static void printKeys(Map m) {
        System.out.print("Size = " + m.size() +", ");
        System.out.print("Keys: ");
        Collection1.print(m.keySet());
    }
    // Producing a Collection of the values:
    public static void printValues(Map m) {
        System.out.print("Values: ");
        Collection1.print(m.values());
    }
    // Iterating through Map.Entry objects (pairs):
    public static void print(Map m) {
        Collection entries = m.entries();
        Iterator it = entries.iterator();
        while(it.hasNext()) {
            Map.Entry e = (Map.Entry)it.next();
            System.out.println("Key = " + e.getKey() +
                    ", Value = " + e.getValue());
        }
    }

    public static void test(Map m) {
        fill(m, testData1);
// Map has 'Set' behavior for keys:
        fill(m, testData1);
        printKeys(m);
        printValues(m);
        print(m);
        String key = testData1[4][0];
        String value = testData1[4][1];
        System.out.println("m.containsKey(\"" + key +
                "\"): " + m.containsKey(key));
        System.out.println("m.get(\"" + key + "\"): "
                + m.get(key));
        System.out.println("m.containsValue(\""
                + value + "\"): " +
                m.containsValue(value));
        Map m2 = fill(new TreeMap(), testData2);
        m.putAll(m2);
        printKeys(m);
        m.remove(testData2[0][0]);
        printKeys(m);
        m.clear();
        System.out.println("m.isEmpty(): "
                + m.isEmpty());
        fill(m, testData1);
// Operations on the Set change the Map:
        m.keySet().removeAll(m.keySet());
        System.out.println("m.isEmpty(): "
                + m.isEmpty());
    }
    public static void main(String args[]) {
        System.out.println("Testing HashMap");
        test(new HashMap());
        System.out.println("Testing TreeMap");
        test(new TreeMap());
    }
} ///:~

Map（接口） 维持“键－值”对应关系（对），以便通过一个键查找相应的值

HashMap基于一个散列表实现（用它代替Hashtable）。针对“键－值”对的插入和检索，这种形式具有最稳定的性能。可通过构建器对这一性能进行调整，以便设置散列表的“能力”和“装载因子”
ArrayMap 由一个ArrayList 后推得到的Map。对反复的顺序提供了精确的控制。面向非常小的Map 设计，特别是那些需要经常创建和删除的。对于非常小的Map，创建和反复所付出的代价要比HashMap 低得多。但在Map 变大以后，性能也会相应地大幅度降低

TreeMap 在一个“红－黑”树的基础上实现。查看键或者“键－值”对时，它们会按固定的顺序排列（取决于Comparable 或Comparator，稍后即会讲到）。TreeMap 最大的好处就是我们得到的是已排好序的结果。
TreeMap 是含有subMap()方法的唯一一种Map，利用它可以返回树的一部分