Produces a Map mapping elements to frequencies, where each entry maps a distinct member of the given iterable elements to the number of times it occurs among the given elements.

Produces a Map grouping the given elements into sequences under the group keys provided by the given grouping function.

Create a TreeMap with comparable keys, sorted by the natural ordering of the keys.

Create a TreeSet with comparable keys, sorted by the natural ordering of the keys.

Groups the given elements into two sequences, the first containing elements selected by the given predicate function, and the second containing elements rejected by the given predicate function.

Wrap the given List, preventing attempts to narrow the returned List to MutableList.

Wrap the given Map, preventing attempts to narrow the returned Map to MutableMap.

Wrap the given Set, preventing attempts to narrow the returned Set to MutableSet.

Protocol for mutation of a MutableList.

Protocol for mutation of a MutableMap.

A List supporting addition, insertion, removal, and replacement of its elements.

A Map supporting addition of new entries and removal of existing entries.

A Set supporting addition of new elements and removal of existing elements.

Abstract supertype of datastructures that can be used as FIFO queues.

A Queue has a well-defined Queue.front and Queue.back. Elements may be added to the back of the queue by Queue.offer(), and removed from the front of the queue by Queue.accept().

Note that many Queues are also Lists, but there is no defined relationship between the order of elements in the list and the direction of the queue. In particular, the front of the queue may be first element of the list, or it may be the last element of the list.

Protocol for mutation of a MutableSet.

A Map that maintains its entries in sorted order.

A Set that maintains its entries in sorted order.

Abstract supertype of datastructures that can be used as LIFO stacks.

A Stack has a well-defined Stack.top. Elements may be added to the top of the stack by Stack.push(), and removed from the top of the stack by Stack.pop().

Note that many Stacks are also Lists, but there is no defined relationship between the order of elements in the list and the direction of the stack. In particular, the top of the stack may be first element of the list, or it may be the last element of the list.

A MutableList implemented using a backing Array. Also:

• a Stack, where the top of the stack is the last element of the list, and
• a Queue, where the front of the queue is the first element of the list and the back of the queue is the last element of the list.

The size of the backing Array is called the capacity of the ArrayList. The capacity of a new instance is specified by the given initialCapacity. The capacity is increased when ArrayList.size exceeds the capacity. The new capacity is the product of the current capacity and the given growthFactor.

A MutableMap implemented as a hash map stored in an Array of singly linked lists of Entrys. Each entry is assigned an index in the array according to the hash code of its key. The hash code of a key is defined by Object.hash.

The stability of a HashMap controls its iteration order:

• A linked map has a stable and meaningful order of iteration. The entries of the map form a linked list, where new entries are added to the end of the linked list. Iteration of the map follows this linked list, from least recently added elements to most recently added elements.
• An unlinked map has an unstable iteration order that may change when the map is modified. The order itself is not meaningful to a client.

The management of the backing array is controlled by the given hashtable.

A MutableSet implemented as a hash set stored in an Array of singly linked lists. Each element is assigned an index of the array according to its hash code. The hash code of an element is defined by Object.hash.

The stability of a HashSet controls its iteration order:

• A linked set has a stable and meaningful order of iteration. The elements of the set form a linked list, where new elements are added to the end of the linked list. Iteration of the set follows this linked list, from least recently added elements to most recently added elements.
• An unlinked set has an unstable iteration order that may change when the set is modified. The order itself is not meaningful to a client.

The management of the backing array is controlled by the given hashtable.

Performance-related settings for a hashtable based collection like HashMap or HashSet.

The size of the backing Array is called the capacity of the hashtable.

• The capacity of a new instance is specified by the given Hashtable.initialCapacity.
• The capacity is increased, and the elements rehashed, when the ratio of collection size to capacity exceeds the given Hashtable.loadFactor.
• The new capacity is the product of the current capacity and the given Hashtable.growthFactor.

An identity map implemented as a hash map stored in an Array of singly linked lists of Entrys. The hash code of a key is defined by identityHash(). Note that an IdentitySet is not a Map, since it does not obey the semantics of a Map. In particular, it may contain multiple keys which are equal, as determined by the == operator.

An identity set implemented as a hash set stored in an Array of singly linked lists. The hash code of an element is defined by identityHash(). Note that an IdentitySet is not a Set, since it does not obey the semantics of a Set. In particular, it may contain multiple elements which are equal, as determined by the == operator.

A MutableList implemented as a singly linked list. Also:

• a Stack, where the top of the stack is the first element of the list, and
• a Queue, where the front of the queue is the first element of the list and the back of the queue is the last element of the list.

A Queue implemented using a backing Array where the front of the queue is the smallest element according to the order relation defined by PriorityQueue.compare() function. Note that this implementation doesn't guarantee the back/last element to be the largest element of the queue.

The size of the backing Array is called the capacity of the PriorityQueue. The capacity of a new instance is specified by the given PriorityQueue.initialCapacity. The capacity is increased when PriorityQueue.size exceeds the capacity. The new capacity is the product of the needed capacity and the given PriorityQueue.growthFactor.

A Map with exactly one SingletonMap.entry.

A Set with exactly one SingletonSet.element.

A MutableMap implemented using a red/black tree. Entries in the map are maintained in a sorted order, from smallest to largest key, as determined by the given comparator function.

A MutableSet implemented using a red/black tree. Elements of the set are maintained in a sorted order, from smallest to largest, as determined by the given comparator function.