`
uule
  • 浏览: 6348947 次
  • 性别: Icon_minigender_1
  • 来自: 一片神奇的土地
社区版块
存档分类
最新评论

ArrayDeque类

 
阅读更多

另:Java多线程(6)之Deque与LinkedBlockingDeque深入分析(转)

其他源码分析

 

ArrayDeque类实现Queue,Deque接口。

对于数组实现的Deque来说,数据结构上比较简单,只需要一个存储数据的数组以及头尾两个索引即可。由于数组是固定长度的,所以很容易就得到数组的头和尾,那么对于数组的操作只需要移动头和尾的索引即可。

特别说明的是ArrayDeque并不是一个固定大小的队列每次队列满了以后就将队列容量扩大一倍(doubleCapacity()),因此加入一个元素总是能成功,而且也不会抛出一个异常。也就是说ArrayDeque是一个没有容量限制的队列。

同样继续性能的考虑,使用System.arraycopy复制一个数组比循环设置要高效得多。

 

ArrayDeque不是线程安全的。 

ArrayDeque不可以存取null元素,因为系统根据某个位置是否为null来判断元素的存在。 

当作为栈使用时,性能比Stack好;

当作为队列使用时,性能比LinkedList好。 

因为栈Stack继承了Vector,是线程安全的

API

 

总结:

 1、队列满了后自动扩容,因此新增总会成功

2、head 为第一个元素的索引  

      tail 为下个要添加元素的位置,为末尾元素的索引 + 1     

      因此,首元素为element[head],未元素为element[tail-1]   

3、   

 头部添加元素e时:

         head = (head - 1) 

         elements[head】 = e

 尾部添加元素e时:

         是将e 赋值给elements[tail] 即elements[tail] = e;  

         tail = (tail + 1) ,指向下个要添加元素的位置

 

添加完之后都需要判断是否需要扩容。

 

头部删除元素时:

        elements[head] = null; 

        head = (head + 1)

尾部删除元素时:

        int t = (tail - 1)  // 处理临界情况(当tail为0时),与后的结果为elements.length - 1。     

        elements[t] = null;  

        tail = t

 

 

看了ArrayDeque类的源码。有以下几点总结:

 

1)ArrayDeque有两个类属性,head和tail,两个指针。

2)ArrayDeque通过一个数组作为载体,其中的数组元素在add等方法执行时不移动,发生变化的只是head和tail指针,而且指针是循环变化,数组容量不限制。

3)offer方法和add方法都是通过其中的addLast方法实现,每添加一个元素,就把元素加到数组的尾部,此时,head指针没有变化,而tail指针加一,因为指针是循环加的,所以当tail追上head((this.tail = this.tail + 1 & this.elements.length - 1) == this.head)时,数组容量翻一倍,继续执行。

4)remove方法和poll方法都是通过其中的pollFirst方法实现,每移除一个元素,该元素所在位置变成null,此时,tail指针没有变化,而head指针加一,当数组中没有数据时,返回null。

5)因为ArrayDeque不是线程安全的,所以,用作堆栈时快于 Stack,在用作队列时快于 LinkedList。

 

1. 两个重要的索引:head和tail 

Java代码  收藏代码
  1. // 第一个元素的索引  
  2. private transient int head;  
  3. // 下个要添加元素的位置,为末尾元素的索引 + 1  
  4. private transient int tail;  



2. 构造方法 

Java代码  收藏代码
  1. public ArrayDeque() {  
  2.     elements = (E[]) new Object[16]; // 默认的数组长度大小  
  3. }  
  4.   
  5. public ArrayDeque(int numElements) {  
  6.     allocateElements(numElements); // 需要的数组长度大小  
  7. }  
  8.   
  9. public ArrayDeque(Collection<? extends E> c) {  
  10.     allocateElements(c.size()); // 根据集合来分配数组大小  
  11.     addAll(c); // 把集合中元素放到数组中  
  12. }  



3. 分配合适大小的数组 

Java代码  收藏代码
  1. private void allocateElements(int numElements) {  
  2.     int initialCapacity = MIN_INITIAL_CAPACITY;  
  3.     // 找到大于需要长度的最小的2的幂整数。  
  4.     // Tests "<=" because arrays aren't kept full.  
  5.     if (numElements >= initialCapacity) {  
  6.         initialCapacity = numElements;  
  7.         initialCapacity |= (initialCapacity >>>  1);  
  8.         initialCapacity |= (initialCapacity >>>  2);  
  9.         initialCapacity |= (initialCapacity >>>  4);  
  10.         initialCapacity |= (initialCapacity >>>  8);  
  11.         initialCapacity |= (initialCapacity >>> 16);  
  12.         initialCapacity++;  
  13.   
  14.         if (initialCapacity < 0)   // Too many elements, must back off  
  15.             initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements  
  16.     }  
  17.     elements = (E[]) new Object[initialCapacity];  
  18. }  



4. 扩容 

Java代码  收藏代码
  1. // 扩容为原来的2倍。  
  2. private void doubleCapacity() {  
  3.     assert head == tail;  
  4.     int p = head;  
  5.     int n = elements.length;  
  6.     int r = n - p; // number of elements to the right of p  
  7.     int newCapacity = n << 1;  
  8.     if (newCapacity < 0)  
  9.         throw new IllegalStateException("Sorry, deque too big");  
  10.     Object[] a = new Object[newCapacity];  
  11.     // 既然是head和tail已经重合了,说明tail是在head的左边。  
  12.     System.arraycopy(elements, p, a, 0, r); // 拷贝原数组从head位置到结束的数据  
  13.     System.arraycopy(elements, 0, a, r, p); // 拷贝原数组从开始到head的数据  
  14.     elements = (E[])a;  
  15.     head = 0// 重置head和tail为数据的开始和结束索引  
  16.     tail = n;  
  17. }  
  18.   
  19. // 拷贝该数组的所有元素到目标数组  
  20. private <T> T[] copyElements(T[] a) {  
  21.     if (head < tail) { // 开始索引大于结束索引,一次拷贝  
  22.         System.arraycopy(elements, head, a, 0, size());  
  23.     } else if (head > tail) { // 开始索引在结束索引的右边,分两段拷贝  
  24.         int headPortionLen = elements.length - head;  
  25.         System.arraycopy(elements, head, a, 0, headPortionLen);  
  26.         System.arraycopy(elements, 0, a, headPortionLen, tail);  
  27.     }  
  28.     return a;  
  29. }  



5. 添加元素 

Java代码  收藏代码
  1. public void addFirst(E e) {  
  2.     if (e == null)  
  3.         throw new NullPointerException();  
  4.     // 本来可以简单地写成head-1,但如果head为0,减1就变为-1了,和elements.length - 1进行与操作就是为了处理这种情况,这时结果为elements.length - 1。  
  5.     elements[head = (head - 1) & (elements.length - 1)] = e;  
  6.     if (head == tail) // head和tail不可以重叠  
  7.         doubleCapacity();  
  8. }  
  9.   
  10. public void addLast(E e) {  
  11.     if (e == null)  
  12.         throw new NullPointerException();  
  13.     // tail位置是空的,把元素放到这。  
  14.     elements[tail] = e;  
  15.     // 和head的操作类似,为了处理临界情况 (tail为length - 1时),和length - 1进行与操作,结果为0。  
  16.     if ( (tail = (tail + 1) & (elements.length - 1)) == head)  
  17.         doubleCapacity();  
  18. }  
  19.   
  20. public boolean offerFirst(E e) {  
  21.     addFirst(e);  
  22.     return true;  
  23. }  
  24.   
  25. public boolean offerLast(E e) {  
  26.     addLast(e);  
  27.     return true;  
  28. }  



6. 删除元素 

删除首尾元素: 

Java代码  收藏代码
  1. public E removeFirst() {  
  2.     E x = pollFirst();  
  3.     if (x == null)  
  4.         throw new NoSuchElementException();  
  5.     return x;  
  6. }  
  7.   
  8. public E removeLast() {  
  9.     E x = pollLast();  
  10.     if (x == null)  
  11.         throw new NoSuchElementException();  
  12.     return x;  
  13. }  
  14.   
  15. public E pollFirst() {  
  16.     int h = head;  
  17.     E result = elements[h]; // Element is null if deque empty  
  18.     if (result == null)  
  19.         return null;  
  20.     // 表明head位置已为空  
  21.     elements[h] = null;     // Must null out slot  
  22.     head = (h + 1) & (elements.length - 1); // 处理临界情况(当h为elements.length - 1时),与后的结果为0。  
  23.     return result;  
  24. }  
  25.   
  26. public E pollLast() {  
  27.     int t = (tail - 1) & (elements.length - 1); // 处理临界情况(当tail为0时),与后的结果为elements.length - 1。  
  28.     E result = elements[t];  
  29.     if (result == null)  
  30.         return null;  
  31.     elements[t] = null;  
  32.     tail = t; // tail指向的是下个要添加元素的索引。  
  33.     return result;  
  34. }  



删除指定元素: 

Java代码  收藏代码
  1. public boolean removeFirstOccurrence(Object o) {  
  2.     if (o == null)  
  3.         return false;  
  4.     int mask = elements.length - 1;  
  5.     int i = head;  
  6.     E x;  
  7.     while ( (x = elements[i]) != null) {  
  8.         if (o.equals(x)) {  
  9.             delete(i);  
  10.             return true;  
  11.         }  
  12.         i = (i + 1) & mask; // 从头到尾遍历  
  13.     }  
  14.     return false;  
  15. }  
  16.   
  17. public boolean removeLastOccurrence(Object o) {  
  18.     if (o == null)  
  19.         return false;  
  20.     int mask = elements.length - 1;  
  21.     int i = (tail - 1) & mask; // 末尾元素的索引  
  22.     E x;  
  23.     while ( (x = elements[i]) != null) {  
  24.         if (o.equals(x)) {  
  25.             delete(i);  
  26.             return true;  
  27.         }  
  28.         i = (i - 1) & mask; // 从尾到头遍历  
  29.     }  
  30.     return false;  
  31. }  



Java代码  收藏代码
  1. private void checkInvariants() { // 有效性检查  
  2.     assert elements[tail] == null// tail位置没有元素  
  3.     assert head == tail ? elements[head] == null :  
  4.         (elements[head] != null &&  
  5.             elements[(tail - 1) & (elements.length - 1)] != null); // 如果head和tail重叠,队列为空;否则head位置有元素,tail-1位置有元素。  
  6.     assert elements[(head - 1) & (elements.length - 1)] == null// head-1的位置没有元素。  
  7. }  
  8.   
  9. private boolean delete(int i) {  
  10.     checkInvariants();  
  11.     final E[] elements = this.elements;  
  12.     final int mask = elements.length - 1;  
  13.     final int h = head;  
  14.     final int t = tail;  
  15.     final int front = (i - h) & mask; // i前面的元素个数  
  16.     final int back  = (t - i) & mask; // i后面的元素个数  
  17.   
  18.     // Invariant: head <= i < tail mod circularity  
  19.     if (front >= ((t - h) & mask)) // i不在head和tail之间  
  20.         throw new ConcurrentModificationException();  
  21.   
  22.     // Optimize for least element motion  
  23.     if (front < back) { // i的位置靠近head,移动开始的元素,返回false。  
  24.         if (h <= i) {  
  25.             System.arraycopy(elements, h, elements, h + 1, front);  
  26.         } else { // Wrap around  
  27.             System.arraycopy(elements, 0, elements, 1, i);  
  28.             elements[0] = elements[mask]; // 处理边缘元素  
  29.             System.arraycopy(elements, h, elements, h + 1, mask - h);  
  30.         }  
  31.         elements[h] = null;  
  32.         head = (h + 1) & mask; // head位置后移  
  33.         return false;  
  34.     } else { // i的位置靠近tail,移动末尾的元素,返回true。  
  35.         if (i < t) { // Copy the null tail as well  
  36.             System.arraycopy(elements, i + 1, elements, i, back);  
  37.             tail = t - 1;  
  38.         } else { // Wrap around  
  39.             System.arraycopy(elements, i + 1, elements, i, mask - i);  
  40.             elements[mask] = elements[0];  
  41.             System.arraycopy(elements, 1, elements, 0, t);  
  42.             tail = (t - 1) & mask;  
  43.         }  
  44.         return true;  
  45.     }  
  46. }  



示意图: 
 

7. 获取元素 

Java代码  收藏代码
  1. public E getFirst() {  
  2.     E x = elements[head];  
  3.     if (x == null)  
  4.         throw new NoSuchElementException();  
  5.     return x;  
  6. }  
  7.   
  8. public E getLast() {  
  9.     E x = elements[(tail - 1) & (elements.length - 1)]; // 处理临界情况(当tail为0时),与后的结果为elements.length - 1。  
  10.     if (x == null)  
  11.         throw new NoSuchElementException();  
  12.     return x;  
  13. }  
  14.   
  15. public E peekFirst() {  
  16.     return elements[head]; // elements[head] is null if deque empty  
  17. }  
  18.   
  19. public E peekLast() {  
  20.     return elements[(tail - 1) & (elements.length - 1)];  
  21. }  



8. 队列操作 

Java代码  收藏代码
  1. public boolean add(E e) {  
  2.     addLast(e);  
  3.     return true;  
  4. }  
  5.   
  6. public boolean offer(E e) {  
  7.     return offerLast(e);  
  8. }  
  9.   
  10. public E remove() {  
  11.     return removeFirst();  
  12. }  
  13.   
  14. public E poll() {  
  15.     return pollFirst();  
  16. }  
  17.   
  18. public E element() {  
  19.     return getFirst();  
  20. }  
  21.   
  22. public E peek() {  
  23.     return peekFirst();  
  24. }  



9. 栈操作 

Java代码  收藏代码
  1. public void push(E e) {  
  2.     addFirst(e);  
  3. }  
  4.   
  5. public E pop() {  
  6.     return removeFirst();  
  7. }  



10. 集合方法 

Java代码  收藏代码
  1. public int size() {  
  2.     return (tail - head) & (elements.length - 1); // 和elements.length - 1进行与操作是为了处理当tail < head时的情况。  
  3. }  
  4.   
  5. public boolean isEmpty() {  
  6.     return head == tail; // tail位置的元素一定为空,head和tail相等,也为空。  
  7. }  
  8.   
  9. // 向前迭代器  
  10. public Iterator<E> iterator() {  
  11.     return new DeqIterator();  
  12. }  
  13.   
  14. // 向后迭代器  
  15. public Iterator<E> descendingIterator() {  
  16.     return new DescendingIterator();  
  17. }  



Java代码  收藏代码
  1.   private class DeqIterator implements Iterator<E> {  
  2.   
  3.       private int cursor = head;  
  4.   
  5.       private int fence = tail; // 迭代终止索引,同时也为了检测并发修改。  
  6.   
  7.       private int lastRet = -1// 最近的next()调用返回的索引。据此可以定位到需要删除元素的位置。  
  8.   
  9.       public boolean hasNext() {  
  10.           return cursor != fence;  
  11.       }  
  12.   
  13.       public E next() {  
  14.           if (cursor == fence)  
  15.               throw new NoSuchElementException();  
  16.           E result = elements[cursor];  
  17.           // This check doesn't catch all possible comodifications,  
  18.           // but does catch the ones that corrupt traversal  
  19.           if (tail != fence || result == null)  
  20.               throw new ConcurrentModificationException();  
  21.           lastRet = cursor;  
  22.           cursor = (cursor + 1) & (elements.length - 1); // 游标位置加1  
  23.           return result;  
  24.       }  
  25.   
  26.       public void remove() {  
  27.           if (lastRet < 0)  
  28.               throw new IllegalStateException();  
  29.           if (delete(lastRet)) { // 如果将元素从右往左移,需要将游标减1。  
  30.               cursor = (cursor - 1) & (elements.length - 1); // 游标位置回退1。  
  31. fence = tail; // 重置阀值。  
  32.    }  
  33.           lastRet = -1;  
  34.       }  
  35.   }  



Java代码  收藏代码
  1. private class DescendingIterator implements Iterator<E> {  
  2.   
  3.     private int cursor = tail; // 游标开始索引为tail  
  4.     private int fence = head; // 游标的阀值为head  
  5.     private int lastRet = -1;  
  6.   
  7.     public boolean hasNext() {  
  8.         return cursor != fence;  
  9.     }  
  10.   
  11.     public E next() {  
  12.         if (cursor == fence)  
  13.             throw new NoSuchElementException();  
  14.         cursor = (cursor - 1) & (elements.length - 1); // tail是下个添加元素的位置,所以要减1才是尾节点的索引。  
  15.         E result = elements[cursor];  
  16.         if (head != fence || result == null)  
  17.             throw new ConcurrentModificationException();  
  18.         lastRet = cursor;  
  19.         return result;  
  20.     }  
  21.   
  22.     public void remove() {  
  23.         if (lastRet < 0)  
  24.             throw new IllegalStateException();  
  25.         if (!delete(lastRet)) { // 如果从左往右移,需要将游标加1。  
  26.             cursor = (cursor + 1) & (elements.length - 1);  
  27.             fence = head;  
  28.         }  
  29.         lastRet = -1;  
  30.     }  
  31. }  



Java代码  收藏代码
  1. public boolean contains(Object o) {  
  2.     if (o == null)  
  3.         return false// ArrayDeque不可以存储null元素  
  4.     int mask = elements.length - 1;  
  5.     int i = head;  
  6.     E x;  
  7.     while ( (x = elements[i]) != null) {  
  8.         if (o.equals(x))  
  9.             return true;  
  10.         i = (i + 1) & mask; // 处理临界情况  
  11.     }  
  12.     return false;  
  13. }  
  14.   
  15. public boolean remove(Object o) {  
  16.     return removeFirstOccurrence(o);  
  17. }  
  18.   
  19. public void clear() {  
  20.     int h = head;  
  21.     int t = tail;  
  22.     if (h != t) { // clear all cells  
  23.         head = tail = 0// 重置首尾索引  
  24.         int i = h;  
  25.         int mask = elements.length - 1;  
  26.         do {  
  27.             elements[i] = null// 清除元素  
  28.             i = (i + 1) & mask;  
  29.         } while (i != t);  
  30.     }  
  31. }  
  32.   
  33. public Object[] toArray() {  
  34.     return copyElements(new Object[size()]); // 把所有元素拷贝到新创建的Object数组上,所以对返回数组的修改不会影响该双端队列。  
  35. }  
  36.   
  37. public <T> T[] toArray(T[] a) {  
  38.     int size = size();  
  39.     if (a.length < size) // 目标数组大小不够  
  40.         a = (T[])java.lang.reflect.Array.newInstance(  
  41.                 a.getClass().getComponentType(), size); // 利用反射创建类型为T,大小为size的数组。  
  42. yElements(a); // 拷贝所有元素到目标数组。  
  43.     if (a.length > size)  
  44.         a[size] = null// 结束标识  
  45.     return a;  
  46. }  



11. Object方法 

Java代码  收藏代码
  1. public ArrayDeque<E> clone() {  
  2.     try {  
  3.         ArrayDeque<E> result = (ArrayDeque<E>) super.clone();  
  4.         result.elements = Arrays.copyOf(elements, elements.length); // 深度复制。  
  5.         return result;  
  6.   
  7.     } catch (CloneNotSupportedException e) {  
  8.         throw new AssertionError();  
  9.     }  
  10. }  

来源:http://czj4451.iteye.com/blog/1688693

 

分享到:
评论

相关推荐

    Java集合ArrayDeque类实例分析

    Java集合ArrayDeque类实例分析 Java集合ArrayDeque类实例分析主要介绍了ArrayDeque类的实现机理、基本特征和实现方法等相关知识点。 ArrayDeque类的继承结构 ArrayDeque类继承自AbstractCollection,实现了...

    java.util.ArrayDeque类使用方法详解

    Java中的`java.util.ArrayDeque`类是一个高效且灵活的数据结构,它实现了`Deque`接口,同时也继承了`AbstractCollection`和`AbstractQueue`。`ArrayDeque`是一个基于可变数组的双端队列,它的主要特点是它使用一个...

    数据结构—Java语言描述

    3. **栈**:栈是一种后进先出(LIFO)的数据结构,Java中的栈可以使用ArrayDeque类或者Stack类实现。栈在函数调用、表达式求值等方面有广泛应用。 4. **队列**:队列是一种先进先出(FIFO)的数据结构,Java中的...

    java 栈的实现和应用

    1. **ArrayDeque类**:Java集合框架提供了一个双端队列`ArrayDeque`,它可以被用作一个高效的栈。`ArrayDeque`继承自`AbstractCollection`,并实现了`Deque`接口,这个接口包含了栈的所有操作。创建一个栈并进行操作...

    java中LinkedList集合类实现栈和队列.doc

    在Java中,除了LinkedList,还可以使用ArrayDeque类来实现栈和队列,ArrayDeque提供了更高效的操作,因为它基于数组而不是链表。 在实际应用中,LinkedList适合于频繁插入和删除的场景,因为这些操作的时间复杂度为...

    用java实现数据结构,形成文档以及代码.zip

    栈是一种后进先出(LIFO)的数据结构,Java的ArrayDeque类可以作为栈来使用,提供了push和pop操作。 6. **队列**: 队列是一种先进先出(FIFO)的数据结构,Java的LinkedList或ArrayDeque类也可实现队列功能。 7...

    Java数据结构和算法

    Java中的栈可以使用ArrayDeque类或者Stack类来实现。栈的主要操作包括压入(push)、弹出(pop)和查看栈顶元素(peek)。 “队列”则是先进先出(FIFO)的数据结构,常见的应用包括任务调度和消息队列。Java提供了...

    Java语言程序设计与数据结构(基础篇)第6章课后习题代码chapter6.rar

    Java中,可以使用ArrayDeque类来实现栈。理解和实现基本的栈操作,如push、pop、peek等,是本章的重要内容。 4. **队列**:队列是先进先出(FIFO)的数据结构,常用于任务调度、消息传递等。Java的LinkedList类或...

    Java数据结构实现之Stack.zip

    - **ArrayDeque类**:ArrayDeque是Java集合框架的一部分,它是一个双端队列,但也可用作高效的栈。通过`push()`方法添加元素到栈顶,`pop()`方法移除并返回栈顶元素,`peek()`方法查看栈顶元素但不移除。 ```java...

    邓俊辉版java 数据结构源码

    队列是先进先出(FIFO)的数据结构,Java的LinkedList类可以方便地实现队列功能,或者使用ArrayDeque类的双端队列特性。 树是一种非线性的数据结构,二叉树是其中最简单的一种,每个节点最多有两个子节点。AVL树是...

    数据结构java版.rar

    Java的ArrayDeque类可以作为栈使用,提供push和pop等操作。此外,java.util.Stack类也是栈的实现,但效率较低。 4. **队列**:队列是一种先进先出(FIFO)的数据结构。Java提供了LinkedList类和ArrayDeque类来实现...

    《java数据结构》源码及课后答案

    Java中,LinkedList或ArrayDeque类都可以实现队列,另外还有专门的Queue接口和其实现类如LinkedList、ArrayBlockingQueue等。 五、栈和队列的变种:堆 堆是一种特殊的树形数据结构,满足堆属性:父节点的键值总是...

    java 数据结构课件

    Java中可以使用ArrayDeque类来实现栈的功能,也可以通过LinkedList类的push和pop方法操作。 队列是一种先进先出(FIFO)的数据结构,适用于处理一系列等待处理的任务,如任务调度。Java提供了LinkedList类和...

    数据结构教程.rar

    Java中可以使用LinkedList类或ArrayDeque类实现队列。 树是一种非线性数据结构,由节点和边构成,每个节点有零个或多个子节点。二叉树、二叉搜索树、平衡树(如AVL树和红黑树)是常见的树结构,它们在搜索、排序等...

    JavaEE技面试常见问题.doc

    在Java中,可以使用ArrayDeque类或LinkedList类来实现栈的功能。例如,使用push()方法添加元素,pop()方法移除并返回栈顶元素。 4. 算法: - 排序算法:常见的有冒泡排序、选择排序、插入排序、快速排序、归并排序...

    数据结构(java版)

    Java中的ArrayDeque类可以被用作栈,提供高效的push和pop操作。 4. **队列**:队列是一种先进先出(FIFO)的数据结构,常用于任务调度和消息传递。Java中的LinkedList类和ArrayDeque类都可实现队列。 5. **堆**:...

    数据结构和算法课程配套实现代码(java).zip

    Java中的ArrayDeque类可以作为栈使用。 4. 队列:先进先出(FIFO)的数据结构,常用操作是入队(enqueue)和出队(dequeue)。Java中的LinkedList或ArrayDeque类可实现队列。 5. 树:非线性数据结构,包含一个根...

    数据结构课程设计——池塘夜将彩色雨(Java模拟)

    Java的ArrayDeque类可以作为一个高效的栈实现。 4. **队列**:可能用于播放音频效果,如风声,因为它们遵循先进先出(FIFO)的原则。 5. **哈希表/映射**:可以用来关联每个荷花的位置与其颜色或状态,Java的...

    src1.rar_emptysl4_java_数据结构java

    在Java中,我们可以使用LinkedList类或者ArrayDeque类来实现队列。队列常用于任务调度、消息传递等场景。 3. **链表**: 链表不同于数组,它的元素在内存中不是连续存放的,每个元素(节点)包含数据和指向下一个...

    线性链表,栈(java版)代码

    在Java中,可以使用ArrayDeque类来实现栈,因为它提供了高效的栈操作: ```java import java.util.ArrayDeque; ArrayDeque&lt;Integer&gt; stack = new ArrayDeque(); stack.push(1); // 压栈 int topElement = stack....

Global site tag (gtag.js) - Google Analytics