Introduction to Collections Framework
The Collections Framework provides a
well-designed set of interfaces and classes for storing and manipulating the groups
of data into a single unit. The collections framework is a unified architecture
which is used to represent
and manipulate collections. The framework allows the collections to get manipulated independently,
additionally it reduces the programming efforts and increases
It includes implementation of interfaces and algorithms. Basically it is a unified architecture that consists
the following collections:
- Interfaces: These
are the abstract data types that represent collections. With the help of
interfaces we manipulate collections independently. A hierarchy is generally formed
in object-oriented languages
- Implementations: They
are the reusable data structures with the concrete implementations of
the collection interfaces.
Algorithms are used to perform computations, such as searching,
sorting etc on the objects that implement collection interfaces. They
provide reusable functionality i.e. the same method can be used with
different implementations of the collection interfaces.
Hence they are also said to be polymorphic.
Implementations: These are the primary implementations of the
Interfaces that provide essential support for the collection
Utilities: Utility functions for arrays of primitives and
This functionality was added to the Java platform
as a part of the Collections Framework.
Advantages of collections
The Java Collections Framework
provides the following benefits:
the efforts to learn and use the new APIs: We
need not to learn multiple ad hoc collection APIs.
software reuse: It
provides a standard interface for collections that fosters software reuse
and also provides algorithms to manipulate them.
the efforts to design new APIs: It reduces
the efforts required to design and implement APIs by eliminating the need to
produce ad hoc collections APIs.
the programming efforts: It
provides useful data structures and algorithms that reduces programming
efforts due to which we need not to write them ourselves.
provides high-performance implementations of useful data structures and
algorithms that increases the performance.
interoperability between the unrelated APIs: It helps
in establishing a common language to pass collections back and forth to
provide interoperability between the unrelated APIs.
resizable capability: Collection
is resizable i.e. it can grow dynamically.
of collections framework:
must cast to correct type.
the compile-time type checking.