Java Collections Framework - Essay Example

JAVA COLLECTIONS FRAMEWORK Name Student ID Course Instructor Institution Date Java Collections Framework According to Cliford (2008), the term ‘collection’ refers to an object that represents a group of objects, while the term ‘collections framework’ is a unified architecture for representing and manipulating collections, allowing them to be manipulated independently of the details of their representation (Cliford, 2008). The framework enables interoperability among unrelated APIs, minimizes effort in designing and learning new APIs, and enhances software reuse. The java collections framework defines a set of interfaces and their implementations to manipulate collections, which serve as a container for a group of subjects such as a collection of mails or a set of words in a dictionary (Naftalin Maurice & Wadler Philip, 2009). These frameworks allow one to store, retrieve, and update a set of objects; it also provides an API to work with the data structures, such as lists, sets, maps, and trees. History of Java Collections Framework In the past several years, the Java programming language has gone through numerous transformations since the Java Development Kit (JDK) and various additions of packages and classes to the standard library. These transformations in Java language is governed by the Java Community Process (JCP), which suggests and stipulate changes to the Java framework using what is known as Java Specification Requests (JSR). Java Language Specification (JLS), which is controlled under JSR, is used to stipulate the changes to the language (Nell, Daniel, & Chip, 2011). Apart from the numerous transformations that Java has gone through, there are many more considerable changes that the framework of this programming language has undergone. For instance, the framework has expanded from a few hundred classes in JDK 1.0 to more than three thousand in J2SE 5 (Nell, Daniel, & Chip, 2011). In addition, completely new Application Programming Interfaces (APIs), such as Java2D and Swing, have been developed, and quite a number of the original JDK 1.0 methods and classes have since been deplored. In these early versions of the Java, the implementation of collections included some data structure classes; however, they did not have a collections framework. The grouping of Java objects was done through Hashtable and Vector classes. It was, however, difficult to extend these classes and did not implement a standard member interface (Nell, Daniel, & Chip, 2011). A number of independent frameworks were later created to address the need for reusable collection data structures. The most common of these data structures were Generic Collection Library (JGL) created by ObjectSpace and Collections package created by Doug Lea, and their main goal was consistency with the Standard Template Library (STL). The current Java Collection Framework was planned and created by Joshua Bloch. This framework makes use of a number of classes as well as the ideas from Doug Lea's Collections package, which has since become irrelevant as a result of introduction of Bloch’s framework (Naftalin Maurice & Wadler Philip, 2009). Generally, The Java Collections Framework was a significant addition in JDK 1.0; it added a lot of powerful data structures that speed up creation of most important Java applications, and from that time, the Java Collections Framework has become the recognized standard for collection handling in Java (William & Joseph, 2004). Benefits of Java Collections Framework As earlier mentioned the Java Collections Framework enables interoperability among unrelated APIs, minimizes effort in designing and learning new APIs, and enhances software reuse. The framework defines a set of interfaces and their implementations to manipulate collections, which serve as a container for a group of subjects such as a collection of mails or a set of words in a dictionary. Such a framework allows one to store, retrieve, and update a set of objects; it also provides an API to work with the data structures, such as lists, sets, maps, and trees. Some important data structures are however missing in the Java Collections Framework. For instance, the frame work does not have ‘Graphs’ among its data structures, unlike C++ language which has it. Basic Principles of Java Collections Framework Unlike C++ has about six parts, the Java Collections Framework comprises of four major parts namely the core collections interface, general purpose implementation classes, algorithms, and infrastructure code (William & Joseph, 2004). The interfaces are the abstract data types that are supported by the framework. The implementations are the concrete versions of these interfaces, while the algorithms are predefined actions that can be defined on either the interfaces or their implementations. Infrastructure code, on the other hand, facilitates collection manipulation. Each of these parts of the Java Collections Framework is discussed below. Core Collection Interfaces The core collections interface comprises of different types of collections; they represent the abstract data types that are part of the collections framework. They are interfaces and so they do not provide an implementation. The figure below shows the core collections interface for a Java platform. From the diagram, it is clear that the Java Collection Framework has six core interfaces divided into two different inheritance hierarchies: one with Map interface as the root and the other with Collection interface as the root. It is also clear from the figure that a Map is not a Collection per se, but, the Map interface does not declare techniques that return different views of a Map as a Collection object (William & Joseph, 2004). The core collection interfaces comprise of Collection, List, Set, Map, SortedSet, and SortedMap. Below are the characteristics of each of these core collections interfaces: Collection interface: this interface represents a group of objects referred to as its elements, and these elements can be accessed and manipulated via an lterator. Collection interface is the base interface of all collections, and its work is to offer a unified way to manipulate collection objects. Some of the techniques that the Collection interface declares are optional. An optional technique may or may not be executed by a general purpose implementation class (Parsons, 2012). Set Interface: This interface represents a collection that contains no duplicate elements. It models the mathematical set abstraction and it is usually used to represent sets such as processes running in a machine. The Set interface has no other methods except those inherited from the Collection. Set adds restriction that prohibits duplicate elements; it also adds a stronger contract on the behavior of the hasCode and equals operations, thus enabling Set objects to be compared meaningfully, even if their types of implementation are different (Gray, 2007). List interface: The interface represents a collection whose elements are arranged in sequence (Parsons, 2012). This interface allows duplicate elements and its user has precise control over where in the List each element is inserted. The elements can be accessed and manipulated via Listlterator. The different between an ordinary lterator and Listlterator is that the Listlterator offers the means to traverse the list backwards and forwards (Parsons, 2012). Map Interface: This interface represents an object that stores and retrieves an element or value whose within the map is determined by a key. A Map cannot contain duplicate values and a key can only map to a single value (Gray, 2007). It is important to note that a Map is not a Collection even though it offers techniques that return a Collection object that contains its elements. SortedSet interface: This interface represents a Set whose lterator will traverse it elements as per their natural sequence. The interface does prohibit duplicate elements in a set and it is used to sort the elements of a collection in ascending order. Insertions into a sorted set may take longer but recovery will takes place within a short period (Gray, 2007). SortedMap interface: This represents a Map that its elements are kept according to their natural sequence. Insertion into a SortedMap may take long period but recovery takes place within a short period. 1. General Purpose Implementation Classes The Java collection framework offers a set of general implementation classes that are used to implement the core collection interfaces. The General Purpose Implementation Classes is categorized into four: 1. Legacy Implementations - The collection classes from earlier releases, Vector and Hashtable, is retrofitted to implement the collection interfaces. 2. Wrapper Implementations - Add functionality, such as synchronization, to other implementations. 3. Convenience Implementations - High-performance "mini-implementations" of the collection interfaces. 4. Abstract Implementations - Partial implementations of the collection interfaces to facilitate custom implementations. Algorithms These are static techniques that carry out useful functions on collections, such as sorting a list. The Java collection framework offers a set of algorithms that are used to access and manipulate collections (Parsons, 2012). These algorithms are executed as static methods in the Collections class. The Collections class offers techniques to search and sort collections as well as find minimum and maximum elements or values. Infrastructure Java infrastructure comprises of interfaces that provide essential support for the collection interfaces. The Java collections framework offers a number of interfaces and classes whose purpose is to assist the user to manipulate elements, catch collection-specific exceptions, and create collection-aware classes. These interfaces and classes are referred to as infrastructure because they are used across the entire Java collections framework. The major part of the Java infrastructure is the arrays. The utility functions for arrays of primitives and reference objects. Not, strictly speaking, a part from the Collections Framework, this functionality is being added to the Java platform at the same time and relies on some of the same infrastructure (William & Joseph, 2004). References: Cliford J. Berg, 2008. Advanced Java Development for Enterprise Applications. London: Addison-Wesley. Gray Simon, 2007. Data Structures in Java: From Abstract Data Types to the Java Collections Framework. London: Addison-Wesley Pub. Goetz, Brian, 2006. Java Concurrency in Practice. London: Addison-Wesley. Nell Dale, Daniel Joyce, & Chip Weems, 2011. Object-Oriented Data Structures Using Java. Sidney: Jones & Bartlett Publishers. Naftalin Maurice & Wadler Philip, 2009. Java Generics and Collections. Texas: O'Reilly Media, Inc. Parsons David, 2012. Foundational Java: Key Elements and Practical Programming. New York: Springer. William Collins & Joseph Collins, 2004. Data Structures and the Java Collections Framework. New York: McGraw-Hill Higher Education. Read More