Java LinkedList descendingIterator() method
Syntax and Examples

Introduction

The descendingIterator() method in Java's LinkedList class provides a way to traverse the list from its last element to the first. This is particularly useful when you need to process elements in reverse order or when implementing algorithms that require backward iteration.

Syntax

public Iterator<E> descendingIterator()

Parameters

This method takes no parameters.

Parameter	Description
None	N/A

Return Value

The method returns an Iterator<E> that allows you to traverse the list in reverse order. The iterator does not support removal (i.e., its remove() method throws an exception).

Examples

Example 1: Basic Usage

This example demonstrates how to create a LinkedList and use the descendingIterator() method to print its elements in reverse order.

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

public class DescendingIteratorExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");

        Iterator<String> descendingIterator = list.descendingIterator();

        System.out.println("Elements in reverse order:");
        while (descendingIterator.hasNext()) {
            System.out.println(descendingIterator.next());
        }
    }
}

Elements in reverse order:
Date
Cherry
Banana
Apple

Explanation: We create a LinkedList of Strings and then obtain a descendingIterator(). The while loop iterates through the list using this iterator, printing each element until there are no more elements left.

Example 2: Iterating with `hasNext()` and `next()`

This example emphasizes how to correctly use the hasNext() and next() methods of the iterator for safe traversal.

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

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

        Iterator<Integer> reverseIter = numbers.descendingIterator();

        System.out.println("Numbers in descending order:");
        if (reverseIter.hasNext()) {
            int num = reverseIter.next();
            while(true){
              System.out.print(num + " ");
                if(!reverseIter.hasNext()){
                    break;
                }
                num= reverseIter.next();
            }
        }
    }
}

Numbers in descending order: 30 20 10

Explanation: The code initializes a LinkedList with Integer values. It then retrieves a descending iterator and uses it to iterate through the list, printing each number followed by a space.

Example 3: Handling an Empty List

This example shows how to handle cases where the LinkedList is empty when calling descendingIterator(). Although the iterator will be valid, there are no elements to iterate over.

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

public class DescendingIteratorExample3 {
    public static void main(String[] args) {
        LinkedList<Double> emptyList = new LinkedList<>();

        Iterator<Double> reverseIter = emptyList.descendingIterator();

        System.out.println("Iterating over an empty list:");

        if (reverseIter.hasNext()) {
            while (reverseIter.hasNext()) {
                System.out.println(reverseIter.next());
            }
        } else {
            System.out.println("The list is empty.");
        }
    }
}

Iterating over an empty list:
The list is empty.

Explanation: This code demonstrates that even if the LinkedList is empty, calling descendingIterator() creates a valid iterator, but it will not have any elements to iterate over. The code checks for this condition using hasNext() and prints an appropriate message.