Java ArrayDeque

Java ArrayDeque

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

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

ArrayDeque 实现的接口

ArrayDeque 类实现了这两个接口：

• Java 队列接口
• Java 双端队列接口

创建 ArrayDeque

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

下面是我们如何在 Java 中创建数组双端队列：

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

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

// 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() - 在数组deque的末尾插入指定的（相当于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() - 返回数组 deque 的第一个元素（相当于 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() - 从数组 deque 中返回并移除第一个元素（相当于 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() - 返回并移除数组 deque 的第一个元素（相当于 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 作为堆栈

实施LIFO（后进先出） Java 中的堆栈，建议在 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 Vs.链表类

两者都是 ArrayDeque Java LinkedList 实现了 Deque 界面。但是，它们之间存在一些差异。

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