当前位置：极客教程 > Java > Java 集合 > Java ArrayDeque

Java ArrayDeque

Java ArrayDeque

Java中的ArrayDeque除了实现Deque接口外，还提供了一种应用可调整大小的数组的方法。它也被称为Array Double Ended Queue或Array Deck。 这是一种特殊的数组，可以增长，并允许用户从队列的两边添加或删除一个元素。

ArrayDeque的几个重要特点如下。

  • 阵列德克没有容量限制，它们根据需要增长以支持使用。
  • 它们不是线程安全的，这意味着在没有外部同步的情况下，ArrayDeque不支持多线程的并发访问。
  • ArrayDeque中禁止出现空元素。
  • ArrayDeque类作为堆栈使用时，可能比Stack快。
  • ArrayDeque类作为队列使用时，可能比LinkedList快。

ArrayDeque实现的接口

ArrayDeque类实现了这两个接口。

  • Queue 接口： 它是一个先入先出的数据结构，元素从后面加入。
  • Deque 接口： 它是一个双端队列，你可以从两边插入元素。它是一个实现队列的接口。

ArrayDeque同时实现了Queue和Deque。它可以从两边动态地调整大小。ArrayDeque在层次结构中的所有实现接口是 Serializable , Cloneable , **Iterable **, **Collection **, Deque<E> , Queue<E>。

Java中的ArrayDeque

语法： 声明

public class ArrayDeque<E>

扩展了 抽象集合。

实现了 Deque<E>, Cloneable, Serializable

这里， E 指的是元素，它可以指任何类，如Integer或String类。

现在我们已经完成了语法，现在让我们来看看在实现之前为它定义的构造函数，以便更好地掌握它，更好地感知输出。

  • ArrayDeque(): 这个构造函数用来创建一个空的ArrayDeque，默认情况下，它的初始容量为16个元素。
ArrayDeque<E> dq = new ArrayDeque<E>();
  • **ArrayDeque(Collection c): **这个构造函数用来创建一个ArrayDeque，包含与指定集合相同的所有元素。

    “`java
    ArrayDeque<E> dq = new ArrayDeque<E>(Collection col);
    “`

    * **ArrayDeque(int numofElements):** 这个构造函数用于创建一个空的ArrayDeque，并持有包含指定数量元素的能力。

    “`java
    ArrayDeque<E> dq = new ArrayDeque<E>(int numofElements);
    “`

    ArrayDeque中的方法如下。

    **注：** 这里， **Element**是ArrayDeque存储的元素的类型。

    方法 | 描述
    —|—
    add(Element e) | 该方法在deque的最后插入一个特定的元素。
    addAll(Collection c) | 将指定集合中的所有元素添加到这个deque的末尾，就像对每一个元素调用addLast(E)一样，按照它们由集合的迭代器返回的顺序。
    addFirst(Element e) | 该方法在deque的开始位置插入特定的元素。
    addLast(Element e) | 该方法在deque的末端插入一个特定的元素。它类似于add()方法。
    clear() | 该方法删除了所有deque元素。
    clone() | 该方法复制deque。
    contains(Obj) | 该方法检查一个deque是否包含该元素。
    element() | 该方法在deque的头部返回元素。
    forEach(Consumer action) | 对Iterable中的每个元素执行给定的动作，直到所有元素都被处理完，或者该动作抛出一个异常。
    getFirst() | 该方法返回deque的第一个元素。
    getLast() | 该方法返回deque的最后一个元素。
    isEmpty() | 该方法检查deque是否为空。
    iterator() | 返回这个deque中元素的迭代器。
    offer(Element e) | 该方法在deque的最后插入元素。
    offerFirst(Element e) | 该方法将元素插入德克的前端。
    offerLast(Element e) | 该方法在deque的最后插入元素。
    peek() | 该方法返回头部元素而不删除它。
    poll() | 该方法返回头部元素，同时将其删除。
    pop() | 该方法在堆栈中弹出一个由deque代表的元素。
    push(Element e) | 该方法将一个元素推到由deque代表的堆栈中。
    remove() | 该方法返回头部元素，并将其删除。
    remove(Object o) | 从这个deque中删除一个指定元素的实例。
    removeAll(Collection c) | 删除这个集合中所有包含在指定集合中的元素（可选操作）。
    removeFirst() | 该方法返回第一个元素，同时将其删除。
    removeFirstOccurrence(Object o) | 删除指定元素在这个deque中的第一次出现（当从头到尾遍历这个deque时）。
    removeIf(Predicate filter) | 删除这个集合中满足给定谓词的所有元素。
    removeLast() | 该方法返回最后一个元素，同时将其删除
    removeLastOccurrence(Object o) | 删除这个deque中最后出现的指定元素（当从头到尾遍历这个deque时）。
    retainAll(Collection c) | 只保留这个集合中包含在指定集合中的元素（可选操作）。
    size() | 返回这个deque中元素的数量。
    spliterator() | 在这个deque中的元素上创建一个晚期绑定的、快速失效的Spliterator。
    toArray() | 返回一个包含deque中所有元素的数组，并以适当的顺序（从第一个元素到最后一个元素）排列。
    toArray(T[] a) | 返回一个数组，包含这个deque中的所有元素，并以适当的顺序排列（从第一个元素到最后一个元素）；返回的数组的运行时类型是指定数组的类型。

从java.util.AbstractCollection类继承的方法

方法，包括 执行的操作
containsAll(Collection c) 如果这个集合包含了指定集合中的所有元素，返回true。
toString() 返回这个集合的一个字符串表示。

从java.util.Collection界面继承的方法

方法 执行的操作
containsAll(Collection c) 如果这个集合包含指定集合中的所有元素，则返回true。
equals() 将指定的对象与这个集合进行比较，看是否相等。
hashcode() 返回此集合的哈希代码值。
parallelStream() 返回一个以该集合为源的可能的并行流。
stream() 返回一个以这个集合为源的顺序流。
toArray(IntFunction<T[]> generator) 返回一个包含此集合中所有元素的数组，使用提供的生成器函数来分配返回的数组。

java.util.Deque接口中声明的方法

方法名称 执行的操作
descendingIterator() 返回这个deque中的元素的反向顺序的迭代器。
peekFirst() 检索但不删除此deque中的第一个元素，如果此deque为空，则返回null。
peekLast() 检索但不删除这个deque的最后一个元素，如果这个deque是空的，则返回null。
pollFirst() 检索并删除这个deque的第一个元素，如果这个deque是空的，则返回null。
pollLast() 检索并删除这个deque的最后一个元素，如果这个deque是空的，则返回null。

例子

// Java program to Implement ArrayDeque in Java
//
 
// Importing utility classes
import java.util.*;
 
// ArrayDequeDemo
public class GGFG {
    public static void main(String[] args)
    {
        // Creating and initializing deque
        // Declaring object of integer type
        Deque<Integer> de_que = new ArrayDeque<Integer>(10);
 
        // Operations 1
        // add() method
 
        // Adding custom elements
        // using add() method to insert
        de_que.add(10);
        de_que.add(20);
        de_que.add(30);
        de_que.add(40);
        de_que.add(50);
 
        // Iterating using for each loop
        for (Integer element : de_que) {
            // Print the corresponding element
            System.out.println("Element : " + element);
        }
 
        // Operation 2
        // clear() method
        System.out.println("Using clear() ");
 
        // Clearing all elements using clear() method
        de_que.clear();
 
        // Operations 3
        // addFirst() method
 
        // Inserting at the start
        de_que.addFirst(564);
        de_que.addFirst(291);
 
        // Operation 4
        // addLast() method
        // Inserting at end
        de_que.addLast(24);
        de_que.addLast(14);
 
        // Display message
        System.out.println(
            "Above elements are removed now");
 
        // Iterators
 
        // Display message
        System.out.println(
            "Elements of deque using Iterator :");
 
        for (Iterator itr = de_que.iterator();
             itr.hasNext();) {
            System.out.println(itr.next());
        }
 
        // descendingIterator()
        // To reverse the deque order
        System.out.println(
            "Elements of deque in reverse order :");
 
        for (Iterator dItr = de_que.descendingIterator();
             dItr.hasNext();) {
            System.out.println(dItr.next());
        }
 
        // Operation 5
        // element() method : to get Head element
        System.out.println(
            "\nHead Element using element(): "
            + de_que.element());
 
        // Operation 6
        // getFirst() method : to get Head element
        System.out.println("Head Element using getFirst(): "
                           + de_que.getFirst());
 
        // Operation 7
        // getLast() method : to get last element
        System.out.println("Last Element using getLast(): "
                           + de_que.getLast());
 
        // Operation 8
        // toArray() method :
        Object[] arr = de_que.toArray();
        System.out.println("\nArray Size : " + arr.length);
 
        System.out.print("Array elements : ");
 
        for (int i = 0; i < arr.length; i++)
            System.out.print(" " + arr[i]);
 
        // Operation 9
        // peek() method : to get head
        System.out.println("\nHead element : "
                           + de_que.peek());
 
        // Operation 10
        // poll() method : to get head
        System.out.println("Head element poll : "
                           + de_que.poll());
 
        // Operation 11
        // push() method
        de_que.push(265);
        de_que.push(984);
        de_que.push(2365);
 
        // Operation 12
        // remove() method : to get head
        System.out.println("Head element remove : "
                           + de_que.remove());
 
        System.out.println("The final array is: " + de_que);
    }
}

输出

Element : 10
Element : 20
Element : 30
Element : 40
Element : 50
Using clear() 
Above elements are removed now
Elements of deque using Iterator :
291
564
24
14
Elements of deque in reverse order :
14
24
564
291

Head Element using element(): 291
Head Element using getFirst(): 291
Last Element using getLast(): 14

Array Size : 4
Array elements :  291 564 24 14
Head element : 291
Head element poll : 291
Head element remove : 2365
The final array is: [984, 265, 564, 24, 14]

如果这个例子在清晰度上有一些滞后，如果是这样的话，那么我们就提出对ArrayDeque类的各种操作 让我们看看如何对ArrayDeque进行一些经常使用的操作，以便更好地理解我们上面用来说明Array Deque整体的操作。

  • 添加操作
  • 访问操作
  • 移除操作
  • 遍历Deque

让我们通过提供干净的java程序来实现每个操作，如下所示。

操作1： 添加元素

为了向ArrayDeque添加一个元素，我们可以使用add()、addFirst()、addLast()、offer()、offerFirst()、offerLast()的方法。

  • add()
  • addFirst()
  • addLast()
  • offer()
  • offerFirst()
  • offerLast()

例子

// Java program to Illustrate Addition of elements
// in ArrayDeque
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// AddingElementsToArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Initializing a deque
        // since deque is an interface
        // it is assigned the
        // ArrayDeque class
        Deque<String> dq = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("The");
        dq.addFirst("To");
        dq.addLast("Geeks");
 
        // offer() method to insert
        dq.offer("For");
        dq.offerFirst("Welcome");
        dq.offerLast("Geeks");
 
        // Printing Elements of ArrayDeque to the console
        System.out.println("ArrayDeque : " + dq);
    }
}

输出

ArrayDeque : [Welcome, To, The, Geeks, For, Geeks]

操作2： 访问元素

添加完元素后，如果我们想访问这些元素，我们可以使用内置的方法，如getFirst(), getLast()等。

  • getFirst()
  • getLast()
  • peek()
  • peekFirst()
  • peekLast()

例子

// Java program to Access Elements of ArrayDeque
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
// AccessingElementsOfArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an empty ArrayDeque
        ArrayDeque<String> de_que
            = new ArrayDeque<String>();
 
        // Using add() method to add elements into the Deque
        // Custom input elements
        de_que.add("Welcome");
        de_que.add("To");
        de_que.add("Geeks");
        de_que.add("4");
        de_que.add("Geeks");
 
        // Displaying the ArrayDeque
        System.out.println("ArrayDeque: " + de_que);
 
        // Displaying the First element
        System.out.println("The first element is: "
                           + de_que.getFirst());
 
        // Displaying the Last element
        System.out.println("The last element is: "
                           + de_que.getLast());
    }
}

输出

ArrayDeque: [Welcome, To, Geeks, 4, Geeks]
The first element is: Welcome
The last element is: Geeks

操作 3. 删除元素

为了从deque中移除一个元素，有多种方法可用。由于我们也可以从两端移除，deque接口为我们提供了removeFirst(), removeLast()方法。除此之外，这个接口还为我们提供了poll()、pop()、pollFirst()、pollLast()方法，其中pop()是用来删除和返回deque的头部。然而，使用poll()是因为它提供了与pop()相同的功能，并且在deque为空时不会返回异常。这些操作集如下所列。

  • remove()
  • removeFirst()
  • removeLast()
  • poll()
  • pollFirst()
  • pollLast()
  • pop()

例子

// Java program to Illustrate Removal Elements in Deque
 
// Importing all utility classes
import java.util.*;
 
// RemoveElementsOfArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Initializing a deque
        Deque<String> dq = new ArrayDeque<String>();
 
        // add() method to insert
        dq.add("One");
 
        // addFirst inserts at the front
        dq.addFirst("Two");
 
        // addLast inserts at the back
        dq.addLast("Three");
 
        // print elements to the console
        System.out.println("ArrayDeque : " + dq);
 
        // remove element as a stack from top/front
        System.out.println(dq.pop());
 
        // remove element as a queue from front
        System.out.println(dq.poll());
 
        // remove element from front
        System.out.println(dq.pollFirst());
 
        // remove element from back
        System.out.println(dq.pollLast());
    }
}

输出

ArrayDeque : [Two, One, Three]
Two
One
Three
null

操作 4： 通过deque进行迭代

由于deque可以从两个方向进行迭代，deque接口的迭代器方法为我们提供了两种迭代方式。一种是从前面，另一种是从后面。下面列出了这几组操作，如下所示。

  • remove()
  • iterator()
  • descendingIterator()

例子

// Java program to Illustrate Iteration of Elements
// in Deque
 
// Importing all utility classes
import java.util.*;
 
// Main class
// IterateArrayDeque
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing an deque
        Deque<String> dq = new ArrayDeque<String>();
 
        // Adding elements at the back
        // using add() method
        dq.add("For");
 
        // Adding element at the front
        // using addFirst() method
        dq.addFirst("Geeks");
 
        // add element at the last
        // using addLast() method
        dq.addLast("Geeks");
        dq.add("is so good");
 
        // Iterate using Iterator interface
        // from the front of the queue
        for (Iterator itr = dq.iterator(); itr.hasNext();) {
 
            // Print the elements
            System.out.print(itr.next() + " ");
        }
 
        // New line
        System.out.println();
 
        // Iterate in reverse sequence in a queue
        for (Iterator itr = dq.descendingIterator();
             itr.hasNext();) {
 
            System.out.print(itr.next() + " ");
        }
    }
}

输出

Geeks For Geeks is so good 
is so good Geeks For Geeks

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Java 精品教程