Java LinkedList descendingIterator() Method

Java LinkedList Java LinkedList

descendingIterator()is a utility method in JavaLinkedListprovided by the class, which returns a reverse iterator, allowing us to traverse the elements of the linked list in a back-to-front order.

Method Syntax

Iterator<E> descendingIterator()

Method Features

Reverse Traversal

descendingIterator()The iterator returned by the method traverses the linked list elements in reverse order (from the last element to the first element).

Doubly Linked List Characteristics

This method takes full advantage ofLinkedListthe characteristics of being a doubly linked list, allowing efficient traversal starting from the tail.

Fail-Fast Mechanism

The returned iterator is fail-fast. If the linked list is modified during iteration (except through the iterator's ownremove()method), it will throwConcurrentModificationException。

Use Cases

1. Reverse Data Processing

When you need to process data in a LIFO (Last In, First Out) order, this method is very useful.

2. Stack Simulation

It can be used to simulate the behavior of a stack (Stack), because a stack is a Last In, First Out data structure.

3. Reverse Search

In some algorithms, you may need to search for a specific element from back to front.

Code Examples

Basic Usage Example

Example

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

public class DescendingIteratorExample {
    public static void main(String[] args) {
        // Create a LinkedList
        LinkedList<String> list = new LinkedList<>();
       
        // Add elements
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");
       
        // Get a reverse iterator
        Iterator<String> descendingIterator = list.descendingIterator();
       
        // Traverse using the reverse iterator
        System.out.println("Elements in reverse order:");
        while (descendingIterator.hasNext()) {
            System.out.println(descendingIterator.next());
        }
    }
}

Output:

Elements in reverse order:
Date
Cherry
Banana
Apple

Comparison with Ordinary Iterator

Example

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

public class CompareIterators {
    public static void main(String[] args) {
        LinkedList<Integer> numbers = new LinkedList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
       
        System.out.println("Forward iteration:");
        Iterator<Integer> forward = numbers.iterator();
        while (forward.hasNext()) {
            System.out.println(forward.next());
        }
       
        System.out.println("\nBackward iteration:");
        Iterator<Integer> backward = numbers.descendingIterator();
        while (backward.hasNext()) {
            System.out.println(backward.next());
        }
    }
}

Output:

Forward iteration:
1
2
3
4

Backward iteration:
4
3
2
1

Notes

1. Concurrent Modification

When usingdescendingIterator()if the linked list is modified by other means during iteration (such as directly callingadd()orremove()method), it will throwConcurrentModificationException。

2. Performance Considerations

AlthoughLinkedListthe reverse traversal performance is good (O(1) time to get each element), for large linked lists, you still need to consider memory usage.

3. Difference from ListIterator

descendingIterator()returnsIteratorinterface, whilelistIterator(size())can return aListIterator, the latter provides more operations (such asadd()andset()）。

Frequently Asked Questions

Q1: What is the difference between descendingIterator() and the ordinary iterator()?

A1: The ordinaryiterator()starts forward traversal from the head of the linked list, whiledescendingIterator()starts reverse traversal from the tail of the linked list.

Q2: What is the time complexity of this method?

A2: Getting the iterator itself is an O(1) operation, and eachnext()operation is also O(1), becauseLinkedListis a doubly linked list.

Q3: Can the linked list be modified during iteration?

A3: Only through the iterator's ownremove()method can modifications be made; other modification methods will causeConcurrentModificationException。

Summary

LinkedListofdescendingIterator()Method is a simple but powerful tool that provides the ability to traverse a linked list from back to front. Understanding and using this method correctly can help you handle scenarios that require reverse data access more efficiently. Remember its fail-fast feature, and consider usingListIteratoras an alternative.

Java LinkedList Java LinkedList

Other Extensions