What are Collections?
A collection — sometimes called a container — is simply an
object that groups multiple elements into a single unit. Collections are used
to store, retrieve, manipulate, and communicate aggregate data. Typically, they
represent data items that form a natural group, such as a poker hand (a
collection of cards), a mail folder (a collection of letters), or a telephone
directory (a mapping of names to phone numbers).
What is collection Framework?
A collections framework is a unified architecture for
representing and manipulating collections.
All collections frameworks contain
These are abstract data types that represent collections. Interfaces allow
collections to be manipulated independently of the details of their
representation. In object-oriented languages, interfaces generally form a
These are the concrete implementations of the collection interfaces. In
essence, they are reusable data structures.
These are the methods that perform useful computations, such as searching and
sorting, on objects that implement collection interfaces. The algorithms are
said to be polymorphic: that is, the same method can be used on many different
implementations of the appropriate collection interface. In essence, algorithms
are reusable functionality.
The core collection interfaces encapsulate different types
of collections. These interfaces allow collections to be manipulated
independently of the details of their representation. Core collection interfaces
are the foundation of the Java Collections Framework.
A Set is a
special kind of Collection, a SortedSet is
a special kind of Set, and so forth. Note also that the hierarchy consists of
two distinct trees — a Map is not a true Collection.
— the root of the collection hierarchy. A collection represents a group of
objects known as its elements. The Collection interface is the least common
denominator that all collections implement and is used to pass collections
around and to manipulate them when maximum generality is desired. Some types of
collections allow duplicate elements, and others do not. Some are ordered and
others are unordered. The Java platform doesn't provide any direct
implementations of this interface but provides implementations of more specific
sub interfaces, such as Set and List.
· Set —
a collection that cannot contain duplicate elements. This interface models the
mathematical set abstraction and is used to represent sets, such as the cards
comprising a poker hand, the courses making up a student's schedule, or the
processes running on a machine. See also The Set Interface section.
— an ordered collection (sometimes called a sequence). Lists can contain
duplicate elements. The user of a List generally has precise control over where
in the list each element is inserted and can access elements by their integer
index (position). If you've used Vector, you're familiar with the general
flavor of List. Also see The List Interface section.
· Queue —
a collection used to hold multiple elements prior to processing. Besides basic
Collection operations, a Queue provides additional insertion, extraction, and
— a collection used to hold multiple elements prior to processing. Besides
basic Collection operations, a Deque provides additional insertion, extraction,
and inspection operations. Deques can be used both as FIFO (first-in,
first-out) and LIFO (last-in, first-out). In a deque all new elements can be
inserted, retrieved and removed at both ends. Also see The Deque Interface
· Map —
an object that maps keys to values. A Map cannot contain duplicate keys; each
key can map to at most one value. If you've used Hashtable, you're already familiar with the basics of Map. Also see
The Map Interface section.
— a Set that maintains its elements in ascending order. Several additional
operations are provided to take advantage of the ordering. Sorted sets are used
for naturally ordered sets, such as word lists and membership rolls. Also see
The SortedSet Interface section.
— a Map that maintains its mappings in ascending key order. This is the Map
analog of SortedSet. Sorted maps are used for naturally ordered collections of
key/value pairs, such as dictionaries and telephone directories. Also see The
SortedMap Interface section
Note: Sorted set and Sorted Map are merely sorted versions of Set and Map
Advantages of Java Collection Framework
programming effort: By providing useful data structures and algorithms, the
Collections Framework frees you to concentrate on the important parts of your
program rather than on the low-level "plumbing" required to make it
work. By facilitating interoperability among unrelated APIs, the Java Collections
Framework frees you from writing adapter objects or conversion code to connect
program speed and quality: This Collections Framework provides
high-performance, high-quality implementations of useful data structures and
algorithms. The various implementations of each interface are interchangeable,
so programs can be easily tuned by switching collection implementations.
Because you're freed from the drudgery of writing your own data structures,
you'll have more time to devote to improving programs' quality and performance.
interoperability among unrelated APIs: The collection interfaces are the
vernacular by which APIs pass collections back and forth. If my network
administration API furnishes a collection of node names and if your GUI toolkit
expects a collection of column headings, our APIs will interoperate seamlessly,
even though they were written independently.
effort to learn and to use new APIs: Many APIs naturally take collections
on input and furnish them as output. In the past, each such API had a small
sub-API devoted to manipulating its collections. There was little consistency
among these ad hoc collections sub-APIs, so you had to learn each one from
scratch, and it was easy to make mistakes when using them. With the advent of
standard collection interfaces, the problem went away.
effort to design new APIs: This is the flip side of the previous advantage.
Designers and implementers don't have to reinvent the wheel each time they
create an API that relies on collections; instead, they can use standard
software reuse: New data structures that conform to the standard collection
interfaces are by nature reusable. The same goes for new algorithms that
operate on objects that implement these interfaces.
**This document is referred from Oracle Java Docs