[cvs] / jsr166 / src / main / java / util / Deque.java Repository:
ViewVC logotype

Diff of /jsr166/src/main/java/util/Deque.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.17, Wed Sep 14 23:49:59 2005 UTC revision 1.30, Tue Dec 2 05:48:28 2014 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea and Josh Bloch with assistance from members of   * Written by Doug Lea and Josh Bloch with assistance from members of
3   * JCP JSR-166 Expert Group and released to the public domain, as explained   * JCP JSR-166 Expert Group and released to the public domain, as explained
4   * at http://creativecommons.org/licenses/publicdomain   * at http://creativecommons.org/publicdomain/zero/1.0/
5   */   */
6    
7  package java.util;  package java.util;
 import java.util.*; // for javadoc (till 6280605 is fixed)  
8    
9  /**  /**
10   * A linear collection that supports element insertion and removal at   * A linear collection that supports element insertion and removal at
11   * both ends.  The name <i>deque</i> is short for "double ended queue"   * both ends.  The name <i>deque</i> is short for "double ended queue"
12   * and is usually pronounced "deck".  Most <tt>Deque</tt>   * and is usually pronounced "deck".  Most {@code Deque}
13   * implementations place no fixed limits on the number of elements   * implementations place no fixed limits on the number of elements
14   * they may contain, but this interface supports capacity-restricted   * they may contain, but this interface supports capacity-restricted
15   * deques as well as those with no fixed size limit.   * deques as well as those with no fixed size limit.
# Line 19  Line 18 
18   * ends of the deque.  Methods are provided to insert, remove, and   * ends of the deque.  Methods are provided to insert, remove, and
19   * examine the element.  Each of these methods exists in two forms:   * examine the element.  Each of these methods exists in two forms:
20   * one throws an exception if the operation fails, the other returns a   * one throws an exception if the operation fails, the other returns a
21   * special value (either <tt>null</tt> or <tt>false</tt>, depending on   * special value (either {@code null} or {@code false}, depending on
22   * the operation).  The latter form of the insert operation is   * the operation).  The latter form of the insert operation is
23   * designed specifically for use with capacity-restricted   * designed specifically for use with capacity-restricted
24   * <tt>Deque</tt> implementations; in most implementations, insert   * {@code Deque} implementations; in most implementations, insert
25   * operations cannot fail.   * operations cannot fail.
26   *   *
27   * <p>The twelve methods described above are summarized in the   * <p>The twelve methods described above are summarized in the
28   * following table:   * following table:
29   *   *
  * <p>  
30   * <table BORDER CELLPADDING=3 CELLSPACING=1>   * <table BORDER CELLPADDING=3 CELLSPACING=1>
31     * <caption>Summary of Deque methods</caption>
32   *  <tr>   *  <tr>
33   *    <td></td>   *    <td></td>
34   *    <td ALIGN=CENTER COLSPAN = 2> <b>First Element (Head)</b></td>   *    <td ALIGN=CENTER COLSPAN = 2> <b>First Element (Head)</b></td>
# Line 44  Line 43 
43   *  </tr>   *  </tr>
44   *  <tr>   *  <tr>
45   *    <td><b>Insert</b></td>   *    <td><b>Insert</b></td>
46   *    <td>{@link #addFirst addFirst(e)}</td>   *    <td>{@link Deque#addFirst addFirst(e)}</td>
47   *    <td>{@link #offerFirst offerFirst(e)}</td>   *    <td>{@link Deque#offerFirst offerFirst(e)}</td>
48   *    <td>{@link #addLast addLast(e)}</td>   *    <td>{@link Deque#addLast addLast(e)}</td>
49   *    <td>{@link #offerLast offerLast(e)}</td>   *    <td>{@link Deque#offerLast offerLast(e)}</td>
50   *  </tr>   *  </tr>
51   *  <tr>   *  <tr>
52   *    <td><b>Remove</b></td>   *    <td><b>Remove</b></td>
53   *    <td>{@link #removeFirst removeFirst()}</td>   *    <td>{@link Deque#removeFirst removeFirst()}</td>
54   *    <td>{@link #pollFirst pollFirst()}</td>   *    <td>{@link Deque#pollFirst pollFirst()}</td>
55   *    <td>{@link #removeLast removeLast()}</td>   *    <td>{@link Deque#removeLast removeLast()}</td>
56   *    <td>{@link #pollLast pollLast()}</td>   *    <td>{@link Deque#pollLast pollLast()}</td>
57   *  </tr>   *  </tr>
58   *  <tr>   *  <tr>
59   *    <td><b>Examine</b></td>   *    <td><b>Examine</b></td>
60   *    <td>{@link #getFirst getFirst()}</td>   *    <td>{@link Deque#getFirst getFirst()}</td>
61   *    <td>{@link #peekFirst peekFirst()}</td>   *    <td>{@link Deque#peekFirst peekFirst()}</td>
62   *    <td>{@link #getLast getLast()}</td>   *    <td>{@link Deque#getLast getLast()}</td>
63   *    <td>{@link #peekLast peekLast()}</td>   *    <td>{@link Deque#peekLast peekLast()}</td>
64   *  </tr>   *  </tr>
65   * </table>   * </table>
66   *   *
67   * <p>This interface extends the {@link Queue} interface.  When a deque is   * <p>This interface extends the {@link Queue} interface.  When a deque is
68   * used as a queue, FIFO (First-In-First-Out) behavior results.  Elements are   * used as a queue, FIFO (First-In-First-Out) behavior results.  Elements are
69   * added at the end of the deque and removed from the beginning.  The methods   * added at the end of the deque and removed from the beginning.  The methods
70   * inherited from the <tt>Queue</tt> interface are precisely equivalent to   * inherited from the {@code Queue} interface are precisely equivalent to
71   * <tt>Deque</tt> methods as indicated in the following table:   * {@code Deque} methods as indicated in the following table:
72   *   *
  * <p>  
73   * <table BORDER CELLPADDING=3 CELLSPACING=1>   * <table BORDER CELLPADDING=3 CELLSPACING=1>
74     * <caption>Comparison of Queue and Deque methods</caption>
75   *  <tr>   *  <tr>
76   *    <td ALIGN=CENTER> <b><tt>Queue</tt> Method</b></td>   *    <td ALIGN=CENTER> <b>{@code Queue} Method</b></td>
77   *    <td ALIGN=CENTER> <b>Equivalent <tt>Deque</tt> Method</b></td>   *    <td ALIGN=CENTER> <b>Equivalent {@code Deque} Method</b></td>
78   *  </tr>   *  </tr>
79   *  <tr>   *  <tr>
80   *    <td>{@link java.util.Queue#add add(e)}</td>   *    <td>{@link java.util.Queue#add add(e)}</td>
# Line 107  Line 106 
106   * interface should be used in preference to the legacy {@link Stack} class.   * interface should be used in preference to the legacy {@link Stack} class.
107   * When a deque is used as a stack, elements are pushed and popped from the   * When a deque is used as a stack, elements are pushed and popped from the
108   * beginning of the deque.  Stack methods are precisely equivalent to   * beginning of the deque.  Stack methods are precisely equivalent to
109   * <tt>Deque</tt> methods as indicated in the table below:   * {@code Deque} methods as indicated in the table below:
110   *   *
  * <p>  
111   * <table BORDER CELLPADDING=3 CELLSPACING=1>   * <table BORDER CELLPADDING=3 CELLSPACING=1>
112     * <caption>Comparison of Stack and Deque methods</caption>
113   *  <tr>   *  <tr>
114   *    <td ALIGN=CENTER> <b>Stack Method</b></td>   *    <td ALIGN=CENTER> <b>Stack Method</b></td>
115   *    <td ALIGN=CENTER> <b>Equivalent <tt>Deque</tt> Method</b></td>   *    <td ALIGN=CENTER> <b>Equivalent {@code Deque} Method</b></td>
116   *  </tr>   *  </tr>
117   *  <tr>   *  <tr>
118   *    <td>{@link #push push(e)}</td>   *    <td>{@link #push push(e)}</td>
# Line 140  Line 139 
139   * <p>Unlike the {@link List} interface, this interface does not   * <p>Unlike the {@link List} interface, this interface does not
140   * provide support for indexed access to elements.   * provide support for indexed access to elements.
141   *   *
142   * <p>While <tt>Deque</tt> implementations are not strictly required   * <p>While {@code Deque} implementations are not strictly required
143   * to prohibit the insertion of null elements, they are strongly   * to prohibit the insertion of null elements, they are strongly
144   * encouraged to do so.  Users of any <tt>Deque</tt> implementations   * encouraged to do so.  Users of any {@code Deque} implementations
145   * that do allow null elements are strongly encouraged <i>not</i> to   * that do allow null elements are strongly encouraged <i>not</i> to
146   * take advantage of the ability to insert nulls.  This is so because   * take advantage of the ability to insert nulls.  This is so because
147   * <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
148   * to indicated that the deque is empty.   * to indicated that the deque is empty.
149   *   *
150   * <p><tt>Deque</tt> implementations generally do not define   * <p>{@code Deque} implementations generally do not define
151   * element-based versions of the <tt>equals</tt> and <tt>hashCode</tt>   * element-based versions of the {@code equals} and {@code hashCode}
152   * methods, but instead inherit the identity-based versions from class   * methods, but instead inherit the identity-based versions from class
153   * <tt>Object</tt>.   * {@code Object}.
154   *   *
155   * <p>This interface is a member of the <a   * <p>This interface is a member of the <a
156   * href="{@docRoot}/../guide/collections/index.html"> Java Collections   * href="{@docRoot}/../technotes/guides/collections/index.html"> Java Collections
157   * Framework</a>.   * Framework</a>.
158   *   *
159   * @author Doug Lea   * @author Doug Lea
160   * @author Josh Bloch   * @author Josh Bloch
161   * @since  1.6   * @since  1.6
162   * @param <E> the type of elements held in this collection   * @param <E> the type of elements held in this deque
163   */   */
   
164  public interface Deque<E> extends Queue<E> {  public interface Deque<E> extends Queue<E> {
165      /**      /**
166       * Inserts the specified element at the front of this deque if it is       * Inserts the specified element at the front of this deque if it is
167       * possible to do so immediately without violating capacity restrictions.       * possible to do so immediately without violating capacity restrictions,
168       * When using a capacity-restricted deque, it is generally preferable to       * throwing an {@code IllegalStateException} if no space is currently
169       * use method {@link #offerFirst}.       * available.  When using a capacity-restricted deque, it is generally
170         * preferable to use method {@link #offerFirst}.
171       *       *
172       * @param e the element to add       * @param e the element to add
173       * @throws IllegalStateException if the element cannot be added at this       * @throws IllegalStateException if the element cannot be added at this
# Line 184  Line 183 
183    
184      /**      /**
185       * Inserts the specified element at the end of this deque if it is       * Inserts the specified element at the end of this deque if it is
186       * possible to do so immediately without violating capacity restrictions.       * possible to do so immediately without violating capacity restrictions,
187       * When using a capacity-restricted deque, it is generally preferable to       * throwing an {@code IllegalStateException} if no space is currently
188       * use method {@link #offerLast}.       * available.  When using a capacity-restricted deque, it is generally
189         * preferable to use method {@link #offerLast}.
190       *       *
191       * <p>This method is equivalent to {@link #add}.       * <p>This method is equivalent to {@link #add}.
192       *       *
# Line 209  Line 209 
209       * which can fail to insert an element only by throwing an exception.       * which can fail to insert an element only by throwing an exception.
210       *       *
211       * @param e the element to add       * @param e the element to add
212       * @return <tt>true</tt> if the element was added to this deque, else       * @return {@code true} if the element was added to this deque, else
213       *         <tt>false</tt>       *         {@code false}
214       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
215       *         prevents it from being added to this deque       *         prevents it from being added to this deque
216       * @throws NullPointerException if the specified element is null and this       * @throws NullPointerException if the specified element is null and this
# Line 227  Line 227 
227       * which can fail to insert an element only by throwing an exception.       * which can fail to insert an element only by throwing an exception.
228       *       *
229       * @param e the element to add       * @param e the element to add
230       * @return <tt>true</tt> if the element was added to this deque, else       * @return {@code true} if the element was added to this deque, else
231       *         <tt>false</tt>       *         {@code false}
232       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
233       *         prevents it from being added to this deque       *         prevents it from being added to this deque
234       * @throws NullPointerException if the specified element is null and this       * @throws NullPointerException if the specified element is null and this
# Line 260  Line 260 
260    
261      /**      /**
262       * Retrieves and removes the first element of this deque,       * Retrieves and removes the first element of this deque,
263       * or returns <tt>null</tt> if this deque is empty.       * or returns {@code null} if this deque is empty.
264       *       *
265       * @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
266       */       */
267      E pollFirst();      E pollFirst();
268    
269      /**      /**
270       * Retrieves and removes the last element of this deque,       * Retrieves and removes the last element of this deque,
271       * or returns <tt>null</tt> if this deque is empty.       * or returns {@code null} if this deque is empty.
272       *       *
273       * @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
274       */       */
275      E pollLast();      E pollLast();
276    
# Line 297  Line 297 
297    
298      /**      /**
299       * Retrieves, but does not remove, the first element of this deque,       * Retrieves, but does not remove, the first element of this deque,
300       * or returns <tt>null</tt> if this deque is empty.       * or returns {@code null} if this deque is empty.
301       *       *
302       * @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
303       */       */
304      E peekFirst();      E peekFirst();
305    
306      /**      /**
307       * Retrieves, but does not remove, the last element of this deque,       * Retrieves, but does not remove, the last element of this deque,
308       * or returns <tt>null</tt> if this deque is empty.       * or returns {@code null} if this deque is empty.
309       *       *
310       * @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
311       */       */
312      E peekLast();      E peekLast();
313    
314      /**      /**
315       * Removes the first occurrence of the specified element from this deque.       * Removes the first occurrence of the specified element from this deque.
316       * If the deque does not contain the element, it is unchanged.       * If the deque does not contain the element, it is unchanged.
317       * More formally, removes the first element <tt>e</tt> such that       * More formally, removes the first element {@code e} such that
318       * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>       * {@code Objects.equals(o, e)} (if such an element exists).
319       * (if such an element exists).       * Returns {@code true} if this deque contained the specified element
      * Returns <tt>true</tt> if this deque contained the specified element  
320       * (or equivalently, if this deque changed as a result of the call).       * (or equivalently, if this deque changed as a result of the call).
321       *       *
322       * @param o element to be removed from this deque, if present       * @param o element to be removed from this deque, if present
323       * @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
324       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
325       *         is incompatible with this deque (optional)       *         is incompatible with this deque
326       * @throws NullPointerException if the specified element is null and this       *         (<a href="../Collection.html#optional-restrictions">optional</a>)
327       *         deque does not permit null elements (optional)       * @throws NullPointerException if the specified element is null
328         *         (<a href="../Collection.html#optional-restrictions">optional</a>)
329       */       */
330      boolean removeFirstOccurrence(Object o);      boolean removeFirstOccurrence(Object o);
331    
332      /**      /**
333       * Removes the last occurrence of the specified element from this deque.       * Removes the last occurrence of the specified element from this deque.
334       * If the deque does not contain the element, it is unchanged.       * If the deque does not contain the element, it is unchanged.
335       * More formally, removes the last element <tt>e</tt> such that       * More formally, removes the last element {@code e} such that
336       * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>       * {@code Objects.equals(o, e)} (if such an element exists).
337       * (if such an element exists).       * Returns {@code true} if this deque contained the specified element
      * Returns <tt>true</tt> if this deque contained the specified element  
338       * (or equivalently, if this deque changed as a result of the call).       * (or equivalently, if this deque changed as a result of the call).
339       *       *
340       * @param o element to be removed from this deque, if present       * @param o element to be removed from this deque, if present
341       * @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
342       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
343       *         is incompatible with this deque (optional)       *         is incompatible with this deque
344       * @throws NullPointerException if the specified element is null and this       *         (<a href="../Collection.html#optional-restrictions">optional</a>)
345       *         deque does not permit null elements (optional)       * @throws NullPointerException if the specified element is null
346         *         (<a href="../Collection.html#optional-restrictions">optional</a>)
347       */       */
348      boolean removeLastOccurrence(Object o);      boolean removeLastOccurrence(Object o);
349    
# Line 353  Line 353 
353       * Inserts the specified element into the queue represented by this deque       * Inserts the specified element into the queue represented by this deque
354       * (in other words, at the tail of this deque) if it is possible to do so       * (in other words, at the tail of this deque) if it is possible to do so
355       * immediately without violating capacity restrictions, returning       * immediately without violating capacity restrictions, returning
356       * <tt>true</tt> upon success and throwing an       * {@code true} upon success and throwing an
357       * <tt>IllegalStateException</tt> if no space is currently available.       * {@code IllegalStateException} if no space is currently available.
358       * When using a capacity-restricted deque, it is generally preferable to       * When using a capacity-restricted deque, it is generally preferable to
359       * use {@link #offer(Object) offer}.       * use {@link #offer(Object) offer}.
360       *       *
361       * <p>This method is equivalent to {@link #addLast}.       * <p>This method is equivalent to {@link #addLast}.
362       *       *
363       * @param e the element to add       * @param e the element to add
364       * @return <tt>true</tt> (as specified by {@link Collection#add})       * @return {@code true} (as specified by {@link Collection#add})
365       * @throws IllegalStateException if the element cannot be added at this       * @throws IllegalStateException if the element cannot be added at this
366       *         time due to capacity restrictions       *         time due to capacity restrictions
367       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
# Line 377  Line 377 
377       * Inserts the specified element into the queue represented by this deque       * Inserts the specified element into the queue represented by this deque
378       * (in other words, at the tail of this deque) if it is possible to do so       * (in other words, at the tail of this deque) if it is possible to do so
379       * immediately without violating capacity restrictions, returning       * immediately without violating capacity restrictions, returning
380       * <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
381       * available.  When using a capacity-restricted deque, this method is       * available.  When using a capacity-restricted deque, this method is
382       * generally preferable to the {@link #add} method, which can fail to       * generally preferable to the {@link #add} method, which can fail to
383       * insert an element only by throwing an exception.       * insert an element only by throwing an exception.
# Line 385  Line 385 
385       * <p>This method is equivalent to {@link #offerLast}.       * <p>This method is equivalent to {@link #offerLast}.
386       *       *
387       * @param e the element to add       * @param e the element to add
388       * @return <tt>true</tt> if the element was added to this deque, else       * @return {@code true} if the element was added to this deque, else
389       *         <tt>false</tt>       *         {@code false}
390       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
391       *         prevents it from being added to this deque       *         prevents it from being added to this deque
392       * @throws NullPointerException if the specified element is null and this       * @throws NullPointerException if the specified element is null and this
# Line 412  Line 412 
412      /**      /**
413       * Retrieves and removes the head of the queue represented by this deque       * Retrieves and removes the head of the queue represented by this deque
414       * (in other words, the first element of this deque), or returns       * (in other words, the first element of this deque), or returns
415       * <tt>null</tt> if this deque is empty.       * {@code null} if this deque is empty.
416       *       *
417       * <p>This method is equivalent to {@link #pollFirst()}.       * <p>This method is equivalent to {@link #pollFirst()}.
418       *       *
419       * @return the first element of this deque, or <tt>null</tt> if       * @return the first element of this deque, or {@code null} if
420       *         this deque is empty       *         this deque is empty
421       */       */
422      E poll();      E poll();
# Line 437  Line 437 
437      /**      /**
438       * Retrieves, but does not remove, the head of the queue represented by       * Retrieves, but does not remove, the head of the queue represented by
439       * this deque (in other words, the first element of this deque), or       * this deque (in other words, the first element of this deque), or
440       * returns <tt>null</tt> if this deque is empty.       * returns {@code null} if this deque is empty.
441       *       *
442       * <p>This method is equivalent to {@link #peekFirst()}.       * <p>This method is equivalent to {@link #peekFirst()}.
443       *       *
444       * @return the head of the queue represented by this deque, or       * @return the head of the queue represented by this deque, or
445       *         <tt>null</tt> if this deque is empty       *         {@code null} if this deque is empty
446       */       */
447      E peek();      E peek();
448    
# Line 452  Line 452 
452      /**      /**
453       * Pushes an element onto the stack represented by this deque (in other       * Pushes an element onto the stack represented by this deque (in other
454       * words, at the head of this deque) if it is possible to do so       * words, at the head of this deque) if it is possible to do so
455       * immediately without violating capacity restrictions, returning       * immediately without violating capacity restrictions, throwing an
456       * <tt>true</tt> upon success and throwing an       * {@code IllegalStateException} if no space is currently available.
      * <tt>IllegalStateException</tt> if no space is currently available.  
457       *       *
458       * <p>This method is equivalent to {@link #addFirst}.       * <p>This method is equivalent to {@link #addFirst}.
459       *       *
# Line 488  Line 487 
487      /**      /**
488       * Removes the first occurrence of the specified element from this deque.       * Removes the first occurrence of the specified element from this deque.
489       * If the deque does not contain the element, it is unchanged.       * If the deque does not contain the element, it is unchanged.
490       * More formally, removes the first element <tt>e</tt> such that       * More formally, removes the first element {@code e} such that
491       * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>       * {@code Objects.equals(o, e)} (if such an element exists).
492       * (if such an element exists).       * Returns {@code true} if this deque contained the specified element
      * Returns <tt>true</tt> if this deque contained the specified element  
493       * (or equivalently, if this deque changed as a result of the call).       * (or equivalently, if this deque changed as a result of the call).
494       *       *
495       * <p>This method is equivalent to {@link #removeFirstOccurrence}.       * <p>This method is equivalent to {@link #removeFirstOccurrence(Object)}.
496       *       *
497       * @param o element to be removed from this deque, if present       * @param o element to be removed from this deque, if present
498       * @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
499       * @throws ClassCastException if the class of the specified element       * @throws ClassCastException if the class of the specified element
500       *         is incompatible with this deque (optional)       *         is incompatible with this deque
501       * @throws NullPointerException if the specified element is null and this       *         (<a href="../Collection.html#optional-restrictions">optional</a>)
502       *         deque does not permit null elements (optional)       * @throws NullPointerException if the specified element is null
503         *         (<a href="../Collection.html#optional-restrictions">optional</a>)
504       */       */
505      boolean remove(Object o);      boolean remove(Object o);
506    
507      /**      /**
508       * Returns <tt>true</tt> if this deque contains the specified element.       * Returns {@code true} if this deque contains the specified element.
509       * More formally, returns <tt>true</tt> if and only if this deque contains       * More formally, returns {@code true} if and only if this deque contains
510       * at least one element <tt>e</tt> such that       * at least one element {@code e} such that {@code Objects.equals(o, e)}.
      * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.  
511       *       *
512       * @param o element whose presence in this deque is to be tested       * @param o element whose presence in this deque is to be tested
513       * @return <tt>true</tt> if this deque contains the specified element       * @return {@code true} if this deque contains the specified element
514       * @throws ClassCastException if the type of the specified element       * @throws ClassCastException if the class of the specified element
515       *         is incompatible with this deque (optional)       *         is incompatible with this deque
516       * @throws NullPointerException if the specified element is null and this       *         (<a href="../Collection.html#optional-restrictions">optional</a>)
517       *         deque does not permit null elements (optional)       * @throws NullPointerException if the specified element is null
518         *         (<a href="../Collection.html#optional-restrictions">optional</a>)
519       */       */
520      boolean contains(Object o);      boolean contains(Object o);
521    

Legend:
Removed from v.1.17  
changed lines
  Added in v.1.30

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8