标签: arraydeque

我知道ArrayDeque在添加和删除简单列表时速度很快。我实际测试过，它的添加和删除比LinkedList更快。因为我知道它是作为数组实现的，那为什么不随机访问呢？

我在 Java src 中读取了 ArrayDeque.java 文件。但以我的英语能力我不太明白。我看过很多来自 Google 和 Stack Overflow 的文章，但没有得到我想要的答案。

总之，我想要的答案是：

1. 为什么 ArrayDeque 不是 Random Access？（我最好奇） 2. ArrayDeque 在什么情况下使用？3. ArrayDeque 是不是没有实现为Array？（是不是知道错了知识？）

非常感谢您的回复！

public void traverse(Node root){
    ArrayDeque<Node> queue = new ArrayDeque<Node>();
        queue.add(root);

    while(!queue.isEmpty()){
        Node currentNode = queue.pollFirst();   
        List<Node> nl = getChildrenfromDB(currentNode);
        queue.addAll(nl);
    }

如何将addAll(nl)整个collection(List<Node>)添加到队列的前面？

嗨,我使用添加和提供添加我的元素在最后的步伐.两者都返回布尔值,两者都不会抛出除NPE之外的任何异常.

 public class ArrayDequeDemo {

  public static void main(String[] args) {


    // Create ArrayDeque elements.
    ArrayDeque<Integer> deque = new ArrayDeque<>();
    deque.add(10);
    deque.offer(30);

   }
 }

两者都会通过返回布尔值在最后的位置添加元素.

JAVA实施

//For Add and Offer Both
   public void addLast(E e) {
    if (e == null)
        throw new NullPointerException();
    elements[tail] = e;
    if ( (tail = (tail + 1) & (elements.length - 1)) == head)
        doubleCapacity();
}

我在为双端队列 (Deque) 的大小分配限制时遇到问题。似乎我的队列永远不会满，并且每当我为其添加或提供值时就会调整大小。我的简单代码只接受一个字符串值，用空格“”分割它，循环所有内容并将其添加到队列中。

evaluate("A B C D E F");

public static int evaluate(final String input){
    final Deque<String> stack = new ArrayDeque<>(3);
    final String[] tokens = input.split(" ");


    for (String token:tokens){
        System.out.println(stack.offer(token));
    }

    System.out.println(stack.size());
 }

返回：

 true
 true
 true
 true
 true
 true
 6

我预计队列将已满，因为我没有从中删除或读取任何值。我在这里缺少什么吗？或者我只是错误地使用了队列？谢谢！

如何将整数数组转换为 ArrayDeque？例如，不是用循环在 ArrayDeque 中添加数字，我可以将这个整数数组直接转换为 ArrayDeque 吗？提前致谢。

我想实现一个非常简单的滑动窗口.换句话说,我会有一些列表,其中的对象从该列表的右端插入并从左端删除.在每次插入中,先前的对象被左移一个索引.当列表被对象填充时,在每次从右端插入时,对象将从左端删除(并且前一个对象当然会像往常一样左移一个索引).

我记得有一个LinkedList或一个ArrayDeque - 可能后者是一个更好的选择,因为据我所知,插入和从任一端移除是对ArrayDeque的持续努力O(1),但事实并非如此对于LinkedList.是对的吗？

此外,我想问以下内容:当我插入一个新对象时,左移所有存储在滑动窗口中的所有对象对于具有100,000甚至1,000,000个对象的大型滑动窗口来说是处理密集型的,就像我的情况一样.是否有其他数据结构可能在我的应用程序中表现更好？

注意:我使用术语"滑动窗口"来表示我想要实现的内容,也许还有一些其他术语可以更好地描述它,但我认为从上面的描述可以清楚地知道我想做什么.

ArrayDeque有栈和队列的方法。最常用的堆栈和队列方法如下：

Stack方法：push/ poll/peek

Queue方法：push/ poll/peek

我在下面的代码块中所做的事情是，我试图理解ArrayDeque在同一个对象中同时使用 offer、push 和 add 方法时的行为。我编写的代码及其输出如下。ArrayDequeafter调用push()方法的行为是什么，它假设自己是一个堆栈，然后调用该offer()方法，它被声明为队列方法。

Deque<Integer> arrayDeque = new ArrayDeque<>(); 

arrayDeque.add(3);
arrayDeque.push(4);
arrayDeque.offer(6);
arrayDeque.addFirst(2);
arrayDeque.addLast(5);
arrayDeque.addFirst(1);
System.out.println("ArrayDeque: " + arrayDeque.toString());

输出是：

ArrayDeque: [1, 2, 4, 3, 6, 5]

我知道它们两者之间的基本区别是 ConcurrentLinkedDeque 可以在多线程应用程序中使用。

任何人都可以给我一个实际的例子，如果错误使用它会如何影响应用程序的性能，在哪种情况下我应该使用 ConcurrentLinkedDeque 以及何时使用 ArrayDeque。

Deque<Card>我想使用Card类方法对集合的内容进行排序getRealValue()。

public class Card implements Comparable<Card> {\n  private final int value;\n  private final CardType cardType;\n\n  public Card(int value, CardType cardType) {\n    this.value = value;\n    this.cardType = cardType;\n  }\n\n  public int getRealValue() {\n    int realValue = this.value == 1 ? 52 : 0;\n    return realValue + this.value * 4 + this.cardType.ordinal();\n  }\n\n  public int compareTo(Card o) {\n    return this.getRealValue() - o.getRealValue();\n  }\n}\n

这是我的 CardType 枚举

public enum CardType {\n    CLUB("\xe2\x99\xa3"),\n    SPADE("\xe2\x99\xa0"), \n    HEART("\xe2\x99\xa5"), …

文件说:

Deque接口的可调整大小的数组实现.阵列deques没有容量限制; 他们根据需要增长以支持使用

但是,我仍然想了解ArrayDeque的确切结构,调整大小的工作原理.如果有人可以提供可靠的来源,我可以找到答案,这将是很好的.根据我发现的一些谷歌搜索结果,它可能是一个圆形阵列.这是真的吗？什么是增长政策？它与ArrayList类似吗？如果是,ArrayDeque在操作中是否具有与ArrayList类似的性能,例如在末尾添加或删除元素？

谢谢.

我正在尝试维护多个线程中的项目列表，每个线程一个（例如，每个线程说一个套接字连接）。我在维护此列表ArrayDeque<>。我面临的问题ArrayDeque<>是超过项目数超过项目数。线程池中的线程数。

这是我的代码：

package com.practice;

import java.util.ArrayDeque;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class CompletableFutureApp implements AutoCloseable {
    private static void sleep(long timeMS) {
        try {
            Thread.sleep(timeMS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try (CompletableFutureApp completableFutureApp = new CompletableFutureApp()) {

            Runnable[] tasksList1 = new Runnable[100];

            for (int i = 0; i < tasksList1.length; i++) {
                String msg1 = "TaskList 1 no.: " + i; …