All 15 Collections Framework questions
More in Collections Framework
What are the key performance differences between ArrayList and LinkedList for common operations (random access, insertion/removal at various positions), and when would you choose one over the other? What is the contract between equals() and hashCode() that a custom class must satisfy to work correctly as a HashMap key or HashSet element? What is the difference between fail-fast and fail-safe iterators in the Collections Framework, and which collections use each? What are the immutable collection factory methods (List.of(), Set.of(), Map.of()) introduced in Java 9, and how do they differ from Collections.unmodifiableList()? What is the purpose of the Collections utility class's synchronization wrappers (Collections.synchronizedList(), etc.), and how do they differ from genuinely concurrent collections like ConcurrentHashMap? How does PriorityQueue work internally (as a binary heap), and what ordering does it use by default versus with a custom Comparator? How does HashMap's internal implementation work (hashing, bucket array, treeification), and how did its collision-handling strategy change in Java 8? How do you choose between HashMap, LinkedHashMap, and TreeMap based on their different ordering guarantees and performance characteristics? How does TreeMap/TreeSet's red-black tree implementation guarantee O(log n) operations, and what role does the Comparable/Comparator interface play in maintaining sorted order? How would you implement a custom Comparator with multiple sort criteria (e.g., sort by last name, then by first name as a tiebreaker) using the Comparator.comparing() and thenComparing() fluent API?
Advertisement
Back to results for “Collections Framework”
Java › Collections Framework

What is the purpose of the Deque interface, and how does it unify both stack (LIFO) and queue (FIFO) behavior in a single interface?

Intermediate

Answer

Deque (double-ended queue) supports insertion and removal at both ends (addFirst/addLast, removeFirst/removeLast, and their peek equivalents), letting a single interface serve as both a stack (using push()/pop(), which operate on the front) and a FIFO queue (using offer()/poll(), which operate on opposite ends) -- ArrayDeque is the generally recommended, more efficient modern replacement for both the legacy Stack class (which is a poorly-designed, unnecessarily synchronized holdover from Java 1.0) and LinkedList when used purely as a queue/stack, due to better performance characteristics and no unnecessary synchronization overhead.
Deque<Integer> stack = new ArrayDeque<>();
stack.push(1); stack.push(2); stack.push(3);
System.out.println(stack.pop());  // 3, LIFO stack behavior

Deque<Integer> queue = new ArrayDeque<>();
queue.offer(1); queue.offer(2); queue.offer(3);
System.out.println(queue.poll());  // 1, FIFO queue behavior
Real-world example A modern codebase replaces legacy usage of java.util.Stack with ArrayDeque (used via push()/pop()), following the widely-cited JDK documentation recommendation, gaining better performance and avoiding Stack's unnecessary built-in synchronization overhead that's irrelevant for typical single-threaded stack usage.

Common follow-ups: Why is java.util.Stack considered a design mistake in the JDK despite still being available and functional?;What's the performance difference between ArrayDeque and LinkedList when both are used as a Deque?

Concurrency & Threads;Design Patterns in Java
All 15 Collections Framework questions