Scala 2.6.1-final
API Specification

This document is the API specification for Scala Library Documentation

Class Summary
`class` | ArrayList [A](`val override` underlying : java.util.ArrayList)`extends` BufferWrapper[A] Creates a buffer backed by a Java array list.
`trait` | Buffer [A]`extends` Mutable[A]`with` Ranged[Int, A]`with` MutableSeq[A]`with` Collection[A] A mutable sequence that supports element insertion and update.
`trait` | BufferIterator [K, A]`extends` SeqIterator[K, A] An iterator for a buffer that supports element update and insertion.
`trait` | BufferWrapper [A]`extends` Buffer[A]`with` CollectionWrapper[A] Wraps Java lists.
`trait` | Collection [A]`extends` MutableIterable[A] Analogous to a Java collection.
`trait` | CollectionWrapper [A]`extends` Collection[A]`with` IterableWrapper[A] Used to wrap Java collections in Scala.
`class` | HashMap [K, E](`val override` underlying : java.util.HashMap)`extends` MapWrapper[K, E] A map that is backed by a Java hash map.
`class` | HashSet [A](`val override` underlying : java.util.HashSet)`extends` SetWrapper[A] A hash set that is backed by a Java hash set.
`class` | IdentityHashMap [K, E](`val override` underlying : java.util.IdentityHashMap)`extends` MapWrapper[K, E] A map that is backed by a Java identity hash map, which compares keys by their reference-based identity as opposed to using equals and hashCode. An identity hash map will often perform better than traditional hash map because it can utilize linear probing.
`trait` | IterableWrapper [A]`extends` MutableIterable[A] A wrapper around a Java collection that only supports remove mutations.
`class` | LinkedHashMap [K, E](`val override` underlying : java.util.LinkedHashMap)`extends` MapWrapper[K, E] A map that is backed by a Java linked hash map, which fixes iteration order in terms of insertion order.
`class` | LinkedHashSet [A](`val override` underlying : java.util.LinkedHashSet)`extends` SetWrapper[A] A set that is backed by a Java linked hash set, which fixes iteration order in terms of insertion order.
`class` | LinkedList [A](`val override` underlying : java.util.LinkedList)`extends` BufferWrapper[A] Creates a buffer backed by a Java linked list. Includes additional peek/poll/removeFirst/removeLast APIs that are useful in implementing queues and stacks.
`trait` | Map [K, E]`extends` MutableIterable[(K, E)]`with` Map[K, E] A mutable map that is compatible with Java maps.
`trait` | MapWrapper [K, E]`extends` Map[K, E] A wrapper around a Java map.
`trait` | MutableIterable [A]`extends` Collection[A] An iterable collection that supports remove operations. Useful for representing projections of mutable collections that where only the remove operation makes sense.
`trait` | MutableIterator [A]`extends` Iterator[A] An iterator that supports the remove operation. These iterators wrap Java iterators, and so have the same fail fast behavior when dealing with concurrent modifications.
`trait` | MutableSeq [A]`extends` Seq[A]`with` MutableIterable[A] A mutable sequence that supports the remove operation and is ordered.
`trait` | Ranged [K, A]`extends` Ranged[K, A]`with` MutableIterable[A] Any collection (including maps) whose keys (or elements) are ordered.
`trait` | SeqIterator [K, A]`extends` MutableIterator[A] An iterator for a sequence that can move both forwards and backwards. over a set of ordered keys.
`trait` | Set [A]`extends` Set[A]`with` Collection[A] Analogous to a Java set.
`trait` | SetWrapper [A]`extends` Set[A]`with` CollectionWrapper[A] Used to wrap Java sets.
`trait` | Sorted [K, A]`extends` Sorted[K, A]`with` Ranged[K, A] Any collection (including maps) whose keys (or elements) are ordered.
`trait` | SortedMap [K, E]`extends` SortedMap[K, E]`with` Map[K, E]`with` Sorted[K, (K, E)] A map whose keys are sorted.
`trait` | SortedMapWrapper [K, E]`extends` SortedMap[K, E]`with` MapWrapper[K, E] A sorted map that wraps an underlying Java sorted map.
`trait` | SortedSet [A]`extends` SortedSet[A]`with` Set[A]`with` Sorted[A, A] Analogous to a Java sorted set.
`trait` | SortedSetWrapper [A]`extends` SortedSet[A]`with` SetWrapper[A] A wrapper around a Java sorted set. The comparator of the sorted set matches the comparator of this set.
`class` | TreeMap [K, E](`implicit` view$1 : (K) => Ordered[K])`extends` SortedMapWrapper[K, E] A sorted map that is backed by a Java tree map.
`class` | TreeSet [A](`implicit` view$1 : (A) => Ordered[A])`extends` SortedSetWrapper[A] Creates a sorted set that is backed by an underlying Java tree set. Elements of the sorted set are ordered with respect to the ordered view bound of A.
`class` | WeakHashMap [K, E](`val override` underlying : java.util.WeakHashMap)`extends` MapWrapper[K, E] A map that is backed by a Java weak hash map, whose keys are maintained as weak references. Because keys are weak references, the garbage collector can collect them if they are not referred to elsewhere. Useful for implementing caches.

Object Summary
`object` | Buffer `extends` AnyRef
`object` | Collection `extends` AnyRef
`object` | Map `extends` AnyRef
`object` | MutableIterable `extends` AnyRef
`object` | MutableIterator `extends` AnyRef
`object` | MutableSeq `extends` AnyRef
`object` | Set `extends` AnyRef
`object` | SortedMap `extends` AnyRef
`object` | SortedSet `extends` AnyRef