Java ArrayDeque - 芒果文档

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

由ArrayDeque实现的接口

ArrayDeque类实现以下两个接口：

Java队列接口
Java Deque接口

Java中的ArrayDeque实现了两个接口：Queue和Deque

创建ArrayDeque

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

这是我们可以用Java创建数组双端队列的方法：

ArrayDeque animal = new ArrayDeque<>();

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

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

// Creating Integer type ArrayDeque
ArrayDeque 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 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否则，返回true 。如果数组双端队列已满，则这些方法返回false 。

例如，

import java.util.ArrayDeque;

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

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

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

        System.out.print("\nArrayDeque in reverse order: ");
        // Using descendingIterator()
        Iterator 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]

其他方法

Methods	Descriptions
`element()`	Returns an element from the head of the array deque.
`contains(element)`	Searches the array deque for the specified element. If the element is found, it returns `true`, if not it returns `false`.
`size()`	Returns the length of the array deque.
`toArray()`	Converts array deque to array and returns it.
`clone()`	Creates a copy of the array deque and returns it.

ArrayDeque作为堆栈

要在Java中实现LIFO(后进先出)堆栈，建议对Stack类使用双端队列。 ArrayDeque类可能比Stack类快。

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

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

例如，

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque 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` 。

如果要实现队列或双端队列数据结构，则`ArrayDeque`可能比`LinkedList`快。

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