[ViewVC] Diff of: jsr166/jsr166/src/main/java/util/Deque.java

Comparing jsr166/src/main/java/util/Deque.java (file contents):
Revision 1.3 by dl, Tue Mar 22 01:29:00 2005 UTC vs.
Revision 1.17 by dl, Wed Sep 14 23:49:59 2005 UTC

#	Line 5 \| Line 5
5		*/
6
7		package java.util;
8	+	import java.util.*; // for javadoc (till 6280605 is fixed)
9
10		/**
11		* A linear collection that supports element insertion and removal at
#	Line 25 \| Line 26 \| package java.util;
26		* operations cannot fail.
27		*
28		* <p>The twelve methods described above are summarized in the
29	<	* following table:<p>
29	>	* following table:
30		*
31	+	* <p>
32		* <table BORDER CELLPADDING=3 CELLSPACING=1>
33		* <tr>
34		* <td></td>
#	Line 36 \| Line 38 \| package java.util;
38		* <tr>
39		* <td></td>
40		* <td ALIGN=CENTER><em>Throws exception</em></td>
41	<	* <td ALIGN=CENTER><em>Returns special value</em></td>
41	>	* <td ALIGN=CENTER><em>Special value</em></td>
42		* <td ALIGN=CENTER><em>Throws exception</em></td>
43	<	* <td ALIGN=CENTER><em>Returns special value</em></td>
43	>	* <td ALIGN=CENTER><em>Special value</em></td>
44		* </tr>
45		* <tr>
46		* <td><b>Insert</b></td>
#	Line 65 \| Line 67 \| package java.util;
67		*
68		* <p>This interface extends the {@link Queue} interface. When a deque is
69		* used as a queue, FIFO (First-In-First-Out) behavior results. Elements are
70	<	* added to the end of the deque and removed from the beginning. The methods
70	>	* added at the end of the deque and removed from the beginning. The methods
71		* inherited from the <tt>Queue</tt> interface are precisely equivalent to
72	<	* <tt>Deque</tt> methods as indicated in the following table:<p>
72	>	* <tt>Deque</tt> methods as indicated in the following table:
73		*
74	+	* <p>
75		* <table BORDER CELLPADDING=3 CELLSPACING=1>
76		* <tr>
77		* <td ALIGN=CENTER> <b><tt>Queue</tt> Method</b></td>
78		* <td ALIGN=CENTER> <b>Equivalent <tt>Deque</tt> Method</b></td>
79		* </tr>
80		* <tr>
78	–	* <tr>
79	–	* <td>{@link java.util.Queue#offer offer(e)}</td>
80	–	* <td>{@link #offerLast offerLast(e)}</td>
81	–	* </tr>
82	–	* <tr>
81		* <td>{@link java.util.Queue#add add(e)}</td>
82		* <td>{@link #addLast addLast(e)}</td>
83	<	* </tr>
84	<	* <tr>
85	<	* <td>{@link java.util.Queue#poll poll()}</td>
86	<	* <td>{@link #pollFirst pollFirst()}</td>
87	<	* </tr>
88	<	* <tr>
83	>	* </tr>
84	>	* <tr>
85	>	* <td>{@link java.util.Queue#offer offer(e)}</td>
86	>	* <td>{@link #offerLast offerLast(e)}</td>
87	>	* </tr>
88	>	* <tr>
89		* <td>{@link java.util.Queue#remove remove()}</td>
90		* <td>{@link #removeFirst removeFirst()}</td>
91	<	* </tr>
92	<	* <tr>
93	<	* <td>{@link java.util.Queue#peek peek()}</td>
94	<	* <td>{@link #peek peekFirst()}</td>
95	<	* </tr>
96	<	* <tr>
91	>	* </tr>
92	>	* <tr>
93	>	* <td>{@link java.util.Queue#poll poll()}</td>
94	>	* <td>{@link #pollFirst pollFirst()}</td>
95	>	* </tr>
96	>	* <tr>
97		* <td>{@link java.util.Queue#element element()}</td>
98		* <td>{@link #getFirst getFirst()}</td>
99	<	* </tr>
99	>	* </tr>
100	>	* <tr>
101	>	* <td>{@link java.util.Queue#peek peek()}</td>
102	>	* <td>{@link #peek peekFirst()}</td>
103	>	* </tr>
104		* </table>
105		*
106		* <p>Deques can also be used as LIFO (Last-In-First-Out) stacks. This
107		* interface should be used in preference to the legacy {@link Stack} class.
108		* When a deque is used as a stack, elements are pushed and popped from the
109		* beginning of the deque. Stack methods are precisely equivalent to
110	<	* <tt>Deque</tt> methods as indicated in the table below:<p>
110	>	* <tt>Deque</tt> methods as indicated in the table below:
111		*
112	+	* <p>
113		* <table BORDER CELLPADDING=3 CELLSPACING=1>
114		* <tr>
115		* <td ALIGN=CENTER> <b>Stack Method</b></td>
116		* <td ALIGN=CENTER> <b>Equivalent <tt>Deque</tt> Method</b></td>
117		* </tr>
118		* <tr>
116	–	* <tr>
119		* <td>{@link #push push(e)}</td>
120		* <td>{@link #addFirst addFirst(e)}</td>
121	<	* </tr>
122	<	* <tr>
121	>	* </tr>
122	>	* <tr>
123		* <td>{@link #pop pop()}</td>
124		* <td>{@link #removeFirst removeFirst()}</td>
125	<	* </tr>
126	<	* <tr>
125	>	* </tr>
126	>	* <tr>
127		* <td>{@link #peek peek()}</td>
128		* <td>{@link #peekFirst peekFirst()}</td>
129	<	* </tr>
129	>	* </tr>
130		* </table>
131		*
132		* <p>Note that the {@link #peek peek} method works equally well when
#	Line 133 \| Line 135 \| package java.util;
135		*
136		* <p>This interface provides two methods to remove interior
137		* elements, {@link #removeFirstOccurrence removeFirstOccurrence} and
138	<	* {@link #removeLastOccurrence removeLastOccurrence}. Unlike the
139	<	* {@link List} interface, this interface does not provide support for
140	<	* indexed access to elements.
138	>	* {@link #removeLastOccurrence removeLastOccurrence}.
139	>	*
140	>	* <p>Unlike the {@link List} interface, this interface does not
141	>	* provide support for indexed access to elements.
142		*
143		* <p>While <tt>Deque</tt> implementations are not strictly required
144		* to prohibit the insertion of null elements, they are strongly
#	Line 162 \| Line 165 \| package java.util;
165
166		public interface Deque<E> extends Queue<E> {
167		/**
168	+	* Inserts the specified element at the front of this deque if it is
169	+	* possible to do so immediately without violating capacity restrictions.
170	+	* When using a capacity-restricted deque, it is generally preferable to
171	+	* use method {@link #offerFirst}.
172	+	*
173	+	* @param e the element to add
174	+	* @throws IllegalStateException if the element cannot be added at this
175	+	* time due to capacity restrictions
176	+	* @throws ClassCastException if the class of the specified element
177	+	* prevents it from being added to this deque
178	+	* @throws NullPointerException if the specified element is null and this
179	+	* deque does not permit null elements
180	+	* @throws IllegalArgumentException if some property of the specified
181	+	* element prevents it from being added to this deque
182	+	*/
183	+	void addFirst(E e);
184	+
185	+	/**
186	+	* Inserts the specified element at the end of this deque if it is
187	+	* possible to do so immediately without violating capacity restrictions.
188	+	* When using a capacity-restricted deque, it is generally preferable to
189	+	* use method {@link #offerLast}.
190	+	*
191	+	* <p>This method is equivalent to {@link #add}.
192	+	*
193	+	* @param e the element to add
194	+	* @throws IllegalStateException if the element cannot be added at this
195	+	* time due to capacity restrictions
196	+	* @throws ClassCastException if the class of the specified element
197	+	* prevents it from being added to this deque
198	+	* @throws NullPointerException if the specified element is null and this
199	+	* deque does not permit null elements
200	+	* @throws IllegalArgumentException if some property of the specified
201	+	* element prevents it from being added to this deque
202	+	*/
203	+	void addLast(E e);
204	+
205	+	/**
206		* Inserts the specified element at the front of this deque unless it would
207		* violate capacity restrictions. When using a capacity-restricted deque,
208	<	* this method is generally preferable to method <tt>addFirst</tt>, which
209	<	* can fail to insert an element only by throwing an exception.
208	>	* this method is generally preferable to the {@link #addFirst} method,
209	>	* which can fail to insert an element only by throwing an exception.
210		*
211	<	* @param e the element to insert
212	<	* @return <tt>true</tt> if it was possible to insert the element,
213	<	* else <tt>false</tt>
211	>	* @param e the element to add
212	>	* @return <tt>true</tt> if the element was added to this deque, else
213	>	* <tt>false</tt>
214	>	* @throws ClassCastException if the class of the specified element
215	>	* prevents it from being added to this deque
216		* @throws NullPointerException if the specified element is null and this
217	<	* deque does not permit null elements
217	>	* deque does not permit null elements
218	>	* @throws IllegalArgumentException if some property of the specified
219	>	* element prevents it from being added to this deque
220		*/
221		boolean offerFirst(E e);
222
223		/**
224	<	* Inserts the specified element to the end of this deque unless it would
224	>	* Inserts the specified element at the end of this deque unless it would
225		* violate capacity restrictions. When using a capacity-restricted deque,
226	<	* this method is generally preferable to method <tt>addLast</tt> which
227	<	* can fail to insert an element only by throwing an exception.
226	>	* this method is generally preferable to the {@link #addLast} method,
227	>	* which can fail to insert an element only by throwing an exception.
228		*
229	<	* @param e the element to insert
230	<	* @return <tt>true</tt> if it was possible to insert the element,
231	<	* else <tt>false</tt>
229	>	* @param e the element to add
230	>	* @return <tt>true</tt> if the element was added to this deque, else
231	>	* <tt>false</tt>
232	>	* @throws ClassCastException if the class of the specified element
233	>	* prevents it from being added to this deque
234		* @throws NullPointerException if the specified element is null and this
235	<	* deque does not permit null elements
235	>	* deque does not permit null elements
236	>	* @throws IllegalArgumentException if some property of the specified
237	>	* element prevents it from being added to this deque
238		*/
239		boolean offerLast(E e);
240
241		/**
242	<	* Inserts the specified element at the front of this deque unless it
243	<	* would violate capacity restrictions.
242	>	* Retrieves and removes the first element of this deque. This method
243	>	* differs from {@link #pollFirst pollFirst} only in that it throws an
244	>	* exception if this deque is empty.
245		*
246	<	* @param e the element to insert
247	<	* @throws IllegalStateException if it was not possible to insert
198	<	* the element due to capacity restrictions
199	<	* @throws NullPointerException if the specified element is null and this
200	<	* deque does not permit null elements
246	>	* @return the head of this deque
247	>	* @throws NoSuchElementException if this deque is empty
248		*/
249	<	void addFirst(E e);
249	>	E removeFirst();
250
251		/**
252	<	* Inserts the specified element to the end of this deque unless it would
253	<	* violate capacity restrictions.
252	>	* Retrieves and removes the last element of this deque. This method
253	>	* differs from {@link #pollLast pollLast} only in that it throws an
254	>	* exception if this deque is empty.
255		*
256	<	* @param e the element to insert
257	<	* @throws IllegalStateException if it was not possible to insert
210	<	* the element due to capacity restrictions
211	<	* @throws NullPointerException if the specified element is null and this
212	<	* deque does not permit null elements
256	>	* @return the tail of this deque
257	>	* @throws NoSuchElementException if this deque is empty
258		*/
259	<	void addLast(E e);
259	>	E removeLast();
260
261		/**
262	<	* Retrieves and removes the first element of this deque, or
263	<	* <tt>null</tt> if this deque is empty.
262	>	* Retrieves and removes the first element of this deque,
263	>	* or returns <tt>null</tt> if this deque is empty.
264		*
265	<	* @return the first element of this deque, or <tt>null</tt> if
221	<	* this deque is empty
265	>	* @return the head of this deque, or <tt>null</tt> if this deque is empty
266		*/
267		E pollFirst();
268
269		/**
270	<	* Retrieves and removes the last element of this deque, or
271	<	* <tt>null</tt> if this deque is empty.
270	>	* Retrieves and removes the last element of this deque,
271	>	* or returns <tt>null</tt> if this deque is empty.
272		*
273	<	* @return the last element of this deque, or <tt>null</tt> if
230	<	* this deque is empty
273	>	* @return the tail of this deque, or <tt>null</tt> if this deque is empty
274		*/
275		E pollLast();
276
277		/**
278	<	* Removes and returns the first element of this deque. This method
279	<	* differs from the <tt>pollFirst</tt> method only in that it throws an
280	<	* exception if this deque is empty.
278	>	* Retrieves, but does not remove, the first element of this deque.
279	>	*
280	>	* This method differs from {@link #peekFirst peekFirst} only in that it
281	>	* throws an exception if this deque is empty.
282		*
283	<	* @return the first element of this deque
283	>	* @return the head of this deque
284		* @throws NoSuchElementException if this deque is empty
285		*/
286	<	E removeFirst();
286	>	E getFirst();
287
288		/**
289	<	* Retrieves and removes the last element of this deque. This method
290	<	* differs from the <tt>pollLast</tt> method only in that it throws an
291	<	* exception if this deque is empty.
289	>	* Retrieves, but does not remove, the last element of this deque.
290	>	* This method differs from {@link #peekLast peekLast} only in that it
291	>	* throws an exception if this deque is empty.
292		*
293	<	* @return the last element of this deque
293	>	* @return the tail of this deque
294		* @throws NoSuchElementException if this deque is empty
295		*/
296	<	E removeLast();
296	>	E getLast();
297
298		/**
299		* Retrieves, but does not remove, the first element of this deque,
300	<	* returning <tt>null</tt> if this deque is empty.
300	>	* or returns <tt>null</tt> if this deque is empty.
301		*
302	<	* @return the first element of this deque, or <tt>null</tt> if
259	<	* this deque is empty
302	>	* @return the head of this deque, or <tt>null</tt> if this deque is empty
303		*/
304		E peekFirst();
305
306		/**
307		* Retrieves, but does not remove, the last element of this deque,
308	<	* returning <tt>null</tt> if this deque is empty.
308	>	* or returns <tt>null</tt> if this deque is empty.
309		*
310	<	* @return the last element of this deque, or <tt>null</tt> if this deque
268	<	* is empty
310	>	* @return the tail of this deque, or <tt>null</tt> if this deque is empty
311		*/
312		E peekLast();
313
314		/**
315	<	* Retrieves, but does not remove, the first element of this
316	<	* deque. This method differs from the <tt>peekFirst</tt> method only
317	<	* in that it throws an exception if this deque is empty.
318	<	*
319	<	* @return the first element of this deque
320	<	* @throws NoSuchElementException if this deque is empty
321	<	*/
280	<	E getFirst();
281	<
282	<	/**
283	<	* Retrieves, but does not remove, the last element of this
284	<	* deque. This method differs from the <tt>peekLast</tt> method only
285	<	* in that it throws an exception if this deque is empty.
286	<	*
287	<	* @return the last element of this deque
288	<	* @throws NoSuchElementException if this deque is empty
289	<	*/
290	<	E getLast();
291	<
292	<	/**
293	<	* Removes the first occurrence of the specified element in this
294	<	* deque. If the deque does not contain the element, it is
295	<	* unchanged. More formally, removes the first element <tt>e</tt>
296	<	* such that <tt>(o==null ? e==null : o.equals(e))</tt> (if
297	<	* such an element exists).
315	>	* Removes the first occurrence of the specified element from this deque.
316	>	* If the deque does not contain the element, it is unchanged.
317	>	* More formally, removes the first element <tt>e</tt> such that
318	>	* <tt>(o==null ? e==null : o.equals(e))</tt>
319	>	* (if such an element exists).
320	>	* Returns <tt>true</tt> if this deque contained the specified element
321	>	* (or equivalently, if this deque changed as a result of the call).
322		*
323		* @param o element to be removed from this deque, if present
324	<	* @return <tt>true</tt> if the deque contained the specified element
325	<	* @throws NullPointerException if the specified element is <tt>null</tt>
324	>	* @return <tt>true</tt> if an element was removed as a result of this call
325	>	* @throws ClassCastException if the class of the specified element
326	>	* is incompatible with this deque (optional)
327	>	* @throws NullPointerException if the specified element is null and this
328	>	* deque does not permit null elements (optional)
329		*/
330		boolean removeFirstOccurrence(Object o);
331
332		/**
333	<	* Removes the last occurrence of the specified element in this
334	<	* deque. If the deque does not contain the element, it is
335	<	* unchanged. More formally, removes the last element <tt>e</tt>
336	<	* such that <tt>(o==null ? e==null : o.equals(e))</tt> (if
337	<	* such an element exists).
333	>	* Removes the last occurrence of the specified element from this deque.
334	>	* If the deque does not contain the element, it is unchanged.
335	>	* More formally, removes the last element <tt>e</tt> such that
336	>	* <tt>(o==null ? e==null : o.equals(e))</tt>
337	>	* (if such an element exists).
338	>	* Returns <tt>true</tt> if this deque contained the specified element
339	>	* (or equivalently, if this deque changed as a result of the call).
340		*
341		* @param o element to be removed from this deque, if present
342	<	* @return <tt>true</tt> if the deque contained the specified element
343	<	* @throws NullPointerException if the specified element is <tt>null</tt>
342	>	* @return <tt>true</tt> if an element was removed as a result of this call
343	>	* @throws ClassCastException if the class of the specified element
344	>	* is incompatible with this deque (optional)
345	>	* @throws NullPointerException if the specified element is null and this
346	>	* deque does not permit null elements (optional)
347		*/
348		boolean removeLastOccurrence(Object o);
349
318	–
350		// * Queue methods *
351
352		/**
353		* Inserts the specified element into the queue represented by this deque
354	<	* unless it would violate capacity restrictions. In other words, inserts
355	<	* the specified element to the end of this deque. When using a
356	<	* capacity-restricted deque, this method is generally preferable to the
357	<	* {@link #add} method, which can fail to insert an element only by
358	<	* throwing an exception.
359	<	*
329	<	* <p>This method is equivalent to {@link #offerLast}.
330	<	*
331	<	* @param e the element to insert
332	<	* @return <tt>true</tt> if it was possible to insert the element,
333	<	* else <tt>false</tt>
334	<	* @throws NullPointerException if the specified element is null and this
335	<	* deque does not permit null elements
336	<	*/
337	<	boolean offer(E e);
338	<
339	<	/**
340	<	* Inserts the specified element into the queue represented by this
341	<	* deque unless it would violate capacity restrictions. In other words,
342	<	* inserts the specified element as the last element of this deque.
354	>	* (in other words, at the tail of this deque) if it is possible to do so
355	>	* immediately without violating capacity restrictions, returning
356	>	* <tt>true</tt> upon success and throwing an
357	>	* <tt>IllegalStateException</tt> if no space is currently available.
358	>	* When using a capacity-restricted deque, it is generally preferable to
359	>	* use {@link #offer(Object) offer}.
360		*
361		* <p>This method is equivalent to {@link #addLast}.
362		*
363	<	* @param e the element to insert
364	<	* @return <tt>true</tt> (as per the spec for {@link Collection#add})
365	<	* @throws IllegalStateException if it was not possible to insert
366	<	* the element due to capacity restrictions
363	>	* @param e the element to add
364	>	* @return <tt>true</tt> (as specified by {@link Collection#add})
365	>	* @throws IllegalStateException if the element cannot be added at this
366	>	* time due to capacity restrictions
367	>	* @throws ClassCastException if the class of the specified element
368	>	* prevents it from being added to this deque
369		* @throws NullPointerException if the specified element is null and this
370	<	* deque does not permit null elements
370	>	* deque does not permit null elements
371	>	* @throws IllegalArgumentException if some property of the specified
372	>	* element prevents it from being added to this deque
373		*/
374		boolean add(E e);
375
376		/**
377	<	* Retrieves and removes the head of the queue represented by
378	<	* this deque, or <tt>null</tt> if this deque is empty. In other words,
379	<	* retrieves and removes the first element of this deque, or <tt>null</tt>
380	<	* if this deque is empty.
377	>	* 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
379	>	* immediately without violating capacity restrictions, returning
380	>	* <tt>true</tt> upon success and <tt>false</tt> if no space is currently
381	>	* available. When using a capacity-restricted deque, this method is
382	>	* generally preferable to the {@link #add} method, which can fail to
383	>	* insert an element only by throwing an exception.
384		*
385	<	* <p>This method is equivalent to {@link #pollFirst()}.
385	>	* <p>This method is equivalent to {@link #offerLast}.
386		*
387	<	* @return the first element of this deque, or <tt>null</tt> if
388	<	* this deque is empty
387	>	* @param e the element to add
388	>	* @return <tt>true</tt> if the element was added to this deque, else
389	>	* <tt>false</tt>
390	>	* @throws ClassCastException if the class of the specified element
391	>	* prevents it from being added to this deque
392	>	* @throws NullPointerException if the specified element is null and this
393	>	* deque does not permit null elements
394	>	* @throws IllegalArgumentException if some property of the specified
395	>	* element prevents it from being added to this deque
396		*/
397	<	E poll();
397	>	boolean offer(E e);
398
399		/**
400	<	* Retrieves and removes the head of the queue represented by this deque.
401	<	* This method differs from the <tt>poll</tt> method only in that it
402	<	* throws an exception if this deque is empty.
400	>	* Retrieves and removes the head of the queue represented by this deque
401	>	* (in other words, the first element of this deque).
402	>	* This method differs from {@link #poll poll} only in that it throws an
403	>	* exception if this deque is empty.
404		*
405		* <p>This method is equivalent to {@link #removeFirst()}.
406		*
#	Line 378 \| Line 410 \| public interface Deque<E> extends Queue<
410		E remove();
411
412		/**
413	<	* Retrieves, but does not remove, the head of the queue represented by
414	<	* this deque, returning <tt>null</tt> if this deque is empty.
413	>	* Retrieves and removes the head of the queue represented by this deque
414	>	* (in other words, the first element of this deque), or returns
415	>	* <tt>null</tt> if this deque is empty.
416		*
417	<	* <p>This method is equivalent to {@link #peekFirst()}.
417	>	* <p>This method is equivalent to {@link #pollFirst()}.
418		*
419	<	* @return the head of the queue represented by this deque, or
420	<	* <tt>null</tt> if this deque is empty
419	>	* @return the first element of this deque, or <tt>null</tt> if
420	>	* this deque is empty
421		*/
422	<	E peek();
422	>	E poll();
423
424		/**
425		* Retrieves, but does not remove, the head of the queue represented by
426	<	* this deque. This method differs from the <tt>peek</tt> method only in
427	<	* that it throws an exception if this deque is empty.
426	>	* this deque (in other words, the first element of this deque).
427	>	* This method differs from {@link #peek peek} only in that it throws an
428	>	* exception if this deque is empty.
429		*
430		* <p>This method is equivalent to {@link #getFirst()}.
431		*
#	Line 400 \| Line 434 \| public interface Deque<E> extends Queue<
434		*/
435		E element();
436
437	+	/**
438	+	* 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
440	+	* returns <tt>null</tt> if this deque is empty.
441	+	*
442	+	* <p>This method is equivalent to {@link #peekFirst()}.
443	+	*
444	+	* @return the head of the queue represented by this deque, or
445	+	* <tt>null</tt> if this deque is empty
446	+	*/
447	+	E peek();
448	+
449
450		// * Stack methods *
451
452		/**
453	<	* Pushes an element onto the stack represented by this deque. In other
454	<	* words, inserts the element at the front of this deque unless it would
455	<	* violate capacity restrictions.
453	>	* 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
455	>	* immediately without violating capacity restrictions, returning
456	>	* <tt>true</tt> upon success and throwing an
457	>	* <tt>IllegalStateException</tt> if no space is currently available.
458		*
459		* <p>This method is equivalent to {@link #addFirst}.
460		*
461		* @param e the element to push
462	<	* @throws IllegalStateException if it was not possible to insert
463	<	* the element due to capacity restrictions
462	>	* @throws IllegalStateException if the element cannot be added at this
463	>	* time due to capacity restrictions
464	>	* @throws ClassCastException if the class of the specified element
465	>	* prevents it from being added to this deque
466		* @throws NullPointerException if the specified element is null and this
467	<	* deque does not permit null elements
467	>	* deque does not permit null elements
468	>	* @throws IllegalArgumentException if some property of the specified
469	>	* element prevents it from being added to this deque
470		*/
471		void push(E e);
472
#	Line 425 \| Line 477 \| public interface Deque<E> extends Queue<
477		* <p>This method is equivalent to {@link #removeFirst()}.
478		*
479		* @return the element at the front of this deque (which is the top
480	<	* of the stack represented by this deque)
480	>	* of the stack represented by this deque)
481		* @throws NoSuchElementException if this deque is empty
482		*/
483		E pop();
484
485
486	<	// * Collection Method *
486	>	// * Collection methods *
487
488		/**
489	<	* Returns an iterator over the elements in this deque. The elements
490	<	* will be ordered from first (head) to last (tail).
489	>	* Removes the first occurrence of the specified element from this deque.
490	>	* If the deque does not contain the element, it is unchanged.
491	>	* More formally, removes the first element <tt>e</tt> such that
492	>	* <tt>(o==null ? e==null : o.equals(e))</tt>
493	>	* (if such an element exists).
494	>	* Returns <tt>true</tt> if this deque contained the specified element
495	>	* (or equivalently, if this deque changed as a result of the call).
496	>	*
497	>	* <p>This method is equivalent to {@link #removeFirstOccurrence}.
498		*
499	<	* @return an <tt>Iterator</tt> over the elements in this deque
499	>	* @param o element to be removed from this deque, if present
500	>	* @return <tt>true</tt> if an element was removed as a result of this call
501	>	* @throws ClassCastException if the class of the specified element
502	>	* is incompatible with this deque (optional)
503	>	* @throws NullPointerException if the specified element is null and this
504	>	* deque does not permit null elements (optional)
505	>	*/
506	>	boolean remove(Object o);
507	>
508	>	/**
509	>	* Returns <tt>true</tt> if this deque contains the specified element.
510	>	* More formally, returns <tt>true</tt> if and only if this deque contains
511	>	* at least one element <tt>e</tt> such that
512	>	* <tt>(o==null ? e==null : o.equals(e))</tt>.
513	>	*
514	>	* @param o element whose presence in this deque is to be tested
515	>	* @return <tt>true</tt> if this deque contains the specified element
516	>	* @throws ClassCastException if the type of the specified element
517	>	* is incompatible with this deque (optional)
518	>	* @throws NullPointerException if the specified element is null and this
519	>	* deque does not permit null elements (optional)
520	>	*/
521	>	boolean contains(Object o);
522	>
523	>	/**
524	>	* Returns the number of elements in this deque.
525	>	*
526	>	* @return the number of elements in this deque
527	>	*/
528	>	public int size();
529	>
530	>	/**
531	>	* Returns an iterator over the elements in this deque in proper sequence.
532	>	* The elements will be returned in order from first (head) to last (tail).
533	>	*
534	>	* @return an iterator over the elements in this deque in proper sequence
535		*/
536		Iterator<E> iterator();
537	+
538	+	/**
539	+	* Returns an iterator over the elements in this deque in reverse
540	+	* sequential order. The elements will be returned in order from
541	+	* last (tail) to first (head).
542	+	*
543	+	* @return an iterator over the elements in this deque in reverse
544	+	* sequence
545	+	*/
546	+	Iterator<E> descendingIterator();
547	+
548		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing jsr166/src/main/java/util/Deque.java (file contents): Revision 1.3 by dl, Tue Mar 22 01:29:00 2005 UTC vs. Revision 1.17 by dl, Wed Sep 14 23:49:59 2005 UTC

Diff Legend

Comparing jsr166/src/main/java/util/Deque.java (file contents):
Revision 1.3 by dl, Tue Mar 22 01:29:00 2005 UTC vs.
Revision 1.17 by dl, Wed Sep 14 23:49:59 2005 UTC