Java ArrayDeque push() Method

The ArrayDeque class in Java provides the push(E e) method to insert an element at the front of the deque.

Table of Contents

1. Introduction
2. push Method Syntax
3. Examples
   • Adding Elements to the Front of the ArrayDeque Using push
   • Handling Capacity and Return Values
4. Real-World Use Case
   • Use Case: Task Management System
5. Conclusion

Introduction

The ArrayDeque.push(E e) method is used to insert an element at the front of the deque. This method is equivalent to addFirst(E e) and can be used when you need to add elements to the front of the deque, similar to the stack push operation.

push Method Syntax

The syntax for the push method is as follows:

public void push(E e)

• The method takes a single parameter e of type E, which is the element to be added to the front of the deque.
• The method does not return any value.

Examples

Adding Elements to the Front of the ArrayDeque Using push

The push method can be used to insert elements at the front of an ArrayDeque.

Example

import java.util.ArrayDeque;

public class ArrayDequePushExample {
    public static void main(String[] args) {
        // Creating an ArrayDeque of Strings
        ArrayDeque<String> tasks = new ArrayDeque<>();

        // Adding elements to the ArrayDeque using push
        tasks.push("Complete project report");
        tasks.push("Email client updates");
        tasks.push("Prepare presentation");

        // Printing the ArrayDeque
        System.out.println("ArrayDeque: " + tasks);
    }
}

Output:

ArrayDeque: [Prepare presentation, Email client updates, Complete project report]

Handling Capacity and Return Values

While ArrayDeque typically does not have a fixed capacity, the push method can be used in capacity-constrained contexts where the deque dynamically resizes as needed.

Example

import java.util.ArrayDeque;

public class ArrayDequeCapacityExample {
    public static void main(String[] args) {
        // Creating an ArrayDeque with an initial capacity
        ArrayDeque<String> tasks = new ArrayDeque<>(3);

        // Adding elements to the ArrayDeque using push
        tasks.push("Complete project report");
        tasks.push("Email client updates");
        tasks.push("Prepare presentation");

        // Printing the ArrayDeque
        System.out.println("ArrayDeque: " + tasks);
    }
}

Output:

ArrayDeque: [Prepare presentation, Email client updates, Complete project report]

Note: In the standard implementation, ArrayDeque does not have a fixed capacity and will dynamically resize as needed.

Real-World Use Case

Use Case: Task Management System

In a task management system, high-priority tasks can be added to the front of the deque using the push method, ensuring they are processed first.

Example

import java.util.ArrayDeque;

public class TaskManagementSystem {
    public static void main(String[] args) {
        // Creating an ArrayDeque to store tasks
        ArrayDeque<Task> tasks = new ArrayDeque<>();

        // Adding tasks to the ArrayDeque using push
        tasks.push(new Task("Complete project report", 2));
        tasks.push(new Task("Email client updates", 1));
        tasks.push(new Task("Prepare presentation", 3));

        // Printing the tasks in the ArrayDeque
        System.out.println("Tasks in ArrayDeque: " + tasks);
    }
}

class Task {
    private String description;
    private int priority;

    public Task(String description, int priority) {
        this.description = description;
        this.priority = priority;
    }

    @Override
    public String toString() {
        return description + " (Priority: " + priority + ")";
    }
}

Output:

Tasks in ArrayDeque: [Prepare presentation (Priority: 3), Email client updates (Priority: 1), Complete project report (Priority: 2)]

Conclusion

The ArrayDeque.push(E e) method in Java is a fundamental operation for inserting elements at the front of an ArrayDeque. Understanding how to use this method is essential for managing collections where elements need to be added to the front of the deque in a capacity-constrained or dynamic manner.