Kotlin ArrayDeque

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

In Kotlin, ArrayDeque is a double-ended queue implementation that provides efficient insert and delete operations at both ends. It is part of the Kotlin standard library and belongs to the kotlin.collections package.

What is ArrayDeque?
Creating an ArrayDeque
Common Operations
Examples of ArrayDeque
Real-World Use Case
Conclusion

1. What is ArrayDeque?

ArrayDeque in Kotlin is a dynamic array that functions as a double-ended queue, allowing for fast insertion and deletion operations at both the front and the back. It is part of the kotlin.collections package.

2. Creating an ArrayDeque

You can create an ArrayDeque using the constructor or by initializing it with elements.

Example

val deque = ArrayDeque<Int>() // Creates an empty ArrayDeque
val dequeWithElements = ArrayDeque(listOf(1, 2, 3)) // Creates an ArrayDeque with elements

3. Common Operations

ArrayDeque supports various operations for adding, removing, and accessing elements.

Adding Elements

addFirst(element: T): Adds an element at the front.
addLast(element: T): Adds an element at the back.

Removing Elements

removeFirst(): Removes and returns the first element.
removeLast(): Removes and returns the last element.

Accessing Elements

first(): Returns the first element without removing it.
last(): Returns the last element without removing it.
get(index: Int): Returns the element at the specified index.

Checking Size

size: Returns the number of elements in the deque.
isEmpty(): Checks if the deque is empty.
isNotEmpty(): Checks if the deque is not empty.

Clearing Deque

clear(): Removes all elements from the deque.

4. Examples of ArrayDeque

Example 1: Basic Operations

This example demonstrates basic operations with ArrayDeque.

fun main() {
    val deque = ArrayDeque<Int>()
    deque.addFirst(1)
    deque.addLast(2)
    deque.addFirst(0)

    println("First element: ${deque.first()}") // Output: First element: 0
    println("Last element: ${deque.last()}") // Output: Last element: 2

    deque.removeFirst()
    println("After removing first: $deque") // Output: After removing first: [1, 2]

    deque.removeLast()
    println("After removing last: $deque") // Output: After removing last: [1]
}

Output:

First element: 0
Last element: 2
After removing first: [1, 2]
After removing last: [1]

Example 2: Using `ArrayDeque` with Strings

This example demonstrates using ArrayDeque with strings.

fun main() {
    val deque = ArrayDeque<String>()
    deque.addLast("Kotlin")
    deque.addFirst("Hello")
    deque.addLast("World")

    println("Deque: $deque") // Output: Deque: [Hello, Kotlin, World]

    val removedFirst = deque.removeFirst()
    println("Removed first element: $removedFirst") // Output: Removed first element: Hello
    println("Deque after removing first: $deque") // Output: Deque after removing first: [Kotlin, World]

    val removedLast = deque.removeLast()
    println("Removed last element: $removedLast") // Output: Removed last element: World
    println("Deque after removing last: $deque") // Output: Deque after removing last: [Kotlin]
}

Output:

Deque: [Hello, Kotlin, World]
Removed first element: Hello
Deque after removing first: [Kotlin, World]
Removed last element: World
Deque after removing last: [Kotlin]

Example 3: Checking Size and Clearing

This example demonstrates how to check the size of the deque and clear it.

fun main() {
    val deque = ArrayDeque(listOf(1, 2, 3, 4, 5))
    println("Initial deque: $deque") // Output: Initial deque: [1, 2, 3, 4, 5]
    println("Size: ${deque.size}") // Output: Size: 5

    deque.clear()
    println("Deque after clear: $deque") // Output: Deque after clear: []
    println("Is deque empty: ${deque.isEmpty()}") // Output: Is deque empty: true
}

Output:

Initial deque: [1, 2, 3, 4, 5]
Size: 5
Deque after clear: []
Is deque empty: true

5. Real-World Use Case: Task Scheduling

ArrayDeque can be used in task scheduling where tasks need to be processed in both FIFO and LIFO order.

Example: Task Scheduling

fun main() {
    val tasks = ArrayDeque<String>()
    tasks.addLast("Task1")
    tasks.addLast("Task2")
    tasks.addFirst("Urgent Task")

    while (tasks.isNotEmpty()) {
        val task = tasks.removeFirst()
        println("Processing: $task")
    }
}

Output:

Processing: Urgent Task
Processing: Task1
Processing: Task2

Explanation:
This example demonstrates using ArrayDeque to manage and process tasks in a priority order.

Conclusion

ArrayDeque in Kotlin is a versatile and efficient double-ended queue from the kotlin.collections package, ideal for scenarios requiring fast insertions and deletions at both ends. Properly utilizing ArrayDeque can greatly enhance the performance and flexibility of your applications.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide