Scala 2
API Specification

This document is the API specification for Scala 2.

Class Summary
| `class` ArrayList [A] Creates a buffer backed by a Java array list.
`abstract` | `class` ConcreteMapWrapper [K, E] A concrete wrapper around a Java map. The identity of the wraper is fixed to the identity of the underlying map.
`abstract` | `class` ConcreteWrapper [A] Describes wrappers around concrete underlying collections. The identity of the wrapper is related strictly to the Java collection being wrapped, which is structurally determined.
| `class` HashMap [K, E] A map that is backed by a Java hash map.
| `class` HashSet [A] A hash set that is backed by a Java hash set.
| `class` IdentityHashMap [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.
| `class` LinkedHashMap [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] A set that is backed by a Java linked hash set, which fixes iteration order in terms of insertion order.
| `class` LinkedList [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.
| `class` TreeMap [K, E] A sorted map that is backed by a Java tree map.
| `class` TreeSet [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] 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.

Trait Summary
`abstract` | `trait` Buffer [A] A mutable sequence that supports element insertion and update.
`abstract` | `trait` BufferIterator [K, A] An iterator for a buffer that supports element update and insertion.
`abstract` | `trait` BufferWrapper [A] Wraps Java lists.
`abstract` | `trait` Collection [A] Analogous to a Java collection.
`abstract` | `trait` CollectionWrapper [A] Used to wrap Java collections in Scala.
`abstract` | `trait` IterableWrapper [A] A wrapper around a Java collection that only supports remove mutations.
`abstract` | `trait` Map [K, E] A mutable map that is compatible with Java maps.
`abstract` | `trait` MapWrapper [K, E] A wrapper around a Java map.
`abstract` | `trait` MutableIterable [A] An iterable collection that supports remove operations. Useful for representing projections of mutable collections that where only the remove operation makes sense.
`abstract` | `trait` MutableIterator [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.
`abstract` | `trait` MutableSeq [A] A mutable sequence that supports the remove operation and is ordered.
`abstract` | `trait` SeqIterator [K, A] An iterator for a sequence that can move both forwards and backwards. over a set of ordered keys.
`abstract` | `trait` Set [A] Analogous to a Java set.
`abstract` | `trait` SetWrapper [A] Used to wrap Java sets.
`abstract` | `trait` Sorted [K, A] Any collection (including maps) whose keys (or elements) are ordered.
`abstract` | `trait` SortedMap [K, E] A map whose keys are sorted.
`abstract` | `trait` SortedMapWrapper [K, E] A sorted map that wraps an underlying Java sorted map.
`abstract` | `trait` SortedSet [A] Analogous to a Java sorted set.
`abstract` | `trait` SortedSetWrapper [A] A wrapper around a Java sorted set. The comparator of the sorted set matches the comparator of this set.

Object Summary
| `object` Collection
| `object` Tests