Chapter 46: Collections in Java (Part 3) | Full Stack Java Development

2.2 DescendingIterator

Introduction

The descendingIterator() method allows traversal of elements in reverse order. It is available in:

• LinkedList

• ArrayDeque

• TreeSet

How DescendingIterator Works

• The iterator starts from the last element and moves backward.

• Uses hasNext() and next() methods to traverse the collection.

• Returns elements as Object, requiring explicit downcasting when needed.

Example: Accessing Elements in Reverse Order

import java.util.Iterator;
import java.util.LinkedList;

public class Collection15 {
    public static void main(String[] args) {
        LinkedList<Integer> ll1 = new LinkedList<>();
        ll1.add(10);
        ll1.add(20);
        ll1.add(30);
        ll1.add(40);
        ll1.add(50);

        System.out.println(ll1); // Output: [10, 20, 30, 40, 50]

        Iterator<Integer> ditr = ll1.descendingIterator();
        while (ditr.hasNext()) {
            System.out.print(ditr.next() + " "); // Output: 50 40 30 20 10
        }
    }
}

---

Real-World Use Case: Why Collections in Java?

• Java collects data from HTML or user input and stores it in collections.

• A separate class manages database interactions.

• Data retrieval occurs via Java programs querying the database.

• Collections like ArrayList store and transfer data between layers (e.g., servlet to HTML).

---

1. Vector Class

• Part of legacy collections.

• Uses Enumeration instead of Iterator.

• Methods: hasMoreElements() and nextElement().

Example: Accessing Objects with Enumeration

import java.util.Vector;
import java.util.Enumeration;

public class Collection16 {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<>();
        v.add(10);
        v.add(20);
        v.add(30);
        v.add(40);

        System.out.println(v); // Output: [10, 20, 30, 40]

        Enumeration<Integer> em = v.elements();
        while (em.hasMoreElements()) {
            System.out.print(em.nextElement() + " "); // Output: 10 20 30 40
        }
    }
}

---

2. Java Collection Framework Hierarchy

                         Iterable
                            |
                  |
            Collection
    ________________________|_____________________________
   |                        |                            |
 List(Interface)        Queue(Interface)            Set(Interface)
   |                       |      |                      |    |
   |                       |    PriorityQueue(class)     |    |--HashSet(class)
   |-ArrayList(class)      |                             |    |
   |                     Deque(Interface)                |    |---LinkedList(class)
   |-LinkedList(class)-----|                             |
   |                       |                             |
   |-Vector(class)      ArrayDeque(class)                |
           | extends                                     |
         Stack                                        SortedSet(Interface)
                                                         |
                                                    Navigable(Interface)
                                                         |
                                                      TreeSet

Key Points

• LinkedList implements both List and Deque interfaces.

• Deque extends Queue, adding specialized methods.

• PriorityQueue has fewer methods than ArrayDeque because it directly implements Queue.

• TreeSet implements NavigableSet for sorted elements.

---

3. Accessing Objects in Collections

---

4. Summary of Java Collections

Notes

• TreeSet sorts elements automatically; hence, it does not allow null.

• PriorityQueue follows a min-heap structure, preventing null values.

• HashSet does not guarantee order, but LinkedHashSet preserves insertion order.

---

5. Tight Coupling vs. Loose Coupling in Java Collections

Example: Using Loose and Tight Coupling

import java.util.*;

public class Collection17 {
    public static void main(String[] args) {
        ArrayList<Integer> al = new ArrayList<>(); // Tight coupling

        List<Integer> list = new ArrayList<>();  // Loose coupling (Interface reference)

        Queue<Integer> q = new ArrayDeque<>();
        List<Integer> li = new LinkedList<>();
        Deque<Integer> ql = new LinkedList<>();
        Collection<Integer> c = new LinkedList<>();

        // peek() is present in Deque interface
        ql.peek();

        HashSet<Integer> hs = new HashSet<>();  // Tight coupling
        Set<Integer> se = new HashSet<>();      // Loose coupling
    }
}

---