Kotlin ArrayDeque

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.

Table of Contents

1. What is ArrayDeque?
2. Creating an ArrayDeque
3. Common Operations
4. Examples of ArrayDeque
5. Real-World Use Case
6. 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.