Java ArrayDeque

在Java中，我们可以使用ArrayDeque类通过数组来实现队列和双端队列数据结构。

ArrayDeque 实现的接口

ArrayDeque类实现了这两个接口。

• Java Queue 接口
• Java Deque 接口

创建 ArrayDeque

为了创建一个数组双端队列，我们必须导入java.util.ArrayDeque包。

以下是在Java中创建数组双端队列的方法：

ArrayDeque<Type> animal = new ArrayDeque<>();

这里，Type表示数组双端队列的类型。例如，

// Creating String type ArrayDeque
ArrayDeque<String> animals = new ArrayDeque<>();

// Creating Integer type ArrayDeque
ArrayDeque<Integer> age = new ArrayDeque<>();

ArrayDeque 的方法

ArrayDeque类提供了Queue和Deque接口中所有方法的实现。

向 Deque 插入元素

1. 使用 add()、addFirst() 和 addLast() 添加元素

• add() - 将指定元素插入到数组双端队列的末尾
• addFirst() - 将指定元素插入到数组双端队列的开头
• addLast() - 将指定元素插入到数组双端队列的末尾（等同于add()）

注意：如果数组双端队列已满，所有这些方法add()、addFirst()和addLast()都会抛出IllegalStateException。

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();

        // Using add()
        animals.add("Dog");

        // Using addFirst()
        animals.addFirst("Cat");

        // Using addLast()
        animals.addLast("Horse");
        System.out.println("ArrayDeque: " + animals);
    }
}

输出

ArrayDeque: [Cat, Dog, Horse]

2. 使用 offer()、offerFirst() 和 offerLast() 插入元素

• offer() - 将指定元素插入到数组双端队列的末尾
• offerFirst() - 将指定元素插入到数组双端队列的开头
• offerLast() - 将指定元素插入到数组双端队列的末尾

注意：如果元素成功插入，offer()、offerFirst()和offerLast()返回true；如果数组双端队列已满，这些方法返回false。

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        // Using offer()
        animals.offer("Dog");

        // Using offerFirst()
        animals.offerFirst("Cat");

        // Using offerLast()
        animals.offerLast("Horse");
        System.out.println("ArrayDeque: " + animals);
    }
}

输出

ArrayDeque: [Cat, Dog, Horse]

访问 ArrayDeque 元素

1. 使用 getFirst() 和 getLast() 访问元素

• getFirst() - 返回数组双端队列的第一个元素
• getLast() - 返回数组双端队列的最后一个元素

注意：如果数组双端队列为空，getFirst()和getLast()会抛出NoSuchElementException。

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Get the first element
        String firstElement = animals.getFirst();
        System.out.println("First Element: " + firstElement);

        // Get the last element
        String lastElement = animals.getLast();
        System.out.println("Last Element: " + lastElement);
    }
}

输出

ArrayDeque: [Dog, Cat, Horse]
First Element: Dog
Last Element: Horse

2. 使用 peek()、peekFirst() 和 peekLast() 方法访问元素

• peek() - 返回数组双端队列的第一个元素
• peekFirst() - 返回数组双端队列的第一个元素（等同于peek()）
• peekLast() - 返回数组双端队列的最后一个元素

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using peek()
        String element = animals.peek();
        System.out.println("Head Element: " + element);

        // Using peekFirst()
        String firstElement = animals.peekFirst();
        System.out.println("First Element: " + firstElement);

        // Using peekLast
        String lastElement = animals.peekLast();
        System.out.println("Last Element: " + lastElement);
    }
}

输出

ArrayDeque: [Dog, Cat, Horse]
Head Element: Dog
First Element: Dog
Last Element: Horse

注意：如果数组双端队列为空，peek()、peekFirst()和getLast()会抛出NoSuchElementException。

移除 ArrayDeque 元素

1. 使用 remove()、removeFirst()、removeLast() 方法移除元素

• remove() - 返回并移除数组双端队列的第一个元素
• remove(element) - 返回并移除数组双端队列头部指定的元素
• removeFirst() - 返回并移除数组双端队列的第一个元素（等同于remove()）
• removeLast() - 返回并移除数组双端队列的最后一个元素

注意：如果数组双端队列为空，remove()、removeFirst()和removeLast()方法会抛出异常。同样，如果找不到元素，remove(element)会抛出异常。

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Cow");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using remove()
        String element = animals.remove();
        System.out.println("Removed Element: " + element);

        System.out.println("New ArrayDeque: " + animals);

        // Using removeFirst()
        String firstElement = animals.removeFirst();
        System.out.println("Removed First Element: " + firstElement);

        // Using removeLast()
        String lastElement = animals.removeLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

输出

ArrayDeque: [Dog, Cat, Cow, Horse]
Removed Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Removed First Element: Cat
Removed Last Element: Horse

2. 使用 poll()、pollFirst() 和 pollLast() 方法移除元素

• poll() - 返回并移除数组双端队列的第一个元素
• pollFirst() - 返回并移除数组双端队列的第一个元素（等同于poll()）
• pollLast() - 返回并移除数组双端队列的最后一个元素

注意：如果数组双端队列为空，poll()、pollFirst()和pollLast()返回null（如果找不到元素）。

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Cow");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using poll()
        String element = animals.poll();
        System.out.println("Removed Element: " + element);
        System.out.println("New ArrayDeque: " + animals);

        // Using pollFirst()
        String firstElement = animals.pollFirst();
        System.out.println("Removed First Element: " + firstElement);

        // Using pollLast()
        String lastElement = animals.pollLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

输出

ArrayDeque: [Dog, Cat, Cow, Horse]
Removed Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Removed First Element: Cat
Removed Last Element: Horse

3. 移除元素：使用 clear() 方法

要从数组双端队列中移除所有元素，我们使用clear()方法。例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using clear()
        animals.clear();

        System.out.println("New ArrayDeque: " + animals);
    }
}

输出

ArrayDeque: [Dog, Cat, Horse]
New ArrayDeque: []

遍历 ArrayDeque

• iterator() - 返回一个可用于遍历数组双端队列的迭代器。
• descendingIterator() - 返回一个可用于反向遍历数组双端队列的迭代器。

为了使用这些方法，我们必须导入java.util.Iterator包。例如，

import java.util.ArrayDeque;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");

        System.out.print("ArrayDeque: ");

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }

        System.out.print("\nArrayDeque in reverse order: ");
        // Using descendingIterator()
        Iterator<String> desIterate = animals.descendingIterator();
        while(desIterate.hasNext()) {
            System.out.print(desIterate.next());
            System.out.print(", ");
        }
    }
}

输出

ArrayDeque: [Dog, Cat, Horse]
ArrayDeque in reverse order: [Horse, Cat, Dog]

其他方法

ArrayDeque 作为 Stack

要在Java中实现LIFO（后进先出）堆栈，建议使用双端队列而不是Stack类。ArrayDeque类可能比Stack类更快。

ArrayDeque提供了以下可用于实现堆栈的方法。

• push() - 将元素添加到堆栈的顶部
• peek() - 从堆栈顶部返回一个元素
• pop() - 从堆栈顶部返回并移除一个元素

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> stack = new ArrayDeque<>();

        // Add elements to stack
        stack.push("Dog");
        stack.push("Cat");
        stack.push("Horse");
        System.out.println("Stack: " + stack);

        // Access element from top of stack
        String element = stack.peek();
        System.out.println("Accessed Element: " + element);

        // Remove elements from top of stack
        String remElement = stack.pop();
        System.out.println("Removed element: " + remElement);
    }
}

输出

Stack: [Horse, Cat, Dog]
Accessed Element: Horse
Removed Element: Horse

ArrayDeque 与 LinkedList 类

ArrayDeque和Java LinkedList都实现了Deque接口。然而，它们之间存在一些差异。

• LinkedList支持null元素，而ArrayDeque不支持。
• 链表中的每个节点都包含指向其他节点的链接。这就是为什么LinkedList比ArrayDeque需要更多的存储空间。
• 如果您正在实现队列或双端队列数据结构，ArrayDeque可能比LinkedList更快。