Java Collections Framework

Before Java 2, Java provided ad-hoc classes such as Dictionary, Vector, Stack, and Properties to store and manipulate groups of objects.

Although these classes were useful, they lacked a central, unifying theme. As a result, the way to use the Vector class was significantly different from using the Properties class.

The Collections Framework was designed to meet several objectives:

-

The framework must be high-performance. The implementations of basic collections (dynamic arrays, linked lists, trees, hash tables) must be efficient.

-

The framework allows different types of collections to work in a similar manner and with high interoperability.

-

Extending and adapting a collection must be straightforward.

To this end, the entire collections framework is designed around a set of standard interfaces. You can use these interfaces' standard implementations directly, such as LinkedList, HashSet, and TreeSet, or you can implement your own collections through these interfaces.

From the Collections Framework diagram above, you can see that the Java Collections Framework mainly includes two types of containers: one is a Collection, which stores a collection of elements, and the other is a Map, which stores key/value pairs. The Collection interface has three subtypes: List, Set, and Queue. Below these are some abstract classes, and finally, concrete implementation classes, commonly used ones include ArrayList, LinkedList, HashSet, LinkedHashSet, HashMap, LinkedHashMap, and so on.

The Collections Framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:

-** Abstract data types representing collections. For example, Collection, List, Set, Map, etc. Multiple interfaces are defined to manipulate collection objects in different ways.

Interfaces:

-

Implementations (classes): These are concrete implementations of the collection interfaces. Essentially, they are reusable data structures, such as ArrayList, LinkedList, HashSet, HashMap.

-

Algorithms: These are useful computations performed by methods in objects that implement collection interfaces, such as searching and sorting. These algorithms are polymorphic, as the same methods can be implemented differently on similar interfaces.

In addition to collections, the framework also defines several Map interfaces and classes. Maps store key/value pairs. Although Maps are not collections, they are fully integrated into collections.

Collections Framework Architecture

The Java Collections Framework provides a set of high-performance, easy-to-use interfaces and classes. The Java Collections Framework is located in the java.util package, so importing this package is necessary when using the Collections Framework.

Collection Interfaces

The Collections Framework defines several interfaces. This section provides an overview of each interface:

Differences Between Set and List

-

1. The Set interface instance stores unordered, non-duplicate data. The List interface instance stores ordered, duplicate elements.

-

2. Set retrieval efficiency is low, but deletion and insertion efficiency is high; insertion and deletion do not change the position of elements <Implemented by HashSet, TreeSet>.

-

3. List is similar to an array but can grow dynamically, automatically adjusting its length based on the actual data stored. It offers high efficiency for element lookup but low efficiency for insertion and deletion, as these operations may shift other elements. <Implementing classes include ArrayList, LinkedList, Vector>.

Collection Implementing Classes (Collection Classes)

Java provides a set of standard collection classes that implement the Collection interface. Some of these are concrete classes that can be used directly, while others are abstract classes that provide partial implementations of the interface.

The standard collection classes are summarized in the following table:

In previous tutorials, we have discussed classes defined in the java.util package, as follows:

Collection Algorithms

The collection framework defines several algorithms that can be used with collections and maps. These algorithms are defined as static methods in the collection classes. When trying to compare incompatible types, some methods can throw a ClassCastException. When attempting to modify an unmodifiable collection, an UnsupportedOperationException is thrown.

Collections define three static variables: EMPTY_SET, EMPTY_LIST, and EMPTY_MAP. These variables are all immutable.

How to Use Iterators

Typically, you will want to traverse the elements of a collection. For example, displaying each element in the collection.

Traversing arrays is usually done using for loops or enhanced for loops, which can also be used in the collection framework. However, there is another method that uses iterators to traverse the collection framework. It is an object that implements the Iterator interface or the ListIterator interface.

Iterators allow you to obtain or remove elements of a collection through looping. ListIterator extends Iterator to allow bidirectional traversal of a list and modification of elements.

Traversing an ArrayList

Example

import java.util.*;

public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     // First method: using For-Each to traverse the List
     for (String str : list) {            // You can also rewrite this as for(int i=0;i&lt;list.size();i++)
        System.out.println(str);
     }

     // Second method: converting the list to an array and traversing
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i&lt;strArray.length;i++) // Here you can also rewrite this as for(String str:strArray)
     {
        System.out.println(strArray[i]);
     }

    // Third method: using an iterator for traversal

     Iterator<String> ite=list.iterator();
     while(ite.hasNext())// Check if there is a next value
     {
         System.out.println(ite.next());
     }
 }
}

Analysis:

All three methods are used to traverse the ArrayList collection. The third method uses an iterator, which does not need to worry about exceeding the length of the collection during traversal.

Traversing a Map

Example

import java.util.*;

public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");

      // First method: commonly used, double key retrieval
      System.out.println("Traversing key and value through Map.keySet:");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }

      // Second method
      System.out.println("Traversing key and value through Map.entrySet using iterator:");

Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<String, String> entry = it.next();
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

// Third method: Recommended, especially for large capacities
System.out.println("Iterating over keys and values using Map.entrySet");
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

// Fourth method
System.out.println("Iterating over all values using Map.values(), but cannot iterate over keys");
for (String v : map.values()) {
    System.out.println("value= " + v);
}
}

How to Use Comparators

TreeSet and TreeMap store elements in a sorted order. However, this is precisely defined by a comparator.

This interface allows us to sort a collection in different ways.

Summary

The Java Collections Framework provides programmers with prepackaged data structures and algorithms to manipulate them.

A collection is an object that can hold references to other objects. The collection interface declares the operations that can be performed on each type of collection.

The classes and interfaces of the collections framework are in the java.util package.

Any object added to a collection class is automatically converted to the Object type, so it needs to be cast back to its original type when retrieved.