Java `ArrayDeque`

在本教程中，我们将借助示例学习ArrayDeque类及其方法。此外，我们还将学习使用数组双端队列来实现栈。
由ArrayDeque实现的接口
创建ArrayDeque
ArrayDeque方法
其他方法
ArrayDeque作为栈
ArrayDeque与LinkedList类

原文： https://www.programiz.com/java-programming/arraydeque

在本教程中，我们将借助示例学习`ArrayDeque`类及其方法。此外，我们还将学习使用数组双端队列来实现栈。

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

由`ArrayDeque`实现的接口

ArrayDeque类实现以下两个接口：

Java `ArrayDeque` - 图1

创建`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接口中存在的所有方法的实现。

将元素插入双端队列

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]

注意：如果数组双端队列已满

add()方法将引发异常
offer()方法返回false

访问`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]

其他方法

方法	内容描述
`element()`	从数组双端队列的头部返回一个元素。
`contains(element)`	在数组双端队列中搜索指定的元素。
如果找到该元素，则返回`true`，否则返回`false`。
`size()`	返回数组双端队列的长度。
`toArray()`	将数组双端队列转换为数组并返回。
`clone()`	创建数组双端队列的副本并返回它。

`ArrayDeque`作为栈

要在 Java 中实现 LIFO（后进先出）栈，建议在栈类上使用双端队列。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快。

在本教程中，我们将借助示例学习ArrayDeque类及其方法。 此外，我们还将学习使用数组双端队列来实现栈。

由ArrayDeque实现的接口

创建ArrayDeque

ArrayDeque方法

将元素插入双端队列

访问ArrayDeque元素

删除ArrayDeque元素

迭代ArrayDeque