九、集合

9.1 Java集合框架

• Enumeration 接口提供了一种用于访问任意容器中各个元素的抽象机制。

1. 将集合的接口与实现分离

   • 队列实现大致如下

     public interface Queue<E> {// a simplified form of the interface in the standard library
         void add(E element);
         E remove();
         int size()；
     }
     

   • 队列实现方式，其示例图如下所示。

     • 循环数组
     • 链表

   

   • 如果想要实现自己的队列类（也许不太可能)，会发现扩展 AbstractQueue 类要比实现Queue 接口中的所有方法轻松得多。

2. Collection 接口（集合类的基本接口）

   • 接口的两个基本方法如下

     public interface Collection<E>
     {
         boolean add(E element);
         Iterator<E> iterator();
         ...
     }
     

3. 迭代器

   • 迭代器 Iterator 接口包含4 个方法

     public interface Iterator<E>
     {
         E next();
         boolean hasNext();
         void remove();
         default void forEachRemaining(Consumer< ? super E> action);
     }
     

   • foreach 循环可以与任何实现了 Iterable 接口的对象一起工作，foreach 循环会被编译器翻译为带有迭代器的循环。 这个接口只包含一个
     抽象方法

     public interface Iterable<E>{
         Iterator<E> iterator();
         ...
     }
     

   • 在Java SE 8 中， 甚至不用写循环。可以调用forEachRemaining 方法并提供一lambda表达式（它会处理一个元素）。将对迭代器的每一个元素调用这个lambda 表达式，直到再没有元素为止。

     iterator.forEachRemaining(element -> do sth element) ;
     

   • 应该将Java 迭代器认为是位于两个元素之间。当调用next 时， 迭代器就越过下一个元素，并返回刚刚越过的那个元素的引用。

     

   • Iterator 接口的remove 方法将会删除上次调用next 方法时返回的元素。对next 方法和remove 方法的调用具有互相依赖性。如果调用remove 之前没有调用next 将是不合法的(抛出一个IllegalStateException)。

4. 泛型实用方法

   • Collection 接口声明了很多有用的方法

     Iterator <E> iterator()
     int size()
     boolean isEmpty()
     boolean contains(Object obj)
     // 如果这个集合包含 other 集合中的所有元素， 返回true
     boolean containsAll (Col1ection< ?> c)
     boolean equals(Object other)
     boolean addAll (Collection< ? extends E> from)
     boolean remove(Object obj)
     boolean removeAll (Col1ection< ?> c)
     // 从这个集合删除filter 返回true 的所有元素。如果由于这个调用改变了集合， 则返回true。
     default boolean removelf(Predicate< ? super E> filter) // java SE 8
     void clear()
     // 从这个集合中删除所有与other 集合中的元素不同的元素。如果由于这个调用改变了集合， 返回true。
     boolean retainAll(Col1ection< ?> c)
     Object[] toArray()
     //返回这个集合的对象数组。如果arrayToFill 足够大， 就将集合中的元素填入这个数组中。剩余空间填补null ; 否则， 分配一个新数组， 其成员类型与arrayToFill 的成员类型相同， 其长度等于集合的大小， 并填充集合元素。
     <T> T[] toArray(T[] arrayToFill )
     

   • AbstractCollection， 它将基础方法 size 和 iterator 抽象化了， 但是在此提供了例行方法。

5. 集合框架中的接口

   • 集合接口框架图

     

   • 集合有两个基本接口：Collection 和Map

     // Collection
     boolean add(E element)
     ... 用迭代器访问元素
     // Map
     V put(K key, V value)
     V get (K key)
     

   • List 是一个有序集，元素会增加到容器中的特定位置。访问元素可以通过两种方式

     • 使用迭代器访问（顺序地访问）
     • 使用一个整数索引来访问
       • 数组方式 可以快速地随机访问，使用迭代器来遍历。
       • 链表方式 随机访问很慢，使用迭代器来遍历。

     为了避免对链表完成随机访问操作， Java SE 1.4 引入了一个标记接口RandomAccess。这个接口不包含任何方法， 不过可以用它来测试一个特定的集合是否支持高效的随机访问

     if (c instanceof RandomAccess){
     	// use random access algorithm
     } else {
     	// use sequential access algorithm
     }
     

   • Set 接口等同于Collection 接口，不过其方法的行为有更严谨的定义，集（set) 的add 方法不允许增加重复的元素。要适当地定义集的equals 方法：只要两个集包含同样的元素就认为是相等的，而不要求这些元素有同样的顺序。hashCode 方法的定义要保证包含相同元素的两个集会得到相同的散列码。

   • NavigableSet 和 NavigableMap接口（Java SE 6），其中包含一些用于搜索和遍历有序集和映射的方法。TreeSet 和TreeMap 类实现了这些接口。

9.2 具体的集合

1. Java 类库中的集合

   

2. 集合框架中的类

   

3. 链表（**LinkedList **）

   • 数组和数组列表都有一个重大的缺陷。这就是从数组的中间位置删除一个元素要付出很大的代价，其原因是数组中处于被删除元素之后的所有元素都要向数组的前端移动。在数组中间的位置上插入一个元素也是如此。

   • 链表（ linked list ) 解决了这个问题，在Java 程序设计语言中， 所有链表实际上都是双向链接的，集合类库提供了子接口 Listlterator

     interface ListIterator<E> extends Iterator<E> {
         // 与Collection.add 不同， 这个方法不返回boolean 类型的值， 它假定添加操作总会改变链表。
         void add(E element);
         // Listlterator 接口有两个方法， 可以用来反向遍历链
         // 与next 方法一样， previous 方法返回越过的对象。
         E previous();
         boolean hasPrevious();
     }
     

   • LinkedList 类的listlterator 方法返回一个实现了Listlterator 接口的迭代器对象。

   • 在用“ 光标” 类比（Listlterator）时要格外小心。remove 操作与BACKSPACE 键的工作方式不太一样。在调用next 之后，remove 方法确实与BACKSPACE 键一样删除了迭代器左侧的元素。但是， 如果调用previous 就会将右侧的元素删除掉， 并且不能连续调用两次remove()，总之，add 方法只依赖于迭代器的位置， 而remove 方法依赖于迭代器的状态。

   • 在某个迭代器修改集合时， 另一个迭代器对其进行遍历， 一定会出现混乱的状况，如下删除情况。

     List<String> list = ...
     ListIterator<String> iterl = list.listlterator();
     ListIterator<String> iter2 = list.listlterator();
     iterl.next();
     iterl.remove();
     iter2.nex();   // throws ConcurrentModificationException
     

     1. 对于并发修改列表的检测肴一个奇怪的例外。链表只负责跟踪对列表的结构性修改， 例如， 添加元素、删除元素。set 方法不被视为结构性修改。

     2. LinkedList中 get 方法做了微小的优化： 如果索引大于size() / 2 就从列表尾端开始搜索元素。

4. 数组列表（ArrayList）

   • ArrayList 方法不是同步的，因此， 建议在不需要同步时使用ArrayList, 而不要使用Vector。

   • Vector 类的所有方法都是同步的。可以由两个线程安全地访问一个Vector 对象。但是， 如果由一个线程访问Vector, 代码要在同步操作上耗费大量的时间。

   • 散列集（HashSet）

     • 散列表

     

     在 Java SE 8 中， 桶满时会从链表变为平衡二叉树。

     在更改集中的元素时要格外小心。如果元素的散列码发生了改变， 元素在数据结构中的位置也会发生变化。

     • 构造函数

     // 构造一个散列集， 并将集合中的所有元素添加到这个散列集中。
     HashSet(Col 1ection< ? extends E> elements )
     // 构造一个具有指定容量和装填因子（一个0.0 ~ 1.0 之间的数值， 确定散列表填充的百分比， 当大于这个百分比时， 散列表进行再散列）的空散列集。
     HashSet(int initialCapacity , float loadFactor)
     ... 
     

5. 树集（**TreeSet **）

   • TreeSet 类与散列集十分类似， 不过， 它比散列集有所改进。树集是一个有序集合，排序是用树结构完成的（当前实现使用的是红黑树（ red-black tree)。如果树中包含n 个元素， 査找新元素的正确位置平均需要 $log_2n$ 次比较。

   • NavigableSet

     E higher(E value)
     E lower(E value)
     // 返回大于value 的最小元素或小于value 的最大元素，如果没有这样的元素则返回null。
     E cei1ing(E value)
     E floor(E value)
     // 返回大于等于vaiue 的最小元素或小于等于value 的最大元素， 如果没有这样的元素则返回null。
     E pollFirst()
     E pollLast()
     // 删除并返回这个集中的最大元素或最小元素， 这个集为空时返回null。
     Iterator<E> descendingIterator()
     // 返回一个按照递减顺序遍历集中元素的迭代器。
     

     1. 要使用树集， 必须能够比较元素。这些元素必须实现Comparable 接口，或者构造集时必须提供一个Comparator。

     2. 从JavaSE 6 起， TreeSet 类实现了NavigableSet 接口。这个接口增加了几个便于定位元素以及反向遍历的方法。

6. 队列与双端队列

   • 有两个端头的队列， 即双端队列， 可以让人们有效地在头部和尾部同时添加或删除元素。不支持在队列中间添加元素。在Java SE 6 中引人了Deque 接口， 并由ArrayDeque 和LinkedList 类实现。这两个类都提供了双端队列， 而且在必要时可以增加队列的长度。

7. 优先级队列（PriorityQueue）

   • 实现了Comparable 接口
   • 优先级队列（priority queue) 中的元素可以按照任意的顺序插人，却总是按照排序的顺序进行检索。优先级队列使用了一个优雅且高效的数据结构，称为堆（ heap)。堆是一个可以自我调整的二叉树，对树执行添加（ add) 和删除（ remore) 操作， 可以让最小的元素移动到根，而不必花费时间对元素进行排序。
   • 使用优先级队列的典型示例是任务调度。

9 . 3 映射

1. 基本映射操作

   • Java 类库为映射提供了两个通用的实现：HashMap 和TreeMap。这两个类都实现了Map 接口。

2. 更新映射项

   • 正常情况下， 可以得到与一个键关联的原值，完成更新， 再放回更新后的值。

     // counts is HashMap，word is String
     counts.put(word, counts.get(word) + 1);
     // 第一次统计到wordword时，counts.get(word)会返回null 
     // 简单的补救
     counts.put(word, counts.getOrDefault(word, 0) + 1);
     // 另一种方法
     counts.putlfAbsent(word, 0);
     counts.put(word, counts.get(word) + 1)
     // 更好的方法，使用merge 方法
     counts.merge(word, 1, Integer::sum); // 把word与1关联，否则使用Integer::sum 函数组合原值和1
     

   • 更新映射项的方法（java.util.Map<K,V>）

     default V merge(K key, V value, BiFunction< ? super V, ? super V, ?extends V> remappingFunctlon)  8
     // 如果key与一个非null值v关联， 将函数应用到v和value，将key与结果关联，或者如果结果为null, 则删除这个键。否则，将key 与value 关联， 返回get(key)。
     default V compute(K key, BiFunction< ? super K,? super V,? extends V> remappingFunction) 8
     // 将函数应用到key和get(key)。 将key与结果关联，或者如果结果为null， 则删除这个键。返回get(key)。
     default V computeIfPresent(K key , BiFunction< ? super K , ? super V , ? extends V > remappingFunction ) 8
     // 如果key 与一个非null值v关联，将函数应用到key和v，将key与结果关联，或者如果结果为null, 则删除这个键。返回get(key)。
     default V computeIfAbsent( K key , Function< ? super K ,? extends V > mappingFunction ) 8
     // 将函数应用到key, 除非key与一个非null值关联。将key与结果关联， 或者如果结果为null, 则删除这个键。返回get(key)。
     default void replaceAll(BiFunction< ? super K ,? super V ,? extends V > function ) 8
     // 在所有映射项上应用函数。将键与非null结果关联，对于null结果，则将相应的键删除。
     

3. 映射视图

   • Set<K> keySet() -> 键集
   • Collection<V> values() -> 值集合（不是一个集）
   • Set<Map.Entry<K, V>> entrySet() -> 键/ 值对集

   同时访问键值对最好使用forEach方法

   • java.util.Map.Entry<K,V>

     K getKey()
     V getValue()
     // 返回这一条目的键或值。
     V setValue(V newValue)
     // 将相关映射中的值改为新值， 并返回原来的值。
     

4. 弱散列映射(WeakHashMap)

   • WeakHashMap 使用弱引用（ weak references) 保存键。WeakReference 对象将引用保存到另外一个对象中， 在这里， 就是散列键。对于这种类型的对象， 垃圾回收器用一种特有的方式进行处理。通常， 如果垃圾回收器发现某个特定的对象已经没有他人引用了， 就将其回收。然而， 如果某个对象只能由WeakReference 引用， 垃圾回收器仍然回收它，但要将引用这个对象的弱引用放人队列中。WeakHashMap 将周期性地检查队列， 以便找出新添加的弱引用。一个弱引用进人队列意味着这个键不再被他人使用， 并且已经被收集起来。于是， WeakHashMap 将删除对应的条目。

5. 链接散列集与映射

   • LinkedHashSet 和 LinkedHashMap 可以记住插人元素项的顺序。这样就可以避免在散歹IJ表中的项从表面上看是随机排列的。当条目插入到表中时，就会并人到双向链表中。

     

   • 链接散列映射将用访问顺序， 而不是插入顺序， 对映射条目进行迭代。每次调用get 或put, 受到影响的条目将从当前的位置删除， 并放到条目链表的尾部（只有条目在链表中的位置会受影响， 而散列表中的桶不会受影响。一个条目总位于与键散列码对应的桶中）。

   • 访问顺序对于实现高速缓存的“ 最近最少使用” 原则十分重要。如可能希望将访问频率高的元素放在内存中， 而访问频率低的元素则从数据库中读取。值需要覆盖下面的方法

     // 需要覆盖的方法，每当方法返回true 时， 就添加一个新条目，从而导致删除eldest 条目。
     protected boolean removeEldestEntry(Map.Entry<K, V> eldest)
     
     // 下面的高速缓存可以存放100 个元素
     Map<K, V> cache = new LinkedHashMapo(128, 0.75F, true) {
         protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
         	return size() > 100;
         }
     }();
     

6. 枚举集与映射

   • EmimSet 是一个枚举类型元素集的高效实现，内部用位序列实现，若对应的值在集中， 则相应的位被置为1。EnumSet 类没有公共的构造器。可以使用静态工厂方法构造

     enum Weekday { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY };
     // 加载全部Weekday
     EnumSet<Weekday> always = EnumSet.allOf(Weekday.class);
     // 加载空Weekday
     EnumSet<Weekday> never = EnumSet.noneOf(Weekday.class);
     // 加载范围Weekday （MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY）
     EnumSet<Weekday> workday = EnumSet.range(Weekday.MONDAY, Weekday.FRIDAY);
     // 加载指定
     EnumSet<Weekday> mwf = EnumSet.of(Weekday.MONDAY, Weekday.WEDNESDAY, Weekday.FRIDAY);
     

   • EnumMap 是一个键类型为枚举类型的映射。它可以直接且高效地用一个值数组实现。在使用时， 需要在构造器中指定键类型

     EnumMap<Weekday, Employee> personlnCharge = new EnumMap<>(Weekday.class);
     

7. 标识散列映射（IdentityHashMap）

   • 在这个类中， 键的散列值不是用hashCode 函数计算的， 而是用System.identityHashCode 方法计算的。这是Object.hashCode 方法根据对象的内存地址来计算散列码时所使用的方式。在对两个对象进行比较时， IdentityHashMap 类使用==, 而不使用equals。
   • 不同的键对象， 即使内容相同， 也被视为是不同的对象。在实现对象遍历算法（如对象串行化）时， 这个类非常有用， 可以用来跟踪每个对象的遍历状况。

9.4 视图与包装器

1. 轻量级集合包装器

   • Arrays 类的静态方法asList 将返回一个包装了普通Java 数组的List 包装器。这个方法可以将数组传递给一个期望得到列表或集合参数的方法。

     Card[] cardOeck = new Card[52];
     ...
     List<Card> cardList = Arrays.asList(cardDeck):
     

     返回的对象不是 ArrayList。它是一个视图对象， 带有访问底层数组的get 和set 方法。改变数组大小的所有方法都会抛出一个UnsupportedOperationException 异常。

   • Collections.nCopies(n, anObject) 将返回一个实现了List 接口的不可修改的对象， 并给人一种包含n个元素， 每个元素都像是一个anObject 的错觉。这种对象存储代价很小。这是视图技术的一种巧妙应用。

   • Collections.singleton(anObject) 将返回一个视图对象。这个对象实现了Set 接口（与产生List 的ncopies 方法不同）。返回的对象实现了一个不可修改的单元素集， 而不需要付出建立数据结构的开销。singletonList方法与singletonMap 方法类似。

   • 对于集合框架中的每一个接口，还有一些方法可以生成空集、列表、映射， 等。特别是， 集的类型可以推导得出：

     Set<String> deepThoughts = Col1ections.emptySet();
     

     Collections 类包含很多实用方法， 这些方法的参数和返回值都是集合。不要将它与Collection 接口混淆起来。

2. 子范围

   • 可以为很多集合建立子范围（subrange) 视图。

     // 使用subList 方法来获得一个列表的子范围视图。
     List group2 = staff.subList(10, 20) ;
     // 子范围对象可以将任何操作应用于子范围，并且能够自动地反映整个列表的情况。
     group2.clear(); // 清除子范围所有数据
     

   • 对于有序集和映射， 可以使用排序顺序而不是元素位置建立子范围。

     // SortedSet 接口
     SortedSet<E> subSet(E from, E to)
     SortedSet<E> headSet(E to)
     SortedSet<E> tailSet(E from)
     // 这些方法将返回大于等于from 且小于to 的所有元素子集。
     // SortedMap 接口同理
     SortedMap<K,V> subMap(K from, K to)
     SortedMap<K,V> headMap(K to)
     SortedMap<K,V> tailMap(K from)
     // NavigableSet 接口赋予子范围操作更多的控制能力
     NavigableSet<E> subSet(E from, boolean fromlnclusive, E to, boolean tolnclusive)
     NavigableSet<E> headSet(E to, boolean tolnclusive)
     Navigab1eSet<E> tailSet(E from, boolean fromlnclusive)
     

3. 不可修改的视图

   • Collections 还有几个方法， 用于产生集合的不可修改视图（ unmodifiable views)。这些视图对现有集合增加了一个运行时的检查。如果发现试图对集合进行修改， 就抛出一个异常，同时这个集合将保持未修改的状态。

   • 获取视图

     Collections.unmodifiableCollection
     Collections.unmodifiableList
     Collections.unmodifiableSet
     Collections.unmodifiableSortedSet
     Collections.unmodifiableNavigableSet
     Collections.unmodifiableMap
     Collections.unmodifiableSortedMap
     Collections.unmodifiableNavigableMap
     // 每个方法都定义于一个接口。
     

   • 不可修改视图并不是集合本身不可修改。仍然可以通过集合的原始引用对集合进行修改。并且仍然可以让集合的元素调用更改器方法。由于视图只是包装了接口而不是实际的集合对象， 所以只能访问接口中定义的方法。

4. 同步视图

   • 如果由多个线程访问集合，就必须确保集不会被意外地破坏。类库的设计者使用视图机制来确保常规集合的线程安全， 而不是实现线程安全的集合
     类。

   • Collections 类的静态synchronizedMap 方法可以将任何一个映射表转换成具有同步访问方法的Map

     Map<String, Employee> map = Collections.synchronizedMap(new HashMap<String, Employee>0)；
     // 当前可由多线程访问map对象，a像get和put这类方法都是同步操作
     

5. 受查视图

   • “受査” 视图用来对泛型类型发生问题时提供调试支持。将错误类型的元素混人泛型集合中的问题极有可能发生。

     ArrayList<String> strings = new ArrayList();
     ArrayList rawList = strings; // warning only, not an error, for compatibility with legacy code
     rawList.add(new Date()); // now strings contains a Date object!
     // 这个错误的add命令在运行时检测不到。相反， 只有在稍后的另一部分代码中调用get方法， 并将结果转化为String 时，这个类才会抛出异常。
     

   • 受査视图可以探测到这类问题。

     ArrayList<String> strings = new ArrayList();
     // 安全检查
     List<String> safestrings = Collections.checkedList(strings, String.class);
     List rawList = safestrings;
     rawList.add(new Date());   //checked list throws a ClassCastException
     

     视图的add 方法将检测插人的对象是否属于给定的类。如果不属于给定的类， 就立即抛出一个ClassCastException。

6. 视图有一些局限性， 即可能只可以读、无法改变大小、只支持删除而不支持插人，这些与映射的键视图情况相同。如果试图进行不恰当的操作，受限制的视图就会抛出一个UnsupportedOperationException。

9 . 5 算法

1. 排序与混排

   • Collections 类中的sort 方法可以对实现了List 接口的集合进行排序。

     List<String> staff = new LinkedList();
     ...
     Collections.sort(staff);
     // 如果想按照降序对列表进行排序， 可以使用一种非常方便的静态方法 
     // Collections.reverseOrder 方法将返回一个比较器， 比较器则返回 b.compareTo(a)（默认是 a.compareTo(b)）
     staff.sort(Collections.reverseOrder())
     
     // 按工资对一个员工列表排序
     staff.sort(Comparator.comparingDouble(Employee::getSalary))
     // 按照工资逆排序
     staff.sort(Comparator.comparingDouble(Employee::getSalary).reversed())
     

     Java 排序使用归并排序（稳定），排序过程是直接将所有元素转人一个数组， 对数组进行排序，然后，再将排序后的序列复制回列表。

     传入排序的列表必须是可修改的，相关解释：

     • 如果列表支持set 方法，则是可修改的。
     • 如果列表支持add 和remove 方法， 则是可改变大小的。

   • Collections 类有一个算法shuffle, 其功能与排序刚好相反， 即随机地混排列表中元素的顺序。如果提供的列表没有实现RandomAccess 接口，shuffle 方法将元素复制到数组中， 然后打乱数组元素的顺序，最后再将打乱顺序后的元素复制回列表。

     ArrayList<Card> cards = ...;
     Collections.shuffle(cards);
     

2. 二分查找

   • Collections 类的binarySearch 方法实现了二分查找算法。集合必须是排好序的， 否则算法将返回错误的答案。集合要实现List 接口。

   • 只有采用随机访问，二分査找才有意义。如果必须利用迭代方式一次次地遍历链表的一半元素来找到中间位置的元素，二分査找就完全失去了优势。因此， 如果为binarySearch 算法提供一个链表， 它将自动地变为线性查找。

3. 批操作

   • 批操作

     // 从coll1 中删除)112 中出现的所有元素。
     coll1.removeAll(coll2);
     // 从coll1中删除所有未在coll2中出现的元素。
     coll1.retainAll(coll2);
     

   • 小例子

     // 假设有一个映射， 将员工ID映射到员工对象， 而且建立了一个将不再聘用的所有员工的ID。
     Map<String, Employee> staffMap = ...;
     Set<String> terainatedlDs = ...;
     // 直接建立一个键集，并删除终止聘用关系的所有员工的ID。
     staffMap.keySet().removeAll(terminatedIDs);
     // 由于键集是映射的一个视图，所以键和相关联的员工名会自动从映射中删除。
     // 批量清除
     staff.subList(0, 10).clear()；
     

4. 集合与数组的转换

   • 把一个数组转换为集合

     // 使用 Arrays.asList
     String[] values = ...
     HashSet<String> staff = new HashSeto(Arrays.asList(values));
     

   • 集合得到数组

     Object[] values = staff.toArray();
     // 不能使用强制类型转换
     // 使用toArray 方法的一个变体形式(创建新数组)
     String[] values = staff.toArray(new String[0]);
     // 或者(不会创建新数组)
     String[] values = staff.toArray(new String[staff.size()]);
     

9.6 遗留的集合

1. Hashtable 类

   • Hashtable 类与HashMap 类的作用一样， 实际上， 它们拥有相同的接口。与Vector 类的方法一样。Hashtable 的方法也是同步的如果对同步性或与遗留代码的兼容性没有任何要求，就应该使用HashMap。如果需要并发访问， 则要使用ConcurrentHashMap。

2. 枚举

   • 遗留集合使用Enumeration 接口对元素序列进行遍历。Enumeration 接口有两个方法， 即hasMoreElements 和nextElement。这两个方法与Iterator 接口的hasNext 方法和next 方法十分类似。

3. 属性映射

   • 属性映射（property map) 是一个类型非常特殊的映射结构。实现属性映射的Java 平台类称为Properties。特征如下：

     • 键与值都是字符串。
     • 表可以保存到一个文件中， 也可以从文件中加载。
     • 使用一个默认的辅助表。

4. 栈

   • Stack 类扩展为Vector 类，它可以让栈使用不属于栈操作的insert 和remove 方法， 即可以在任何地方进行插入或删除操作，而不仅仅是在栈顶。

5. 位集

   • Java 平台的BitSet 类用于存放一个位序列（它不是数学上的集， 称为位向量或位数组更为合适)。如如果需要高效地存储位序列（例如，标志）就可以使用位集。由于位集将位包装在字节里， 所以，使用位集要比使用Boolean 对象的ArrayList 更加高效。

   • BitSet 类提供了一个便于读取、设置或清除各个位的接口。使用这个接口可以避免屏蔽和其他麻烦的位操作。如果将这些位存储在int 或丨ong 变量中就必须进行这些繁琐的操作。

   • 例子，对于一个名为bucketOfBits 的BitSet

     bucketOfBits.get(i)
     // 如果第i 位处于“ 开” 状态，就返回true; 否则返回false。同样地，
     bucketOfBits.set(i)
     // 将第i 位置为“ 开” 状态。最后，
     bucketOfBits.clear(i)
     // 将第i 位置为“ 关” 状态。
     

API注释

9.1.4 泛型实用方法

java.util.Colloction 1.2

Iterator<E> iterator()
// 返回一个用于访问集合中每个元素的迭代器。
int size()
// 返回当前存储在集合中的元素个数。
boolean isEmpty()
// 如果集合中没有元素， 返回true。
boolean contains(Object obj)
// 如果集合中包含了一个与obj 相等的对象， 返回true。
boolean containsAll(Collection< ?> other)
// 如果这个集合包含other 集合中的所有元素， 返回trueo
boolean add(Object element)
// 将一个元素添加到集合中。如果由于这个调用改变了集合，返回true。
boolean addAll(Collection< ? extends E> other)
// 将other 集合中的所有元素添加到这个集合。如果由于这个调用改变了集合， 返回true。
boolean remove(Object obj)
// 从这个集合中删除等于obj 的对象。如果有匹配的对象被删除， 返回true。
boolean removeAll(Col 1ection< ?> other)
// 从这个集合中删除other 集合中存在的所有元素。如果由于这个调用改变了集合，返回true。
default boolean removelf(Predicate< ? super E> filter)8
// 从这个集合删除filter 返回true 的所有元素。如果由于这个调用改变了集合， 则返回true。
void clear()
// 从这个集合中删除所有的元素。
boolean retainAll(Collection< ?> other)
// 从这个集合中删除所有与other 集合中的元素不同的元素。如果由于这个调用改变了集合， 返回true。
Object[] toArray()
// 返回这个集合的对象数组。
<T> T[] toArray(T[]arrayToFi11)
// 返回这个集合的对象数组。如果arrayToFill 足够大， 就将集合中的元素填入这个数组中。剩余空间填补null ; 否则， 分配一个新数组， 其成员类型与arrayToFill 的成员类型相同， 其长度等于集合的大小， 并填充集合元素。

java.util.Iterator 1.2

boolean hasNext()
// 如果存在可访问的元素， 返回true。
E next()
// 返回将要访问的下一个对象。如果已经到达了集合的尾部， 将拋出一个NoSuchElementException。
void remove( )
// 删除上次访问的对象。这个方法必须紧跟在访问一个元素之后执行。如果上次访问之后，集合已经发生了变化， 这个方法将抛出一个IllegalStateException。

9 . 2.1 链表

java.util.List 1.2

ListIterator<E> listIterator()
// 返回一个列表迭代器， 以便用来访问列表中的元素。
ListIterator <E> listIterator(int index)
// 返回一个列表迭代器， 以便用来访问列表中的元素， 这个元素是第一次调用next 返回的给定索引的元素。
void add(int i, E element)
// 在给定位置添加一个元素。
void addAll(int i, Collection< ? extends E> elements)
// 将某个集合中的所有元素添加到给定位置。
E remove(int i)
// 删除给定位置的元素并返回这个元素。
E get(int i)
// 获取给定位置的元素。
E set(int i, E element)
// 用新元素取代给定位置的元素， 并返回原来那个元素。
int indexOf(Object element)
// 返回与指定元素相等的元素在列表中第一次出现的位置， 如果没有这样的元素将返回-1。
int 1 astlndexOf(Object element)
// 返回与指定元素相等的元素在列表中最后一次出现的位置， 如果没有这样的元素将返回-1

java.util.Listlterator 1.2

void add(E newElement)
// 在当前位置前添加一个元素。
void set(E newElement)
// 用新元素取代next 或previous 上次访问的元素。如果在next 或previous 上次调用之后列表结构被修改了， 将拋出一个IllegalStateException 异常。
boolean hasPrevious()
// 当反向迭代列表时， 还有可供访问的元素， 返回true。
E previous()
// 返回前对象。如果已经到达了列表的头部， 謝te出一hNoSuchElementException 异常。
int nextlndex()
// 返回下一次调用next 方法时将返回的元素索引。
int previousIndex()
// 返回下一次调用previous 方法时将返回的元素索引。

java.util.LinkList 1.2

LinkedList()
// 构造一个空链表。
LinkedList(Collection< ? extends E> elements)
// 构造一个链表， 并将集合中所有的元素添加到这个链表中。
void addFirst(E element)
void addLast(E element)
// 将某个元素添加到列表的头部或尾部。
E getFirst()
E getLast()
// 返回列表头部或尾部的元素。
E removeFirst()
E removeLast()
// 删除并返回列表头部或尾部的元素。

9.2.3 散列集

java.util.HashSet 1.2

HashSet()
// 构造一个空散列表。
HashSet(Collection< ? extends E> elements )
// 构造一个散列集， 并将集合中的所有元素添加到这个散列集中。
HashSet(int initialCapacity)
// 构造一个空的具有指定容量（桶数）的散列集。
HashSet(int initialCapacity, float loadFactor )
// 构造一个具有指定容量和装填因子（一个0.0 ~ 1.0 之间的数值， 确定散列表填充的百分比， 当大于这个百分比时， 散列表进行再散列）的空散列集。

java.Iang.Objectl 1.0

int hashCode( )
// 返回这个对象的散列码。散列码可以是任何整数， 包括正数或负数。equals 和hashCode的定义必须兼容，即如果x.equals(y) 为true, x.hashCode() 必须等于y.hashCode()。

9.2.4 树集

java.util.TreeSet 1.2

TreeSet()
TreeSet(Comparator< ? super E> comparator)
//构造一个空树集。
TreeSet(Collection< ? extends E> elements)
TreeSet(SortedSet<E> s)
//构造一个树集， 并增加一个集合或有序集中的所有元素（对于后一种情况， 要使用同样的顺序)。

java.util.SortedSet 1.2

Comparator< ? super E> comparator)
// 返回用于对元素进行排序的比较器。如果元素用Comparable 接口的compareTo 方法进行比较则返回null。
E first()
E last()
// 返回有序集中的最小元素或最大元素。

java.util.NavigableSet 6

E higher(E value)
E lower(E value)
// 返回大于value 的最小元素或小于value 的最大元素，如果没有这样的元素则返回null。
E ceiling(E value)
E floor(E value)
// 返回大于等于vaiue 的最小元素或小于等于value 的最大元素， 如果没有这样的元素则返回null。
E pollFirst()
E pollLast()
// 删除并返回这个集中的最大元素或最小元素， 这个集为空时返回null。
Iterator<E> descend *ngIterator()
// 返回一个按照递减顺序遍历集中元素的迭代器。

9.2.5 队列与双端队列

java.utii.Queue

boolean add(E element )
boolean offer(E element )
// 如果队列没有满，将给定的元素添加到这个双端队列的尾部并返回true。如果队列满了，第一个方法将拋出一个IllegalStateException, 而第二个方法返回false。
E remove()
E poll()
// 假如队列不空， 删除并返回这个队列头部的元素。如果队列是空的，第一个方法抛出NoSuchElementException, 而第二个方法返回null。
E element()
E peek()
// 如果队列不空，返回这个队列头部的元素， 但不删除。如果队列空，第一个方法将拋出一个NoSuchElementException, 而第二个方法返回null。

java.util.Deque

void addFirst(E element)
void addLast(E element)
boolean offerFirst(E element)
boolean offerLast(E element)
// 将给定的对象添加到双端队列的头部或尾部。如果队列满了，前面两个方法将拋出一个IllegalStateException， 而后面两个方法返回false。
E removeFirst()
E removeLast()
E pollFirst()
E pollLast()
// 如果队列不空，删除并返回队列头部的元素。如果队列为空，前面两个方法将拋出一个NoSuchElementException, 而后面两个方法返回null。
E getFirst()
E getLast()
E peekFirst()
E peekLast()
// 如果队列非空，返回队列头部的元素， 但不删除。如果队列空，前面两个方法将拋出一个NoSuchElementException, 而后面两个方法返回null。

java.util.ArrayDeque

ArrayDeque()
ArrayDeque(1nt initialCapacity)

9.2.6 优先级队列

java.util.PriorityQueue

PriorityQueue()
PriorityQueue(int initialCapacity)
// 构造一个用于存放Comparable 对象的优先级队列。
Pr1orityQueue(int initialCapacity, Comparator ? super E> c)
// 构造一个优先级队列， 并用指定的比较器对元素进行排序。

9 . 3.1 基本映射操作

java.util.Map<K,V>

V get(Object key)
// 获取与键对应的值；返回与键对应的对象， 如果在映射中没有这个对象则返回null。键可以为null。
default V getOrDefault(Object key, V defaultValue)
// 获得与键关联的值； 返回与键关联的对象， 或者如果未在映射中找到这个键， 则返回defaultValue。
V put(K key, V value)
// 将键与对应的值关系插入到映射中。如果这个键已经存在， 新的对象将取代与这个键对应的旧对象。这个方法将返回键对应的旧值。如果这个键以前没有出现过则返回null。键可以为null， 但值不能为null。
void putAll(Map< ? extends K , ? extends V> entries)
// 将给定映射中的所有条目添加到这个映射中。
boolean containsKey(Object key)
// 如果在映射中已经有这个键， 返回true。
boolean containsValue(Object value)
// 如果映射中已经有这个值， 返回true。
default void forEach(BiConsumer< ? super K ,? super V> action) // [java SE 8]
// 对这个映射中的所有键/值对应用这个动作。

java.util.TreeMap<K,V>

TreeMap()
// 为实现Comparable 接口的键构造一个空的树映射。
TreeMap(Comparator< ? super K> c)
// 构造一个树映射， 并使用一个指定的比较器对键进行排序。
TreeMap(Map< ? extends K, ? extends V> entries)
// 构造一个树映射， 并将某个映射中的所有条目添加到树映射中。
TreeMap(SortedMap< ? extends K, ? extends V> entries)
// 构造一个树映射， 将某个有序映射中的所有条目添加到树映射中， 并使用与给定的有映射相同的比较器。

java.util.SortedMap<K, V>

Comparator< ? super K> comparator()
// 返回对键进行排序的比较器。如果键是用Comparable 接口的compareTo 方法进行比 较的，返回null。
K firstKey()
K lastKey()
// 返回映射中最小元素和最大元素。

9.3.2 更新映射项

java.util.Map<K,V> 1.2

default V merge(K key, V value, BiFunction< ? super V, ? super V, ?extends V> remappingFunctlon)  8
// 如果key与一个非null值v关联， 将函数应用到v和value，将key与结果关联，或者如果结果为null, 则删除这个键。否则，将key 与value 关联， 返回get(key)。
default V compute(K key, BiFunction< ? super K,? super V,? extends V> remappingFunction) 8
// 将函数应用到key和get(key)。 将key与结果关联，或者如果结果为null， 则删除这个键。返回get(key)。
default V computeIfPresent(K key , BiFunction< ? super K , ? super V , ? extends V > remappingFunction ) 8
// 如果key 与一个非null值v关联，将函数应用到key和v，将key与结果关联，或者如果结果为null, 则删除这个键。返回get(key)。
default V computeIfAbsent( K key , Function< ? super K ,? extends V > mappingFunction ) 8
// 将函数应用到key, 除非key与一个非null值关联。将key与结果关联， 或者如果结果为null, 则删除这个键。返回get(key)。
default void replaceAll(BiFunction< ? super K ,? super V ,? extends V > function ) 8
// 在所有映射项上应用函数。将键与非null结果关联，对于null结果，则将相应的键删除。

9.3.3 映射视图

java.util.Map<K,V> 1.2

Set<Map.Entry<K, V>> entrySet()
// 返回Map.Entry 对象（映射中的键/ 值对）的一个集视图。可以从这个集中删除元素，它们将从映射中删除，但是不能增加任何元素。
Set<K> keySet()
// 返回映射中所有键的一个集视图。可以从这个集中删除元素，键和相关联的值将从映射中删除， 但是不能增加任何元素。
Col 1ection<V> values()
// 返回映射中所有值的一个集合视图。可以从这个集合中删除元素， 所删除的值及相应的键将从映射中删除， 不过不能增加任何元素。

java.util.Map.Entry<K,V> 1.2

K getKey()
V getValue()
// 返回这一条目的键或值。
V setValue(V newValue)
// 将相关映射中的值改为新值， 并返回原来的值。

9.3.7 标识散列映射

java.util.WeakHashMap<K, V> 1.2

WeakHashMap()
WeakHashMap(int initialCapacity)
WeakHashMap(int initialCapacity, float 1oadFactor)
// 用给定的容量和填充因子构造一个空的散列映射表。

java.util.LinkedHashSet 1.4

LinkedHashSet()
LinkedHashSet(int initialCapacity)
LinkedHashSet(int initialCapacity, float 1oadFactor)
// 用给定的容量和填充因子构造一个空链接散列集。

java.utif.LinkedHashMap<K, V> 1.4

LinkedHashMap()
LinkedHashMap(int initialCapacity)
LinkedHashMap(int initialCapacity, float loadFactor)
LinkedHashMap(int initialCapacity, float loadFactor, booleanaccessOrder)
// 用给定的容量、填充因子和顺序构造一个空的链接散列映射表。accessOrder 参数为true 时表示访问顺序， 为false 时表示插入顺序。
protected boolean removeEldestEntry(Map.Entry<K, V > eldest)
// 如果想删除eldest 元素， 并同时返回true, 就应该覆盖这个方法。eldest 参数是预期要删除的条目。这个方法将在条目添加到映射中之后调用。其默认的实现将返回false。即在默认情况下，旧元素没有被删除。然而， 可以重新定义这个方法， 以便有选择地返回true。例如， 如果最旧的条目符合一个条件， 或者映射超过了一定大小， 则返回true。

java.util.EnumSet<E extends Enum> 5.0

static <E extends Enum<E>> EnumSet<E> allOf(Class<E> enumType)
// 返回一个包含给定枚举类型的所有值的集。
static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> enumType)
// 返回一个空集，并有足够的空间保存给定的枚举类型所有的值。
static <E extends Enum<E>> EnumSet<E> range(E from, E to)
// 返回一个包含from 〜to 之间的所有值（包括两个边界元素）的集。
static <E extends Enum<E>> EnumSet<E> of(E value)
static <E extends Enum<E>> EnumSet<E> of(E value, E... values)
// 返回包括给定值的集。

java.util.EnumMap<K extends Enum, V> 5.0

EnumMap(Class<K> keyType)
// 构造一个键为给定类型的空映射。

java.util.ldentityHashMap<K, V> 1.4

IdentityHashMap()
IdentityHashMap(int expectedMaxSize)
// 构造一个空的标识散列映射集，其容量是大于1.5 * expectedMaxSize 的2 的最小次幂( expectedMaxSize 的默认值是21 )。

java. Lang.System 1.0

static int identityHashCode(Object obj) 1.1
// 返回ObjecUiashCode 计算出来的相同散列码（根据对象的内存地址产生)，即使obj所属的类已经重新定义了hashCode 方法也是如此。

9.4.6 关于可选操作的说明

java.util.Colloctions 1.2

static <E> Collection unmodifiableCollectlon(Collection<E> c)
static <E> List unmodifiableLIst(L1st<E> c)
static <E> Set unmodifiab1eSet(Set<E> c)
static <E> SortedSet unmodif1ableSortedSet(SortedSet<E> c)
static <E> SortedSet unmodif1ableNavigab1eSet(Navigab1eSet<E> c) 8
static <K, V> Map unmodifiableMap(Map<K, V> c)
static <K, V> SortedMap unmodifiableSortedMap(SortedMap<K, V> c)
static <K, V> SortedMap unmodifiableSortedMap(NavigableMap<K, V> c) 8
// 构造一个集合视图；视图的更改器方法抛出一个UnsupportedOperationException。
static <E> Col 1ection<E> synchronizedCollection(Col 1ection<E> c)
static <E> List synchronizedList(List<E> c)
static <E> Set synchronizedSet(Set<E> c)
static <E> SortedSet synchronizedSortedSet(SortedSet<E> c)
static <E> Navigab1eSet synchronizedNavigabeSet(NavigableSet<E> c) 8
static <K, V> Map<K, V> synchronizedMap(Map<K, V> c)
static <K, V> SortedMapCK, V> synchronizedSortedMap(SortedMap<K, V> c)
static <K, V> NavigableMap<K, V> synchronizedNavigab1eMap(NavigableMap<K, V> c) 8
// 构造一个集合视图； 视图的方法同步。
static <E> Collection checkedCollection(Col 1ection<E> c, Class<E>elementType)
static <E> List checkedList(List<E> c,  Class<E> elementType)
static <E> Set checkedSet(Set<E> c, Class<E> elementType)
static <E> SortedSet checkedSortedSet(SortedSet<E> c,  Class <E>elementType)
static <E> NavigableSet checkedNavigableSet(NavigableSet <E> c, Class<E> elementType) 8
static <K, V> Map checkedMap(Map<K, V> c,  Class <K > keyType,Class<V> valueType)
static <K, V> SortedMap checkedSortedMap(SortedMap<K, V> c, Class<K> keyType, Class<V> valueType)
static <K, V> NavigableMap checkedNavigableMap(NavigableMap<K,  V>c, Class<K> keyType, Cl ass<V> valueType) 8
static <E> Queue<E> checkedQueue(Queue<E> queue,  Class <E>elementType) 8
// 构造一合视图；如果插入一型的元素， 视图的方法拋出一ClassCastException。
static <E> List<E> nCopies(int n, E value)
static <E> Set<E> singleton(E value)
static <E> List<E> singletonList(E value)
static <K,  V> Map<K, V> singletonMap(K key, V value)
// 构造一个对象视图， 可以是一个包含n 个相同元素的不可修改列表， 也可以是一个单元素集、列表或映射。
static <E> List<E> emptyList()
static <T> Set<T> emptySet()
static <E> SortedSet<E> emptySortedSet()
static NavigableSet<E> emptyNavigableSet()
static <K, V> Map<K, V> emptyMap()
static <K, V> SortedMap<K, V> emptySortedMap()
static <K, V> NavigableMap<K, V> emptyNavigableMap()
static <T> Enumeration<T> emptyEnumeration()
static <T> Iterator<T> emptyIterator()
static <T> ListIterator<T> emptyListIterator()
// 生成一个空集合、映射或迭代器。

java.util.Arrays 1.2

static <E> List<E> asList(E... array)
// 返回一个数组元素的列表视图。这个数组是可修改的， 但其大小不可变。

java.util.List 1.2

List<E> subList(int firstlncluded， int firstExcluded)
// 返回给定位置范围内的所有元素的列表视图。

java.util.SortedSet 1.2

SortedSet<E> subSet(E firstlncluded, E firstExcluded)
SortedSet<E> headSet(E firstExcluded)
SortedSet<E> tailSet(E firstlncluded)
// 返回给定范围内的元素视图。

java.util.NavigableSet 6

NavigableSet<E> subSet(E from , boolean fromlncluded, E to, boolean tolncluded)
NavigableSet<E> headSet(E to, boolean tolncluded)
NavigableSet<E> tailSet(E from, boolean fromlncluded)
// 返回给定范围内的元素视图。boolean 标志决定视图是否包含边界。

java.util.SortedMap<K, V> 1.2

SortedMap<K, V> subMap(K firstlncluded , K firstExcluded)
SortedMap<K, V> headMap(K firstExcluded)
SortedMap<K, V> tailMap(K firstlncluded)
// 返回在给定范围内的键条目的映射视图。

java.util.NavigableMap<K, V> 6

NavigableMap<K, V> subMap(K from, boolean fromlncluded, K to, boolean tolncluded)
NavigableMap< K, V> headMap(K from, boolean fromlncluded)
NavigableMapCK, V> tailMap(K to, boolean tolncluded)
// 返回在给定范围内的键条目的映射视图。boolean 标志决定视图是否包含边界。

9 . 5.1 排序与混排

java.util.Colloctions 1.2

static <T extends Comparable< ? super T» void sort( List<T> elements )
// 使用稳定的排序算法， 对列表中的元素进行排序。这个算法的时间复杂度是0(n logn), 其中n 为列表的长度。
static void shuff1e(List< ?> elements )
static void shuff1e(List < ?> elements, Random r )
// 随机地打乱列表中的元素。这个算法的时间复杂度是0(na(n», n 是列表的长度，a (n)是访问元素的平均时间。

java.util.List 1.2

default void sort(Comparator< ? super T> comparator ) 8
//使用给定比较器对列表排序。

java.utii.Comparator 1.2

static <T extends Comparable< ? super T» Comparator<T> reverseOrder( ) 8
// 生成一个比较器， 将逆置Comparable 接口提供的顺序。
default Comparator<T> reversed( ) 8
// 生成一个比较器， 将逆置这个比较器提供的顺序。

9.5.2 二分查找

java.util.Colloctions 1.2

static <T extends Comparable< ? super T>> int binarySearch( List<T> elements , T key)
static <T> int binarySearch(List<T> elements, T key, Conparator< ? super T> c)
// 从有序列表中搜索一个键， 如果元素扩展了AbstractSequentialList 类， 则采用线性查找，否则将采用二分查找。这个方法的时间复杂度为0(a(n)l0gn), n 是列表的长度，a(n)是访问一个元素的平均时间。这个方法将返回这个键在列表中的索引， 如果在列表中不存在这个键将返回负值i。 在这种情况下，应该将这个键插人到列表索引一i— l的位置上， 以保持列表的有序性。

9 . 5.3 简单算法

java.util.CoIiections 1.2

static <T extends Comparab1e< ? super T>> T min(Collection<T> elements)
static <T extends Comparable< ? super T>> T max(Collection<T> elements)
static <T> min(Collection<T> elements, Comparator ? super T> c)
static <T> max(Collection<T> elements, Comparator ? super T> c)
// 返回集合中最小的或最大的元素（为清楚起见， 参数的边界被简化了）。
static <T> void copy(List< ? super T> to, List<T> from)
// 将原列表中的所有元素复制到目辱列表的相应位置上。目标列表的长度至少与原列表一样。
static <T> void fi11(List< ? super T> l， T value)
// 将列表中所有位置设置为相同的值。
static <T> boolean addAll(Collection< ? super T> c, T... values) 5.0
// 将所有的值添加到集合中。如果集合改变了， 则返回true。
static <T> boolean replaceAll(List<T> l, T oldValue, T newValue) 1.4
// 用newValue 取代所有值为oldValue 的元素。
static int indexOfSubList(List< ?> l, List< ?> s) 1.4
static int lastIndexOfSubList(List< ?> l, List< ?> s) 1.4
// 返回1 中第一个或最后一个等于S 子列表的索引。如果1 中不存在等于S 的子列表， 则返回-1。
static void swap(List< ?> l, int i, int j) 1.4
// 交换给定偏移量的两个元素。
static void reverse(List< ?> l)
// 逆置列表中元素的顺序。这个方法的时间复杂度为O(n)，n为列表的长度。
static void rotate(List< ?> l, int d) 1.4
// 旋转列表中的元素， 将索引i的条目移动到位置(i+d)%l.size()例如， 将列表[t,a,r] 旋转移2 个位置后得到[a, r，t]。 这个方法的时间复杂度为O(n), n为列表的长度。
static int frequency(Collection< ?> c, Object o) 5.0
// 返回c 中与对象o 相同的元素个数。
boolean disjoint(Collection< ?> cl, Collection< ?> c2) 5.0
// 如果两个集合没有共同的元素， 则返回true。

java.util.Collection 1.2

default boolean removeIf (Predicate< ? super E> fi lter ) 8
// 删除所有匹配的元素。

java.util.List 1.2

default void replaceAll(UnaryOperator<E> op) 8
// 对这个列表的所有元素应用这个操作。

9.6.2 枚举

java.util.Enumeration 1.0

boolean hasMoreElements()
// 如果还有更多的元素可以査看， 则返回true。
E nextElement()
// 返回被检测的下一个元素。如果hasMoreElements() 返回false, 则不要调用这个方法。

java.util.Hashtable 1.0

Enumeration<K> keys()
// 返回一个遍历散列表中键的枚举对象。
Enumeration<V> elements()
// 返回一个遍历散列表中元素的枚举对象。

java.util.Vector 1.0

Enumeration<E> elements()
// 返回遍历向量中元素的枚举对象。

9.6.3 属性映射

java.util.Properties 1.0

Properties()
// 创建一个空的属性映射。
Properties(Properties defaults)
// 创建一个带有一组默认值的空的属性映射。
String getProperty(String key)
// 获得属性的对应关系；返回与键对应的字符串。如果在映射中不存在， 返回默认表中与这个键对应的字符串。
String getProperty(String key, String defaultValue)
// 获得在键没有找到时具有的默认值属性；它将返回与键对应的字符串， 如果在映射中不存在，就返回默认的字符串。
void load(InputStream in)
// 从InputStream 加载属性映射。
void store(OutputStream out, String commentstring)
// 把属性映射存储到OutputStream。

9.6.4 栈

java.util.Stack 1.0

E push(E item)
// 将item 压人桟并返回item。
E pop()
// 弹出并返回栈顶的item。如果栈为空，请不要调用这个方法。
E peek()
// 返回栈顶元素，但不弹出。如果栈为空， 请不要调用这个方法。

9.6.5 位集

java.util.BitSet 1.0

BitSet(int initialCapacity)
// 创建一个位集。
int length()
// 返回位集的“ 逻辑长度”， 即1 加上位集的最高设置位的索引。
boolean get(int bit)
// 获得一个位。
void set(int bit)
// 设置一个位。
void clear(int bit)
// 清除一个位。
void and(BitSet set)
// 这个位集与另一个位集进行逻辑“ AND”。
void or(BitSet set)
// 这个位集与另一个位集进行逻辑“ OR”。
void xor(BitSet set)
// 这个位集与另一个位集进行逻辑“ X0R”。
void andNot(BitSet set)
// 清除这个位集中对应另一个位集中设置的所有位。