Java Collections Framework
The Java Collections Framework(JCF) is one of the most widely used APIs in Java because it provides a collection of versatile data structures. In programming, we work with data that we store in appropriate data structures in memory, and these most often need to be categorized, processed, sorted, filtered, or transformed into another form of data.
V článku sa dozvieš:
On our blog, we have dedicated articles to data structures. If you’ve read our articles, you’ll know that programming an efficient, optimized, reusable data structure is no easy task. This is one of the reasons why we use frameworks, a kind of libraries that already contain pre-programmed sets of components immediately usable in projects, so that the programmer can work on project-specific business logic.
And so that we don’t have to program everything ourselves on a greenfield site, a high-level programming language such as Java offers programmers a collection of optimized, universally usable data containers in which they can store their data.
By a collection, we mean a collection of type-like objects grouped into a single data structure and used to store, retrieve, manipulate, and communicate with aggregated data. Examples might be a customer list, an email inbox, or a phone directory mapping client names to their phone numbers.
In this article, we will explain how the Java Collections Framework came to be, what it contains, and why we should start learning how to use all of its benefits right away.
History of Java Collections Framework
The collection framework was primarily designed and developed by Joshua Bloch and was introduced in Java 2 (JDK 1.2) in 1998. If you’ve read one of the best books on Java, Effective Java 3rd Edition, Joshua is certainly no stranger to you. His main motivation was to deliver an easily extensible, adaptable, high-performance framework that would include a set of core collections (such as dynamic arrays, linked lists, tree structures, hash tables, etc.) and their implementation would be very efficient and optimized for performance.
Prior to this release, developers were reliant on grouping objects via arrays, Vector and Hashtable classes, which were not easy to extend and did not implement a uniform interface. Thus, programmers mostly programmed their own data structures or reached for some non-standard third-party library.
Gradually, the JCF evolved and acquired new functions. In Java 5, generic classes were added to increase the type safety of collections. Later, with the advent of Java 8, collections were extended to include streams, lambda expressions, and the ability to do functional programming, which further simplified working with data structures. These have been the two most important updates to the framework so far, but the JCF is still a work in progress and each update of the JDK brings minor or major improvements to the collections.
Java Collections Framework hierarchy – architecture
The collections framework is a unified architecture for representing and manipulating collections. It consists of three parts: interfaces, class implementations, and algorithms.
Interfaces: these are abstract data types (ADTs) that represent a collection. Interfaces allow collections to be manipulated independently of their internal representation. They are important because they allow to form a hierarchy of classes.
Classes: these reusable structures offer concrete implementations of collection interfaces.
Algorithms: computational methods on collections such as searching, sorting or editing collections.
Basic JCF interfaces
The most important JCF interfaces that provide a general structure for working with different types of collections include: Iterable, Collection, List, Queue, Set a Map.
Iterable interface
The Iterable interface is a basic interface in Java that allows iteration over a collection of objects. Located in the java.lang package, it is available for all collections without the need for import. Collections implementing Iterable can be traversed using a for-each loop, which greatly simplifies usage. The interface provides a single method.
| Method | Description |
| Iterator <E> iterator() | Returns an iterator of type E for the collection. |
Iterator interface
It is located in the java.util package. In order to use iterator to traverse the collection we need to override and provide an implementation for the following methods.
| Method | Description |
| boolean hasNext() | Returns true if the iteration has more elements. |
| E next() | Returns the next element of E in the iteration |
| void remove() | Removes the last element returned by the iterator (optional operation). |
Interface Collection
A basic interface that represents a group of objects. It is the parent of specialized interfaces such as List, Set, and Queue, for which it defines a series of abstract methods (that is, only the method signature is available) that child collections must implement. This makes working with collections similar and intuitive. It is found in the java.util package, as are all child collections.
| Method | Description |
| boolean add(E e) | Adds the specified element to the collection (optional operation). |
| void clear() | Removes all elements from this collection (optional operation). |
| boolean contains(Object o) | Returns true if this collection contains the specified element. |
| boolean equals(Object o) | Compares the specified object with this collection for equality. |
| boolean isEmpty() | Returns true if this collection contains no elements. |
| Iterator<E> iterator() | Returns an iterator over the elements in this collection. |
| boolean remove(Object o) | Removes one instance of the specified element from this collection, if present (optional operation). |
| int size() | Returns the number of elements in this collection. |
| Object[] toArray() | Returns an array containing all the elements in this collection. |
Interface List
Defines an interface for collections where the order of elements matters (called ordered collections) and may contain duplicate elements. Access to elements is based on indexes, through which their position in the collection is determined.
Examples of implementations of this interface are ArrayList, LinkedList, Vector, Stack collections.
Interface Set
Defines an interface for collections that contain a set of unique elements without duplicates. The elements are not stored in any particular order (called unordered collections). However, some implementations such as LinkedHashSet maintain the order in which elements are inserted. The insertion of one null element into this collection Quantity is allowed e.g. for a HashSet collection, but some implementations like TreeSet do not allow the insertion of null elements.
Examples of implementations of this interface are the HashSet, TreeSet and LinkedHashSet collections.
Queue interface
Defines an interface for collections that should be processed according to the FIFO (First In, First Out) principle, although some implementation variants such as priority queues may not follow this.
Examples of implementations of this interface are the LinkedList, PriorityQueue and ArrayDequeue collections.
Interface Map
This interface belongs to the JCF, but has no relationship with the Collection interface, which works with one entity, while the Map interface works with two – a unique key and its corresponding object. For example, the key might be a phone number, and the object could be the owner of that number. To retrieve an object from the Map collection, we usually need to use its key.
Examples of implementations of this interface are the HashMap, TreeMap and LinkedHashMap collections.
Algorithms
JCF also includes a number of algorithms for manipulating collections. These are implemented as static methods in the Collections class. Among the most important are:
- Sort: Using the sort method, you can sort the collection by natural order or based on a comparator.
- Search: algorithms such as binarySearch allow efficient search for elements in a sorted collection.
- Edit: Algorithms such as reverse, shuffle and rotate allow different transformations of collections.
- Synchronization: using methods such as synchronizedList it is possible to create safe versions of collections for multithreaded processing.
Benefits of Java Collections Framework
Let’s summarise the benefits offered by the JCF:
- Optimized collections for high performance and high amount of data (collection elements).
- The implementations of the collections are similar (due to the hierarchies of interfaces and classes).
- It saves the time needed to implement and debug custom data structures and algorithms.
- Facilitates code reuse.
Conclusion
The Java Collections Framework provides us with a huge number of interfaces, classes and algorithms for a wide variety of development challenges related to working efficiently with data structures and data in Java. While it is challenging to master its complexity at the outset, the investment of time in understanding the JCF will only pay off for developers in the long run.
