RFR doclint issues in j.u.Deque & Queue
Chris Hegarty
chris.hegarty at oracle.com
Thu Aug 1 10:34:56 UTC 2013
These changes are already committed in the jsr166 CVS, this is a request
to pull them into jdk8.
Specdiff has been run, and there is nothing surprising.
The doclint issues are specifically around the addition of a caption to
the tables, the remaining changes are cleanup, <code> -> {@code ..}, etc.
Note: there are some minor doc updates around throwing an
IllegalStateException if no space is currently available in Deque, which
is already part of the spec.
Martin, Doug,
The 166 CVS is trivially missing 6546713,
http://cr.openjdk.java.net/~mduigou/6546713/0/webrev/src/share/classes/java/util/Deque.java.sdiff.html.
Once the changes below are in jdk8, you can easily sync with the 8
version, or apply the diffs from the webrev link above.
I have already reviewed these changes, but more reviewers are welcome.
diff -r 4bd51f6268f4 src/share/classes/java/util/Deque.java
--- a/src/share/classes/java/util/Deque.java Wed Jul 24 10:57:02 2013 +0200
+++ b/src/share/classes/java/util/Deque.java Thu Aug 01 11:24:48 2013 +0100
@@ -38,7 +38,7 @@ package java.util;
/**
* A linear collection that supports element insertion and removal at
* both ends. The name <i>deque</i> is short for "double ended queue"
- * and is usually pronounced "deck". Most <tt>Deque</tt>
+ * and is usually pronounced "deck". Most {@code Deque}
* implementations place no fixed limits on the number of elements
* they may contain, but this interface supports capacity-restricted
* deques as well as those with no fixed size limit.
@@ -47,10 +47,10 @@ package java.util;
* ends of the deque. Methods are provided to insert, remove, and
* examine the element. Each of these methods exists in two forms:
* one throws an exception if the operation fails, the other returns a
- * special value (either <tt>null</tt> or <tt>false</tt>, depending on
+ * special value (either {@code null} or {@code false}, depending on
* the operation). The latter form of the insert operation is
* designed specifically for use with capacity-restricted
- * <tt>Deque</tt> implementations; in most implementations, insert
+ * {@code Deque} implementations; in most implementations, insert
* operations cannot fail.
*
* <p>The twelve methods described above are summarized in the
@@ -58,6 +58,7 @@ package java.util;
*
* <p>
* <table BORDER CELLPADDING=3 CELLSPACING=1>
+ * <caption>Summary of Deque methods</caption>
* <tr>
* <td></td>
* <td ALIGN=CENTER COLSPAN = 2> <b>First Element (Head)</b></td>
@@ -72,38 +73,39 @@ package java.util;
* </tr>
* <tr>
* <td><b>Insert</b></td>
- * <td>{@link #addFirst addFirst(e)}</td>
- * <td>{@link #offerFirst offerFirst(e)}</td>
- * <td>{@link #addLast addLast(e)}</td>
- * <td>{@link #offerLast offerLast(e)}</td>
+ * <td>{@link Deque#addFirst addFirst(e)}</td>
+ * <td>{@link Deque#offerFirst offerFirst(e)}</td>
+ * <td>{@link Deque#addLast addLast(e)}</td>
+ * <td>{@link Deque#offerLast offerLast(e)}</td>
* </tr>
* <tr>
* <td><b>Remove</b></td>
- * <td>{@link #removeFirst removeFirst()}</td>
- * <td>{@link #pollFirst pollFirst()}</td>
- * <td>{@link #removeLast removeLast()}</td>
- * <td>{@link #pollLast pollLast()}</td>
+ * <td>{@link Deque#removeFirst removeFirst()}</td>
+ * <td>{@link Deque#pollFirst pollFirst()}</td>
+ * <td>{@link Deque#removeLast removeLast()}</td>
+ * <td>{@link Deque#pollLast pollLast()}</td>
* </tr>
* <tr>
* <td><b>Examine</b></td>
- * <td>{@link #getFirst getFirst()}</td>
- * <td>{@link #peekFirst peekFirst()}</td>
- * <td>{@link #getLast getLast()}</td>
- * <td>{@link #peekLast peekLast()}</td>
+ * <td>{@link Deque#getFirst getFirst()}</td>
+ * <td>{@link Deque#peekFirst peekFirst()}</td>
+ * <td>{@link Deque#getLast getLast()}</td>
+ * <td>{@link Deque#peekLast peekLast()}</td>
* </tr>
* </table>
*
* <p>This interface extends the {@link Queue} interface. When a deque is
* used as a queue, FIFO (First-In-First-Out) behavior results.
Elements are
* added at the end of the deque and removed from the beginning. The
methods
- * inherited from the <tt>Queue</tt> interface are precisely equivalent to
- * <tt>Deque</tt> methods as indicated in the following table:
+ * inherited from the {@code Queue} interface are precisely equivalent to
+ * {@code Deque} methods as indicated in the following table:
*
* <p>
* <table BORDER CELLPADDING=3 CELLSPACING=1>
+ * <caption>Comparison of Queue and Deque methods</caption>
* <tr>
- * <td ALIGN=CENTER> <b><tt>Queue</tt> Method</b></td>
- * <td ALIGN=CENTER> <b>Equivalent <tt>Deque</tt> Method</b></td>
+ * <td ALIGN=CENTER> <b>{@code Queue} Method</b></td>
+ * <td ALIGN=CENTER> <b>Equivalent {@code Deque} Method</b></td>
* </tr>
* <tr>
* <td>{@link java.util.Queue#add add(e)}</td>
@@ -135,13 +137,14 @@ package java.util;
* interface should be used in preference to the legacy {@link Stack}
class.
* When a deque is used as a stack, elements are pushed and popped
from the
* beginning of the deque. Stack methods are precisely equivalent to
- * <tt>Deque</tt> methods as indicated in the table below:
+ * {@code Deque} methods as indicated in the table below:
*
* <p>
* <table BORDER CELLPADDING=3 CELLSPACING=1>
+ * <caption>Comparison of Stack and Deque methods</caption>
* <tr>
* <td ALIGN=CENTER> <b>Stack Method</b></td>
- * <td ALIGN=CENTER> <b>Equivalent <tt>Deque</tt> Method</b></td>
+ * <td ALIGN=CENTER> <b>Equivalent {@code Deque} Method</b></td>
* </tr>
* <tr>
* <td>{@link #push push(e)}</td>
@@ -168,18 +171,18 @@ package java.util;
* <p>Unlike the {@link List} interface, this interface does not
* provide support for indexed access to elements.
*
- * <p>While <tt>Deque</tt> implementations are not strictly required
+ * <p>While {@code Deque} implementations are not strictly required
* to prohibit the insertion of null elements, they are strongly
- * encouraged to do so. Users of any <tt>Deque</tt> implementations
+ * encouraged to do so. Users of any {@code Deque} implementations
* that do allow null elements are strongly encouraged <i>not</i> to
* take advantage of the ability to insert nulls. This is so because
- * <tt>null</tt> is used as a special return value by various methods
+ * {@code null} is used as a special return value by various methods
* to indicated that the deque is empty.
*
- * <p><tt>Deque</tt> implementations generally do not define
- * element-based versions of the <tt>equals</tt> and <tt>hashCode</tt>
+ * <p>{@code Deque} implementations generally do not define
+ * element-based versions of the {@code equals} and {@code hashCode}
* methods, but instead inherit the identity-based versions from class
- * <tt>Object</tt>.
+ * {@code Object}.
*
* <p>This interface is a member of the <a
* href="{@docRoot}/../technotes/guides/collections/index.html"> Java
Collections
@@ -190,13 +193,13 @@ package java.util;
* @since 1.6
* @param <E> the type of elements held in this collection
*/
-
public interface Deque<E> extends Queue<E> {
/**
* Inserts the specified element at the front of this deque if it is
- * possible to do so immediately without violating capacity
restrictions.
- * When using a capacity-restricted deque, it is generally
preferable to
- * use method {@link #offerFirst}.
+ * possible to do so immediately without violating capacity
restrictions,
+ * throwing an {@code IllegalStateException} if no space is currently
+ * available. When using a capacity-restricted deque, it is generally
+ * preferable to use method {@link #offerFirst}.
*
* @param e the element to add
* @throws IllegalStateException if the element cannot be added at
this
@@ -212,9 +215,10 @@ public interface Deque<E> extends Queue<
/**
* Inserts the specified element at the end of this deque if it is
- * possible to do so immediately without violating capacity
restrictions.
- * When using a capacity-restricted deque, it is generally
preferable to
- * use method {@link #offerLast}.
+ * possible to do so immediately without violating capacity
restrictions,
+ * throwing an {@code IllegalStateException} if no space is currently
+ * available. When using a capacity-restricted deque, it is generally
+ * preferable to use method {@link #offerLast}.
*
* <p>This method is equivalent to {@link #add}.
*
@@ -237,8 +241,8 @@ public interface Deque<E> extends Queue<
* which can fail to insert an element only by throwing an exception.
*
* @param e the element to add
- * @return <tt>true</tt> if the element was added to this deque, else
- * <tt>false</tt>
+ * @return {@code true} if the element was added to this deque, else
+ * {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this deque
* @throws NullPointerException if the specified element is null
and this
@@ -255,8 +259,8 @@ public interface Deque<E> extends Queue<
* which can fail to insert an element only by throwing an exception.
*
* @param e the element to add
- * @return <tt>true</tt> if the element was added to this deque, else
- * <tt>false</tt>
+ * @return {@code true} if the element was added to this deque, else
+ * {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this deque
* @throws NullPointerException if the specified element is null
and this
@@ -288,17 +292,17 @@ public interface Deque<E> extends Queue<
/**
* Retrieves and removes the first element of this deque,
- * or returns <tt>null</tt> if this deque is empty.
+ * or returns {@code null} if this deque is empty.
*
- * @return the head of this deque, or <tt>null</tt> if this deque
is empty
+ * @return the head of this deque, or {@code null} if this deque is
empty
*/
E pollFirst();
/**
* Retrieves and removes the last element of this deque,
- * or returns <tt>null</tt> if this deque is empty.
+ * or returns {@code null} if this deque is empty.
*
- * @return the tail of this deque, or <tt>null</tt> if this deque
is empty
+ * @return the tail of this deque, or {@code null} if this deque is
empty
*/
E pollLast();
@@ -325,31 +329,31 @@ public interface Deque<E> extends Queue<
/**
* Retrieves, but does not remove, the first element of this deque,
- * or returns <tt>null</tt> if this deque is empty.
+ * or returns {@code null} if this deque is empty.
*
- * @return the head of this deque, or <tt>null</tt> if this deque
is empty
+ * @return the head of this deque, or {@code null} if this deque is
empty
*/
E peekFirst();
/**
* Retrieves, but does not remove, the last element of this deque,
- * or returns <tt>null</tt> if this deque is empty.
+ * or returns {@code null} if this deque is empty.
*
- * @return the tail of this deque, or <tt>null</tt> if this deque
is empty
+ * @return the tail of this deque, or {@code null} if this deque is
empty
*/
E peekLast();
/**
* Removes the first occurrence of the specified element from this
deque.
* If the deque does not contain the element, it is unchanged.
- * More formally, removes the first element <tt>e</tt> such that
+ * More formally, removes the first element {@code e} such that
* <tt>(o==null ? e==null : o.equals(e))</tt>
* (if such an element exists).
- * Returns <tt>true</tt> if this deque contained the specified element
+ * Returns {@code true} if this deque contained the specified element
* (or equivalently, if this deque changed as a result of the call).
*
* @param o element to be removed from this deque, if present
- * @return <tt>true</tt> if an element was removed as a result of
this call
+ * @return {@code true} if an element was removed as a result of
this call
* @throws ClassCastException if the class of the specified element
* is incompatible with this deque
* (<a href="Collection.html#optional-restrictions">optional</a>)
@@ -362,14 +366,14 @@ public interface Deque<E> extends Queue<
/**
* Removes the last occurrence of the specified element from this
deque.
* If the deque does not contain the element, it is unchanged.
- * More formally, removes the last element <tt>e</tt> such that
+ * More formally, removes the last element {@code e} such that
* <tt>(o==null ? e==null : o.equals(e))</tt>
* (if such an element exists).
- * Returns <tt>true</tt> if this deque contained the specified element
+ * Returns {@code true} if this deque contained the specified element
* (or equivalently, if this deque changed as a result of the call).
*
* @param o element to be removed from this deque, if present
- * @return <tt>true</tt> if an element was removed as a result of
this call
+ * @return {@code true} if an element was removed as a result of
this call
* @throws ClassCastException if the class of the specified element
* is incompatible with this deque
* (<a href="Collection.html#optional-restrictions">optional</a>)
@@ -385,15 +389,15 @@ public interface Deque<E> extends Queue<
* Inserts the specified element into the queue represented by
this deque
* (in other words, at the tail of this deque) if it is possible
to do so
* immediately without violating capacity restrictions, returning
- * <tt>true</tt> upon success and throwing an
- * <tt>IllegalStateException</tt> if no space is currently available.
+ * {@code true} upon success and throwing an
+ * {@code IllegalStateException} if no space is currently available.
* When using a capacity-restricted deque, it is generally
preferable to
* use {@link #offer(Object) offer}.
*
* <p>This method is equivalent to {@link #addLast}.
*
* @param e the element to add
- * @return <tt>true</tt> (as specified by {@link Collection#add})
+ * @return {@code true} (as specified by {@link Collection#add})
* @throws IllegalStateException if the element cannot be added at
this
* time due to capacity restrictions
* @throws ClassCastException if the class of the specified element
@@ -409,7 +413,7 @@ public interface Deque<E> extends Queue<
* Inserts the specified element into the queue represented by
this deque
* (in other words, at the tail of this deque) if it is possible
to do so
* immediately without violating capacity restrictions, returning
- * <tt>true</tt> upon success and <tt>false</tt> if no space is
currently
+ * {@code true} upon success and {@code false} if no space is currently
* available. When using a capacity-restricted deque, this method is
* generally preferable to the {@link #add} method, which can fail to
* insert an element only by throwing an exception.
@@ -417,8 +421,8 @@ public interface Deque<E> extends Queue<
* <p>This method is equivalent to {@link #offerLast}.
*
* @param e the element to add
- * @return <tt>true</tt> if the element was added to this deque, else
- * <tt>false</tt>
+ * @return {@code true} if the element was added to this deque, else
+ * {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this deque
* @throws NullPointerException if the specified element is null
and this
@@ -444,11 +448,11 @@ public interface Deque<E> extends Queue<
/**
* Retrieves and removes the head of the queue represented by this
deque
* (in other words, the first element of this deque), or returns
- * <tt>null</tt> if this deque is empty.
+ * {@code null} if this deque is empty.
*
* <p>This method is equivalent to {@link #pollFirst()}.
*
- * @return the first element of this deque, or <tt>null</tt> if
+ * @return the first element of this deque, or {@code null} if
* this deque is empty
*/
E poll();
@@ -469,12 +473,12 @@ public interface Deque<E> extends Queue<
/**
* Retrieves, but does not remove, the head of the queue
represented by
* this deque (in other words, the first element of this deque), or
- * returns <tt>null</tt> if this deque is empty.
+ * returns {@code null} if this deque is empty.
*
* <p>This method is equivalent to {@link #peekFirst()}.
*
* @return the head of the queue represented by this deque, or
- * <tt>null</tt> if this deque is empty
+ * {@code null} if this deque is empty
*/
E peek();
@@ -484,9 +488,8 @@ public interface Deque<E> extends Queue<
/**
* Pushes an element onto the stack represented by this deque (in
other
* words, at the head of this deque) if it is possible to do so
- * immediately without violating capacity restrictions, returning
- * <tt>true</tt> upon success and throwing an
- * <tt>IllegalStateException</tt> if no space is currently available.
+ * immediately without violating capacity restrictions, throwing an
+ * {@code IllegalStateException} if no space is currently available.
*
* <p>This method is equivalent to {@link #addFirst}.
*
@@ -520,16 +523,16 @@ public interface Deque<E> extends Queue<
/**
* Removes the first occurrence of the specified element from this
deque.
* If the deque does not contain the element, it is unchanged.
- * More formally, removes the first element <tt>e</tt> such that
+ * More formally, removes the first element {@code e} such that
* <tt>(o==null ? e==null : o.equals(e))</tt>
* (if such an element exists).
- * Returns <tt>true</tt> if this deque contained the specified element
+ * Returns {@code true} if this deque contained the specified element
* (or equivalently, if this deque changed as a result of the call).
*
- * <p>This method is equivalent to {@link #removeFirstOccurrence}.
+ * <p>This method is equivalent to {@link
#removeFirstOccurrence(Object)}.
*
* @param o element to be removed from this deque, if present
- * @return <tt>true</tt> if an element was removed as a result of
this call
+ * @return {@code true} if an element was removed as a result of
this call
* @throws ClassCastException if the class of the specified element
* is incompatible with this deque
* (<a href="Collection.html#optional-restrictions">optional</a>)
@@ -540,13 +543,13 @@ public interface Deque<E> extends Queue<
boolean remove(Object o);
/**
- * Returns <tt>true</tt> if this deque contains the specified element.
- * More formally, returns <tt>true</tt> if and only if this deque
contains
- * at least one element <tt>e</tt> such that
+ * Returns {@code true} if this deque contains the specified element.
+ * More formally, returns {@code true} if and only if this deque
contains
+ * at least one element {@code e} such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this deque is to be tested
- * @return <tt>true</tt> if this deque contains the specified element
+ * @return {@code true} if this deque contains the specified element
* @throws ClassCastException if the type of the specified element
* is incompatible with this deque
* (<a href="Collection.html#optional-restrictions">optional</a>)
diff -r 4bd51f6268f4 src/share/classes/java/util/Queue.java
--- a/src/share/classes/java/util/Queue.java Wed Jul 24 10:57:02 2013 +0200
+++ b/src/share/classes/java/util/Queue.java Thu Aug 01 11:24:48 2013 +0100
@@ -41,14 +41,15 @@ package java.util;
* queues provide additional insertion, extraction, and inspection
* operations. Each of these methods exists in two forms: one throws
* an exception if the operation fails, the other returns a special
- * value (either <tt>null</tt> or <tt>false</tt>, depending on the
+ * value (either {@code null} or {@code false}, depending on the
* operation). The latter form of the insert operation is designed
- * specifically for use with capacity-restricted <tt>Queue</tt>
+ * specifically for use with capacity-restricted {@code Queue}
* implementations; in most implementations, insert operations cannot
* fail.
*
* <p>
* <table BORDER CELLPADDING=3 CELLSPACING=1>
+ * <caption>Summary of Queue methods</caption>
* <tr>
* <td></td>
* <td ALIGN=CENTER><em>Throws exception</em></td>
@@ -56,18 +57,18 @@ package java.util;
* </tr>
* <tr>
* <td><b>Insert</b></td>
- * <td>{@link #add add(e)}</td>
- * <td>{@link #offer offer(e)}</td>
+ * <td>{@link Queue#add add(e)}</td>
+ * <td>{@link Queue#offer offer(e)}</td>
* </tr>
* <tr>
* <td><b>Remove</b></td>
- * <td>{@link #remove remove()}</td>
- * <td>{@link #poll poll()}</td>
+ * <td>{@link Queue#remove remove()}</td>
+ * <td>{@link Queue#poll poll()}</td>
* </tr>
* <tr>
* <td><b>Examine</b></td>
- * <td>{@link #element element()}</td>
- * <td>{@link #peek peek()}</td>
+ * <td>{@link Queue#element element()}</td>
+ * <td>{@link Queue#peek peek()}</td>
* </tr>
* </table>
*
@@ -79,15 +80,15 @@ package java.util;
* Whatever the ordering used, the <em>head</em> of the queue is that
* element which would be removed by a call to {@link #remove() } or
* {@link #poll()}. In a FIFO queue, all new elements are inserted at
- * the <em> tail</em> of the queue. Other kinds of queues may use
- * different placement rules. Every <tt>Queue</tt> implementation
+ * the <em>tail</em> of the queue. Other kinds of queues may use
+ * different placement rules. Every {@code Queue} implementation
* must specify its ordering properties.
*
* <p>The {@link #offer offer} method inserts an element if possible,
- * otherwise returning <tt>false</tt>. This differs from the {@link
+ * otherwise returning {@code false}. This differs from the {@link
* java.util.Collection#add Collection.add} method, which can fail to
* add an element only by throwing an unchecked exception. The
- * <tt>offer</tt> method is designed for use when failure is a normal,
+ * {@code offer} method is designed for use when failure is a normal,
* rather than exceptional occurrence, for example, in fixed-capacity
* (or "bounded") queues.
*
@@ -95,32 +96,32 @@ package java.util;
* return the head of the queue.
* Exactly which element is removed from the queue is a
* function of the queue's ordering policy, which differs from
- * implementation to implementation. The <tt>remove()</tt> and
- * <tt>poll()</tt> methods differ only in their behavior when the
- * queue is empty: the <tt>remove()</tt> method throws an exception,
- * while the <tt>poll()</tt> method returns <tt>null</tt>.
+ * implementation to implementation. The {@code remove()} and
+ * {@code poll()} methods differ only in their behavior when the
+ * queue is empty: the {@code remove()} method throws an exception,
+ * while the {@code poll()} method returns {@code null}.
*
* <p>The {@link #element()} and {@link #peek()} methods return, but do
* not remove, the head of the queue.
*
- * <p>The <tt>Queue</tt> interface does not define the <i>blocking queue
+ * <p>The {@code Queue} interface does not define the <i>blocking queue
* methods</i>, which are common in concurrent programming. These
methods,
* which wait for elements to appear or for space to become available, are
* defined in the {@link java.util.concurrent.BlockingQueue}
interface, which
* extends this interface.
*
- * <p><tt>Queue</tt> implementations generally do not allow insertion
- * of <tt>null</tt> elements, although some implementations, such as
- * {@link LinkedList}, do not prohibit insertion of <tt>null</tt>.
- * Even in the implementations that permit it, <tt>null</tt> should
- * not be inserted into a <tt>Queue</tt>, as <tt>null</tt> is also
- * used as a special return value by the <tt>poll</tt> method to
+ * <p>{@code Queue} implementations generally do not allow insertion
+ * of {@code null} elements, although some implementations, such as
+ * {@link LinkedList}, do not prohibit insertion of {@code null}.
+ * Even in the implementations that permit it, {@code null} should
+ * not be inserted into a {@code Queue}, as {@code null} is also
+ * used as a special return value by the {@code poll} method to
* indicate that the queue contains no elements.
*
- * <p><tt>Queue</tt> implementations generally do not define
- * element-based versions of methods <tt>equals</tt> and
- * <tt>hashCode</tt> but instead inherit the identity based versions
- * from class <tt>Object</tt>, because element-based equality is not
+ * <p>{@code Queue} implementations generally do not define
+ * element-based versions of methods {@code equals} and
+ * {@code hashCode} but instead inherit the identity based versions
+ * from class {@code Object}, because element-based equality is not
* always well-defined for queues with the same elements but different
* ordering properties.
*
@@ -145,11 +146,11 @@ public interface Queue<E> extends Collec
/**
* Inserts the specified element into this queue if it is possible
to do so
* immediately without violating capacity restrictions, returning
- * <tt>true</tt> upon success and throwing an
<tt>IllegalStateException</tt>
+ * {@code true} upon success and throwing an {@code
IllegalStateException}
* if no space is currently available.
*
* @param e the element to add
- * @return <tt>true</tt> (as specified by {@link Collection#add})
+ * @return {@code true} (as specified by {@link Collection#add})
* @throws IllegalStateException if the element cannot be added at
this
* time due to capacity restrictions
* @throws ClassCastException if the class of the specified element
@@ -169,8 +170,8 @@ public interface Queue<E> extends Collec
* by throwing an exception.
*
* @param e the element to add
- * @return <tt>true</tt> if the element was added to this queue, else
- * <tt>false</tt>
+ * @return {@code true} if the element was added to this queue, else
+ * {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null and
@@ -192,9 +193,9 @@ public interface Queue<E> extends Collec
/**
* Retrieves and removes the head of this queue,
- * or returns <tt>null</tt> if this queue is empty.
+ * or returns {@code null} if this queue is empty.
*
- * @return the head of this queue, or <tt>null</tt> if this queue
is empty
+ * @return the head of this queue, or {@code null} if this queue is
empty
*/
E poll();
@@ -210,9 +211,9 @@ public interface Queue<E> extends Collec
/**
* Retrieves, but does not remove, the head of this queue,
- * or returns <tt>null</tt> if this queue is empty.
+ * or returns {@code null} if this queue is empty.
*
- * @return the head of this queue, or <tt>null</tt> if this queue
is empty
+ * @return the head of this queue, or {@code null} if this queue is
empty
*/
E peek();
}
-Chris.
More information about the core-libs-dev
mailing list