Java ArrayDeque

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


ArrayDeque 实现的接口

ArrayDeque类实现了这两个接口。

ArrayDeque in Java implements two interfaces: Queue and 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类提供了QueueDeque接口中所有方法的实现。


向 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 作为 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 类

ArrayDequeJava LinkedList都实现了Deque接口。然而,它们之间存在一些差异。

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

我们的高级学习平台,凭借十多年的经验和数千条反馈创建。

以前所未有的方式学习和提高您的编程技能。

试用 Programiz PRO
  • 交互式课程
  • 证书
  • AI 帮助
  • 2000+ 挑战