Sue Brandreth's Learning Resources

This section describes the Java Collections Framework. Here, you will learn what collections are and how they can make your job easier and programs better. You’ll learn about the core elements — interfaces, implementations, aggregate operations, and algorithms — that comprise the Java Collections Framework.

Introduction tells you what collections are, and how they’ll make your job easier and your programs better. You’ll learn about the core elements that comprise the Collections Framework: interfaces, implementations and algorithms.

Interfaces describes the core collection interfaces, which are the heart and soul of the Java Collections Framework. You’ll learn general guidelines for effective use of these interfaces, including when to use which interface. You’ll also learn idioms for each interface that will help you get the most out of the interfaces.

Aggregate Operations iterate over collections on your behalf, which enable you to write more concise and efficient code that process elements stored in collections.

Implementations describes the JDK’s general-purpose collection implementations and tells you when to use which implementation. You’ll also learn about the wrapper implementations, which add functionality to general-purpose implementations.

Algorithms describes the polymorphic algorithms provided by the JDK to operate on collections. With any luck you’ll never have to write your own sort routine again!

Custom Implementations tells you why you might want to write your own collection implementation (instead of using one of the general-purpose implementations provided by the JDK), and how you’d go about it. It’s easy with the JDK’s abstract collection implementations!

Interoperability tells you how the Collections Framework interoperates with older APIs that predate the addition of Collections to Java. Also, it tells you how to design new APIs so that they’ll interoperate seamlessly with other new APIs.

Java Collections Framework
(https://en.wikipedia.org/wiki/Java_collections_framework)

The Java Collections Framework (JCF) is a set of classes and interfaces that implement commonly reusable collection data structures.

Although referred to as a framework, it works in a manner of a library. The JCF provides both interfaces that define various collections and classes that implement them.

History
Collection implementations in pre-JDK 1.2 versions of the Java platform included few data structure classes, but did not contain a collections framework. The standard methods for grouping Java objects were via the array, the Vector, and the Hashtable classes, which unfortunately were not easy to extend, and did not implement a standard member interface.

To address the need for reusable collection data structures, several independent frameworks were developed, the most used being Doug Lea’s Collections package, and ObjectSpace Generic Collection Library (JGL), whose main goal was consistency with the C++ Standard Template Library (STL).

The collections framework was designed and developed primarily by Joshua Bloch, and was introduced in JDK 1.2. It reused many ideas and classes from Doug Lea’s Collections package, which was deprecated as a result.^[4] Sun chose not to use the ideas of JGL, because they wanted a compact framework, and consistency with C++ was not one of their goals.^[7]

Doug Lea later developed a concurrency package, comprising new Collection-related classes. An updated version of these concurrency utilities was included in JDK 5.0 as of JSR 166.

Architecture
Almost all collections in Java are derived from the java.util.Collection interface. Collection defines the basic parts of all collections. The interface states the add() and remove() methods for adding to and removing from a collection respectively. Also required is the toArray() method, which converts the collection into a simple array of all the elements in the collection. Finally, the contains() method checks if a specified element is in the collection. The Collection interface is a subinterface of java.lang.Iterable, so any Collection may be the target of a for-each statement. (The Iterable interface provides the iterator() method used by for-each statements.) All collections have an iterator that goes through all of the elements in the collection. Additionally, Collection is a generic. Any collection can be written to store any class. For example, Collection<String> can hold strings, and the elements from the collection can be used as strings without any casting required. Note that the angled brackets < > can hold a type argument that specifies which type the collection holds.

Java Programming Tutorial – The Collection Framework
(https://www3.ntu.edu.sg/home/ehchua/programming/java/J5c_Collection.html)

Introduction to the Collection Framework

Although we can use an array to store a group of elements of the same type (either primitives or objects). The array, however, does not support so-called dynamic allocation – it has a fixed length which cannot be changed once allocated. Furthermore, array is a simple linear structure. Many applications may require more complex data structure such as linked list, stack, hash table, sets, or trees.

In Java, dynamically allocated data structures (such as ArrayList, LinkedList, Vector, Stack, HashSet, HashMap, Hashtable) are supported in a unified architecture called the Collection Framework, which mandates the common behaviors of all the classes.

A collection, as its name implied, is simply an object that holds a collection (or a group, a container) of objects. Each item in a collection is called an element. A framework, by definition, is a set of interfaces that force you to adopt some design practices. A well-designed framework can improve your productivity and provide ease of maintenance.

The collection framework provides a unified interface to store, retrieve and manipulate the elements of a collection, regardless of the underlying and actual implementation. This allows the programmers to program at the interfaces, instead of the actual implementation.

The Java Collection Framework package (java.util) contains:

1. A set of interfaces,
2. Implementation classes, and
3. Algorithms (such as sorting and searching).

Similar Collection Framework is the C++ Standard Template Library (STL).

Prior to JDK 1.2, Java’s data structures consist of array, Vector, and Hashtable that were designed in a non-unified way with inconsistent public interfaces. JDK 1.2 introduced the unified collection framework, and retrofits the legacy classes (Vector and Hashtable) to conform to this unified collection framework.

JDK 1.5 introduced Generics (which supports passing of types), and many related features (such as auto-boxing and unboxing, enhance for-loop). The collection framework is retrofitted to support generics and takes full advantages of these new features.

To understand this chapter, you have to be familiar with:

• Polymorphism, especially the upcasting and downcasting operations.
• Interfaces, abstract methods and their implementations.
• Generics, Auto-boxing & unboxing, and enhanced for-loop (introduced in JDK 1.5).

You need to refer to the JDK API specification while reading this chapter. The classes and interfaces for the Collection Framework are kept in package java.util.

Get started with the Java Collections Framework – Find out how Sun’s new offering can help you to make your collections more useful and accessible
(http://www.javaworld.com/article/2076800/java-se/get-started-with-the-java-collections-framework.html)