数据结构-队列(3)-使用Java内置队列

大多数流行语言都提供内置的队列库，因此您无需重新发明轮子。

如前所述，队列有两个重要的操作，入队 enqueue 和出队 dequeue。此外，我们应该能够获得队列中的第一个元素，因为应该首先处理它。

下面是使用内置队列库及其常见操作的一些示例：

 package queue;

 import java.util.LinkedList;

 import java.util.Queue;

 //"static void main" must be defined in a public class.

 //“静态void main”必须在公共类中定义。

 public class Main3 {

  public static void main(String[] args) {

      // 1. Initialize a queue.

      //1.初始化一个队列。

      Queue<Integer> q = new LinkedList();

      // 2. Get the first element - return null if queue is empty.

      //2.获取第一个元素——如果队列为空，返回null。

      System.out.println("The first element is: " + q.peek());

      // 3. Push new element.

      //3. 插入新元素。

      q.offer(5);

      q.offer(13);

      q.offer(8);

      q.offer(6);

      // 4. Pop an element.

      //4. 检索并删除该队列的头，如果此队列为空，则返回{@code null}。

      q.poll();

      // 5. Get the first element.

      //5. 得到第一个元素。

      System.out.println("The first element is: " + q.peek());

      // 7. Get the size of the queue.

      //获取队列的大小。

      System.out.println("The size is: " + q.size());

  }

 }

JDK中关于LinkedList的方法摘要

构造方法摘要
`LinkedList()` 构造一个空列表。
`LinkedList(Collection<? extends E> c)` 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

方法摘要

boolean add(E e)

将指定元素添加到此列表的结尾。

void add(int index, E element)

在此列表中指定的位置插入指定的元素。

boolean addAll(Collection<? extends E> c)
添加指定
collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

boolean addAll(int index, Collection<? extends E> c)
将指定
collection 中的所有元素从指定位置开始插入此列表。

void addFirst(E e)

将指定元素插入此列表的开头。

void addLast(E e)

将指定元素添加到此列表的结尾。

void clear()

从此列表中移除所有元素。

Object clone()

返回此 LinkedList 的浅表副本。

boolean contains(Object o)

如果此列表包含指定元素，则返回 true。

Iterator<E> descendingIterator()

返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

E element()

获取但不移除此列表的头（第一个元素）。

E get(int index)

返回此列表中指定位置处的元素。

E getFirst()

返回此列表的第一个元素。

E getLast()

返回此列表的最后一个元素。

int indexOf(Object o)

返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

int lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

ListIterator<E> listIterator(int index)

返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

boolean offer(E e)

将指定元素添加到此列表的末尾（最后一个元素）。

boolean offerFirst(E e)

在此列表的开头插入指定的元素。

boolean offerLast(E e)

在此列表末尾插入指定的元素。

E peek()

获取但不移除此列表的头（第一个元素）。

E peekFirst()

获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

E peekLast()

获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

E poll()

获取并移除此列表的头（第一个元素）

E pollFirst()

获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

E pollLast()

获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

E pop()

从此列表所表示的堆栈处弹出一个元素。

void push(E e)

将元素推入此列表所表示的堆栈。

E remove()

获取并移除此列表的头（第一个元素）。

E remove(int index)

移除此列表中指定位置处的元素。

boolean remove(Object o)

从此列表中移除首次出现的指定元素（如果存在）。

E removeFirst()

移除并返回此列表的第一个元素。

boolean removeFirstOccurrence(Object o)

从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。

E removeLast()

移除并返回此列表的最后一个元素。

boolean removeLastOccurrence(Object o)

从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

E set(int index, E element)

将此列表中指定位置的元素替换为指定的元素。

int size()

返回此列表的元素数。

Object[] toArray()

返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

<T>

T[]

toArray(T[] a)

返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

构造方法详细信息

LinkedList

public LinkedList()

构造一个空列表。

LinkedList

public LinkedList(Collection<? extends E> c)

构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

参数：: c - 要将其元素放入此列表的 collection
抛出：: NullPointerException - 如果指定的 collection 为 null

方法详细信息

getFirst

public E getFirst()

返回此列表的第一个元素。

指定者：: 接口 Deque<E> 中的 getFirst

返回：: 此列表的第一个元素
抛出：: NoSuchElementException - 如果此列表为空

getLast

public E getLast()

返回此列表的最后一个元素。

指定者：: 接口 Deque<E> 中的 getLast

返回：: 此列表的最后一个元素
抛出：: NoSuchElementException - 如果此列表为空

removeFirst

public E removeFirst()

移除并返回此列表的第一个元素。

指定者：: 接口 Deque<E> 中的 removeFirst

返回：: 此列表的第一个元素
抛出：: NoSuchElementException - 如果此列表为空

removeLast

public E removeLast()

移除并返回此列表的最后一个元素。

指定者：: 接口 Deque<E> 中的 removeLast

返回：: 此列表的最后一个元素
抛出：: NoSuchElementException - 如果此列表为空

addFirst

public void addFirst(E e)

将指定元素插入此列表的开头。

指定者：: 接口 Deque<E> 中的 addFirst

参数：: e - 要添加的元素

addLast

public void addLast(E e)

将指定元素添加到此列表的结尾。

此方法等效于 add(E)。

指定者：: 接口 Deque<E> 中的 addLast

参数：: e - 要添加的元素

contains

public boolean contains(Object o)

如果此列表包含指定元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时返回 true。

指定者：: 接口 Collection<E> 中的 contains
指定者：: 接口 Deque<E> 中的 contains
指定者：: 接口 List<E> 中的 contains
覆盖：: 类 AbstractCollection<E> 中的 contains

参数：: o - 要测试在此列表中是否存在的元素
返回：: 如果此列表包含指定元素，则返回 true

size

public int size()

返回此列表的元素数。

指定者：: 接口 Collection<E> 中的 size
指定者：: 接口 Deque<E> 中的 size
指定者：: 接口 List<E> 中的 size
指定者：: 类 AbstractCollection<E> 中的 size

返回：: 此列表的元素数

add

public boolean add(E e)

将指定元素添加到此列表的结尾。

此方法等效于 addLast(E)。

指定者：: 接口 Collection<E> 中的 add
指定者：: 接口 Deque<E> 中的 add
指定者：: 接口 List<E> 中的 add
指定者：: 接口 Queue<E> 中的 add
覆盖：: 类 AbstractList<E> 中的 add

参数：: e - 要添加到此列表的元素
返回：: true（根据 Collection.add(E) 的规定）

remove

public boolean remove(Object o)

从此列表中移除首次出现的指定元素（如果存在）。如果列表不包含该元素，则不作更改。更确切地讲，移除具有满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i 的元素（如果存在这样的元素）。如果此列表已包含指定元素（或者此列表由于调用而发生更改），则返回 true。

指定者：: 接口 Collection<E> 中的 remove
指定者：: 接口 Deque<E> 中的 remove
指定者：: 接口 List<E> 中的 remove
覆盖：: 类 AbstractCollection<E> 中的 remove

参数：: o - 要从此列表删除的元素，如果存在
返回：: 如果此列表包含指定元素，则返回 true

addAll

public boolean addAll(Collection<? extends E> c)

添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。如果指定的 collection 在操作过程中被修改，则此操作的行为是不确定的。（注意，如果指定 collection 就是此列表并且非空，则此操作的行为是不确定的。）

指定者：: 接口 Collection<E> 中的 addAll
指定者：: 接口 List<E> 中的 addAll
覆盖：: 类 AbstractCollection<E> 中的 addAll

参数：: c - 包含要添加到此列表的元素的 collection
返回：: 如果此列表由于调用而更改，则返回 true
抛出：: NullPointerException - 如果指定的 collection 为 null
另请参见：: AbstractCollection.add(Object)

addAll

public boolean addAll(int index,

                      Collection<? extends E> c)

将指定 collection 中的所有元素从指定位置开始插入此列表。移动当前在该位置上的元素（如果有），所有后续元素都向右移（增加其索引）。新元素将按由指定 collection 的迭代器返回的顺序在列表中显示。

指定者：: 接口 List<E> 中的 addAll
覆盖：: 类 AbstractSequentialList<E> 中的 addAll

参数：: index - 在其中插入指定 collection 中第一个元素的索引; c - 包含要添加到此列表的元素的 collection
返回：: 如果此列表由于调用而更改，则返回 true
抛出：: IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size()); NullPointerException - 如果指定的 collection 为 null

clear

public void clear()

从此列表中移除所有元素。

指定者：: 接口 Collection<E> 中的 clear
指定者：: 接口 List<E> 中的 clear
覆盖：: 类 AbstractList<E> 中的 clear

get

public E get(int index)

返回此列表中指定位置处的元素。

指定者：: 接口 List<E> 中的 get
覆盖：: 类 AbstractSequentialList<E> 中的 get

参数：: index - 要返回的元素的索引
返回：: 列表中指定位置的元素
抛出：: IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

set

public E set(int index,

             E element)

将此列表中指定位置的元素替换为指定的元素。

指定者：: 接口 List<E> 中的 set
覆盖：: 类 AbstractSequentialList<E> 中的 set

参数：: index - 要替换的元素的索引; element - 要在指定位置存储的元素
返回：: 以前在指定位置的元素
抛出：: IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

add

public void add(int index,

                E element)

在此列表中指定的位置插入指定的元素。移动当前在该位置处的元素（如果有），所有后续元素都向右移（在其索引中添加 1）。

指定者：: 接口 List<E> 中的 add
覆盖：: 类 AbstractSequentialList<E> 中的 add

参数：: index - 要在其中插入指定元素的索引; element - 要插入的元素
抛出：: IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

remove

public E remove(int index)

移除此列表中指定位置处的元素。将任何后续元素向左移（从索引中减 1）。返回从列表中删除的元素。

指定者：: 接口 List<E> 中的 remove
覆盖：: 类 AbstractSequentialList<E> 中的 remove

参数：: index - 要移除的元素的索引
返回：: 以前在指定位置的元素
抛出：: IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

indexOf

public int indexOf(Object o)

返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果没有此索引，则返回 -1。

指定者：: 接口 List<E> 中的 indexOf
覆盖：: 类 AbstractList<E> 中的 indexOf

参数：: o - 要搜索的元素
返回：: 此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1

lastIndexOf

public int lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果没有此索引，则返回 -1。

指定者：: 接口 List<E> 中的 lastIndexOf
覆盖：: 类 AbstractList<E> 中的 lastIndexOf

参数：: o - 要搜索的元素
返回：: 此列表中最后出现的指定元素的索引；如果此列表中不包含该元素，则返回 -1

peek

public E peek()

获取但不移除此列表的头（第一个元素）。

指定者：: 接口 Deque<E> 中的 peek
指定者：: 接口 Queue<E> 中的 peek

返回：: 此列表的头，如果此列表为空，则返回 null
从以下版本开始：: 1.5

element

public E element()

获取但不移除此列表的头（第一个元素）。

指定者：: 接口 Deque<E> 中的 element
指定者：: 接口 Queue<E> 中的 element

返回：: 列表的头
抛出：: NoSuchElementException - 如果此列表为空
从以下版本开始：: 1.5

poll

public E poll()

获取并移除此列表的头（第一个元素）

指定者：: 接口 Deque<E> 中的 poll
指定者：: 接口 Queue<E> 中的 poll

返回：: 此列表的头，如果此列表为空，则返回 null
从以下版本开始：: 1.5

remove

public E remove()

获取并移除此列表的头（第一个元素）。

指定者：: 接口 Deque<E> 中的 remove
指定者：: 接口 Queue<E> 中的 remove

返回：: 列表的头
抛出：: NoSuchElementException - 如果此列表为空
从以下版本开始：: 1.5

offer

public boolean offer(E e)

将指定元素添加到此列表的末尾（最后一个元素）。

指定者：: 接口 Deque<E> 中的 offer
指定者：: 接口 Queue<E> 中的 offer

参数：: e - 要添加的元素
返回：: true（根据 Queue.offer(E) 的规定）
从以下版本开始：: 1.5

offerFirst

public boolean offerFirst(E e)

在此列表的开头插入指定的元素。

指定者：: 接口 Deque<E> 中的 offerFirst

参数：: e - 要插入的元素
返回：: true（根据 Deque.offerFirst(E) 的规定）
从以下版本开始：: 1.6

offerLast

public boolean offerLast(E e)

在此列表末尾插入指定的元素。

指定者：: 接口 Deque<E> 中的 offerLast

参数：: e - 要插入的元素
返回：: true（根据 Deque.offerLast(E) 的规定）
从以下版本开始：: 1.6

peekFirst

public E peekFirst()

获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

指定者：: 接口 Deque<E> 中的 peekFirst

返回：: 此列表的第一个元素；如果此列表为空，则返回 null
从以下版本开始：: 1.6

peekLast

public E peekLast()

获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

指定者：: 接口 Deque<E> 中的 peekLast

返回：: 此列表的最后一个元素；如果此列表为空，则返回 null
从以下版本开始：: 1.6

pollFirst

public E pollFirst()

获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

指定者：: 接口 Deque<E> 中的 pollFirst

返回：: 此列表的第一个元素；如果此列表为空，则返回 null
从以下版本开始：: 1.6

pollLast

public E pollLast()

获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

指定者：: 接口 Deque<E> 中的 pollLast

返回：: 此列表的最后一个元素；如果此列表为空，则返回 null
从以下版本开始：: 1.6

push

public void push(E e)

将元素推入此列表所表示的堆栈。换句话说，将该元素插入此列表的开头。

此方法等效于 addFirst(E)。

指定者：: 接口 Deque<E> 中的 push

参数：: e - 要推入的元素
从以下版本开始：: 1.6

pop

public E pop()

从此列表所表示的堆栈处弹出一个元素。换句话说，移除并返回此列表的第一个元素。

此方法等效于 removeFirst()。

指定者：: 接口 Deque<E> 中的 pop

返回：: 此列表开头的元素（它是此列表所表示的堆栈的顶部）
抛出：: NoSuchElementException - 如果此列表为空
从以下版本开始：: 1.6

removeFirstOccurrence

public boolean removeFirstOccurrence(Object o)

从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。如果列表不包含该元素，则不作更改。

指定者：: 接口 Deque<E> 中的 removeFirstOccurrence

参数：: o - 要从此列表中移除的元素（如果存在）
返回：: 如果该列表已包含指定元素，则返回 true
从以下版本开始：: 1.6

removeLastOccurrence

public boolean removeLastOccurrence(Object o)

从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。如果列表不包含该元素，则不作更改。

指定者：: 接口 Deque<E> 中的 removeLastOccurrence

参数：: o - 要从此列表中移除的元素（如果存在）
返回：: 如果该列表已包含指定元素，则返回 true
从以下版本开始：: 1.6

listIterator

public ListIterator<E> listIterator(int index)

返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。遵守 List.listIterator(int) 的常规协定。

列表迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过列表迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，列表迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确定行为的风险。

指定者：: 接口 List<E> 中的 listIterator
指定者：: 类 AbstractSequentialList<E> 中的 listIterator

参数：: index - 要从列表迭代器返回的第一个元素的索引（通过调用 next 方法）
返回：: 此列表中的元素的 ListIterator（按适当顺序），从列表中指定位置开始
抛出：: IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
另请参见：: List.listIterator(int)

descendingIterator

public Iterator<E> descendingIterator()

从接口 Deque 复制的描述

返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个（尾部）到第一个（头部）的顺序返回。

指定者：: 接口 Deque<E> 中的 descendingIterator

返回：: 以逆向顺序在此双端队列中的元素上进行迭代的迭代器
从以下版本开始：: 1.6

clone

public Object clone()

返回此 LinkedList 的浅表副本。（这些元素本身没有复制。）

覆盖：: 类 Object 中的 clone

返回：: 此 LinkedList 实例的浅表副本
另请参见：: Cloneable

toArray

public Object[] toArray()

返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

由于此列表不维护对返回数组的任何引用，因而它将是“安全的”。（换句话说，此方法必须分配一个新数组）。因此，调用者可以随意修改返回的数组。

此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。

指定者：: 接口 Collection<E> 中的 toArray
指定者：: 接口 List<E> 中的 toArray
覆盖：: 类 AbstractCollection<E> 中的 toArray

返回：: 以适当顺序包含此列表中所有元素的数组。
另请参见：: Arrays.asList(Object[])

toArray

public <T> T[] toArray(T[] a)

返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。如果指定数组能容纳列表，则在其中返回该列表。否则，分配具有指定数组的运行时类型和此列表大小的新数组。

如果指定数组能容纳列表，并有剩余空间（即数组比列表元素多），则紧跟在列表末尾的数组元素会被设置为 null。（只有在调用者知道列表不包含任何 null 元素时，才可使用此方法来确定列表的长度。）

像 toArray() 方法一样，此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。更进一步说，此方法允许对输出数组的运行时类型上进行精确控制，在某些情况下，可以用来节省分配开销。

假定 x 是只包含字符串的一个已知列表。以下代码可用来将该列表转储到一个新分配的 String 数组：

     String[] y = x.toArray(new String[0]);

注意，toArray(new Object[0]) 和 toArray() 在功能上是相同的。

指定者：: 接口 Collection<E> 中的 toArray
指定者：: 接口 List<E> 中的 toArray
覆盖：: 类 AbstractCollection<E> 中的 toArray

参数：: a - 要在其中存储列表元素的数组（如果它足够大）；否则，为其分配具有相同运行时类型的新数组
返回：: 包含列表元素的数组
抛出：: ArrayStoreException - 如果指定数组的运行时类型不是此列表中每个元素的运行时类型的超类型; NullPointerException - 如果指定的数组为 null