ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/LinkedList.java
(Generate patch)

Comparing jsr166/src/main/java/util/LinkedList.java (file contents):
Revision 1.26 by jsr166, Mon May 2 08:35:49 2005 UTC vs.
Revision 1.27 by jsr166, Sat May 14 02:19:00 2005 UTC

# Line 89 | Line 89 | public class LinkedList<E>
89       * collection, in the order they are returned by the collection's
90       * iterator.
91       *
92 <     * @param  c the collection whose elements are to be placed into this list.
93 <     * @throws NullPointerException if the specified collection is null.
92 >     * @param  c the collection whose elements are to be placed into this list
93 >     * @throws NullPointerException if the specified collection is null
94       */
95       public LinkedList(Collection<? extends E> c) {
96           this();
# Line 100 | Line 100 | public class LinkedList<E>
100      /**
101       * Returns the first element in this list.
102       *
103 <     * @return the first element in this list.
104 <     * @throws    NoSuchElementException if this list is empty.
103 >     * @return the first element in this list
104 >     * @throws NoSuchElementException if this list is empty
105       */
106      public E getFirst() {
107          if (size==0)
# Line 113 | Line 113 | public class LinkedList<E>
113      /**
114       * Returns the last element in this list.
115       *
116 <     * @return the last element in this list.
117 <     * @throws    NoSuchElementException if this list is empty.
116 >     * @return the last element in this list
117 >     * @throws NoSuchElementException if this list is empty
118       */
119      public E getLast()  {
120          if (size==0)
# Line 126 | Line 126 | public class LinkedList<E>
126      /**
127       * Removes and returns the first element from this list.
128       *
129 <     * @return the first element from this list.
130 <     * @throws    NoSuchElementException if this list is empty.
129 >     * @return the first element from this list
130 >     * @throws NoSuchElementException if this list is empty
131       */
132      public E removeFirst() {
133          return remove(header.next);
# Line 136 | Line 136 | public class LinkedList<E>
136      /**
137       * Removes and returns the last element from this list.
138       *
139 <     * @return the last element from this list.
140 <     * @throws    NoSuchElementException if this list is empty.
139 >     * @return the last element from this list
140 >     * @throws NoSuchElementException if this list is empty
141       */
142      public E removeLast() {
143          return remove(header.previous);
# Line 146 | Line 146 | public class LinkedList<E>
146      /**
147       * Inserts the given element at the beginning of this list.
148       *
149 <     * @param e the element to be inserted at the beginning of this list.
149 >     * @param e the element to be inserted at the beginning of this list
150       */
151      public void addFirst(E e) {
152          addBefore(e, header.next);
# Line 156 | Line 156 | public class LinkedList<E>
156       * Appends the given element to the end of this list.  (Identical in
157       * function to the <tt>add</tt> method; included only for consistency.)
158       *
159 <     * @param e the element to be inserted at the end of this list.
159 >     * @param e the element to be inserted at the end of this list
160       */
161      public void addLast(E e) {
162          addBefore(e, header);
# Line 168 | Line 168 | public class LinkedList<E>
168       * at least one element <tt>e</tt> such that <tt>(o==null ? e==null
169       * : o.equals(e))</tt>.
170       *
171 <     * @param o element whose presence in this list is to be tested.
172 <     * @return <tt>true</tt> if this list contains the specified element.
171 >     * @param o element whose presence in this list is to be tested
172 >     * @return <tt>true</tt> if this list contains the specified element
173       */
174      public boolean contains(Object o) {
175          return indexOf(o) != -1;
# Line 178 | Line 178 | public class LinkedList<E>
178      /**
179       * Returns the number of elements in this list.
180       *
181 <     * @return the number of elements in this list.
181 >     * @return the number of elements in this list
182       */
183      public int size() {
184          return size;
# Line 187 | Line 187 | public class LinkedList<E>
187      /**
188       * Appends the specified element to the end of this list.
189       *
190 <     * @param e element to be appended to this list.
191 <     * @return <tt>true</tt> (as per the general contract of
192 <     * <tt>Collection.add</tt>).
190 >     * @param e element to be appended to this list
191 >     * @return <tt>true</tt> (as per the spec for {@link Collection#add})
192       */
193      public boolean add(E e) {
194          addBefore(e, header);
# Line 203 | Line 202 | public class LinkedList<E>
202       * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> (if such an
203       * element exists).
204       *
205 <     * @param o element to be removed from this list, if present.
206 <     * @return <tt>true</tt> if the list contained the specified element.
205 >     * @param o element to be removed from this list, if present
206 >     * @return <tt>true</tt> if the list contained the specified element
207       */
208      public boolean remove(Object o) {
209          if (o==null) {
# Line 233 | Line 232 | public class LinkedList<E>
232       * progress.  (This implies that the behavior of this call is undefined if
233       * the specified Collection is this list, and this list is nonempty.)
234       *
235 <     * @param c the elements to be inserted into this list.
236 <     * @return <tt>true</tt> if this list changed as a result of the call.
237 <     * @throws NullPointerException if the specified collection is null.
235 >     * @param c the elements to be inserted into this list
236 >     * @return <tt>true</tt> if this list changed as a result of the call
237 >     * @throws NullPointerException if the specified collection is null
238       */
239      public boolean addAll(Collection<? extends E> c) {
240          return addAll(size, c);
# Line 249 | Line 248 | public class LinkedList<E>
248       * in the list in the order that they are returned by the
249       * specified collection's iterator.
250       *
251 <     * @param index index at which to insert first element
252 <     *              from the specified collection.
253 <     * @param c elements to be inserted into this list.
254 <     * @return <tt>true</tt> if this list changed as a result of the call.
251 >     * @param index index at which to insert the first element
252 >     *              from the specified collection
253 >     * @param c elements to be inserted into this list
254 >     * @return <tt>true</tt> if this list changed as a result of the call
255       * @throws IndexOutOfBoundsException if the index is out of range
256 <     *         (<tt>index &lt; 0 || index &gt; size()</tt>).
257 <     * @throws NullPointerException if the specified collection is null.
256 >     *         (<tt>index &lt; 0 || index &gt; size()</tt>)
257 >     * @throws NullPointerException if the specified collection is null
258       */
259      public boolean addAll(int index, Collection<? extends E> c) {
260          if (index < 0 || index > size)
# Line 302 | Line 301 | public class LinkedList<E>
301      /**
302       * Returns the element at the specified position in this list.
303       *
304 <     * @param index index of element to return.
305 <     * @return the element at the specified position in this list.
307 <     *
304 >     * @param index index of element to return
305 >     * @return the element at the specified position in this list
306       * @throws IndexOutOfBoundsException if the index is out of range
307 <     *         (<tt>index &lt; 0 || index &gt; size()</tt>).
307 >     *         (<tt>index &lt; 0 || index &gt; size()</tt>)
308       */
309      public E get(int index) {
310          return entry(index).element;
# Line 316 | Line 314 | public class LinkedList<E>
314       * Replaces the element at the specified position in this list with the
315       * specified element.
316       *
317 <     * @param index index of element to replace.
318 <     * @param element element to be stored at the specified position.
319 <     * @return the element previously at the specified position.
317 >     * @param index index of element to replace
318 >     * @param element element to be stored at the specified position
319 >     * @return the element previously at the specified position
320       * @throws IndexOutOfBoundsException if the index is out of range
321 <     *         (<tt>index &lt; 0 || index &gt; size()</tt>).
321 >     *         (<tt>index &lt; 0 || index &gt; size()</tt>)
322       */
323      public E set(int index, E element) {
324          Entry<E> e = entry(index);
# Line 334 | Line 332 | public class LinkedList<E>
332       * Shifts the element currently at that position (if any) and any
333       * subsequent elements to the right (adds one to their indices).
334       *
335 <     * @param index index at which the specified element is to be inserted.
336 <     * @param element element to be inserted.
335 >     * @param index index at which the specified element is to be inserted
336 >     * @param element element to be inserted
337       *
338       * @throws IndexOutOfBoundsException if the index is out of range
339 <     *         (<tt>index &lt; 0 || index &gt; size()</tt>).
339 >     *         (<tt>index &lt; 0 || index &gt; size()</tt>)
340       */
341      public void add(int index, E element) {
342          addBefore(element, (index==size ? header : entry(index)));
# Line 349 | Line 347 | public class LinkedList<E>
347       * subsequent elements to the left (subtracts one from their indices).
348       * Returns the element that was removed from the list.
349       *
350 <     * @param index the index of the element to removed.
351 <     * @return the element previously at the specified position.
350 >     * @param index the index of the element to be removed
351 >     * @return the element previously at the specified position
352       *
353       * @throws IndexOutOfBoundsException if the index is out of range
354 <     *         (<tt>index &lt; 0 || index &gt; size()</tt>).
354 >     *         (<tt>index &lt; 0 || index &gt; size()</tt>)
355       */
356      public E remove(int index) {
357          return remove(entry(index));
# Line 387 | Line 385 | public class LinkedList<E>
385       * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, or -1 if
386       * there is no such index.
387       *
388 <     * @param o element to search for.
388 >     * @param o element to search for
389       * @return the index in this list of the first occurrence of the
390 <     *         specified element, or -1 if the list does not contain this
391 <     *         element.
390 >     *         specified element, or -1 if the list does not contain this
391 >     *         element
392       */
393      public int indexOf(Object o) {
394          int index = 0;
# Line 417 | Line 415 | public class LinkedList<E>
415       * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, or -1 if
416       * there is no such index.
417       *
418 <     * @param o element to search for.
418 >     * @param o element to search for
419       * @return the index in this list of the last occurrence of the
420 <     *         specified element, or -1 if the list does not contain this
421 <     *         element.
420 >     *         specified element, or -1 if the list does not contain this
421 >     *         element
422       */
423      public int lastIndexOf(Object o) {
424          int index = size;
# Line 444 | Line 442 | public class LinkedList<E>
442  
443      /**
444       * Retrieves, but does not remove, the head (first element) of this list.
445 <     * @return the head of this list, or <tt>null</tt> if this list is empty.
445 >     * @return the head of this list, or <tt>null</tt> if this list is empty
446       * @since 1.5
447       */
448      public E peek() {
# Line 455 | Line 453 | public class LinkedList<E>
453  
454      /**
455       * Retrieves, but does not remove, the head (first element) of this list.
456 <     * @return the head of this list.
457 <     * @throws NoSuchElementException if this list is empty.
456 >     * @return the head of this list
457 >     * @throws NoSuchElementException if this list is empty
458       * @since 1.5
459       */
460      public E element() {
# Line 464 | Line 462 | public class LinkedList<E>
462      }
463  
464      /**
465 <     * Retrieves and removes the head (first element) of this list.
466 <     * @return the head of this list, or <tt>null</tt> if this list is empty.
465 >     * Retrieves and removes the head (first element) of this list
466 >     * @return the head of this list, or <tt>null</tt> if this list is empty
467       * @since 1.5
468       */
469      public E poll() {
# Line 476 | Line 474 | public class LinkedList<E>
474  
475      /**
476       * Retrieves and removes the head (first element) of this list.
477 <     * @return the head of this list.
478 <     * @throws NoSuchElementException if this list is empty.
477 >     *
478 >     * @return the head of this list
479 >     * @throws NoSuchElementException if this list is empty
480       * @since 1.5
481       */
482      public E remove() {
# Line 487 | Line 486 | public class LinkedList<E>
486      /**
487       * Adds the specified element as the tail (last element) of this list.
488       *
489 <     * @param e the element to add.
490 <     * @return <tt>true</tt> (as per the general contract of
492 <     * <tt>Queue.offer</tt>)
489 >     * @param e the element to add
490 >     * @return <tt>true</tt> (as per the spec for {@link Queue#offer})
491       * @since 1.5
492       */
493      public boolean offer(E e) {
# Line 523 | Line 521 | public class LinkedList<E>
521  
522      /**
523       * Retrieves, but does not remove, the first element of this list,
524 <     * returning <tt>null</tt> if this list is empty.
524 >     * or returns <tt>null</tt> if this list is empty.
525       *
526 <     * @return the first element of this list, or <tt>null</tt> if
527 <     *     this list is empty
526 >     * @return the first element of this list, or <tt>null</tt>
527 >     *         if this list is empty.
528       * @since 1.6
529       */
530      public E peekFirst() {
# Line 537 | Line 535 | public class LinkedList<E>
535  
536      /**
537       * Retrieves, but does not remove, the last element of this list,
538 <     * returning <tt>null</tt> if this list is empty.
538 >     * or returns <tt>null</tt> if this list is empty.
539       *
540 <     * @return the last element of this list, or <tt>null</tt> if this list
541 <     *     is empty
540 >     * @return the last element of this list, or <tt>null</tt>
541 >     *         if this list is empty.
542       * @since 1.6
543       */
544      public E peekLast() {
# Line 597 | Line 595 | public class LinkedList<E>
595       * <p>This method is equivalent to {@link #removeFirst()}.
596       *
597       * @return the element at the front of this list (which is the top
598 <     *     of the stack represented by this list)
599 <     * @throws NoSuchElementException if this list is empty.
598 >     *         of the stack represented by this list)
599 >     * @throws NoSuchElementException if this list is empty
600       * @since 1.6
601       */
602      public E pop() {
# Line 660 | Line 658 | public class LinkedList<E>
658       * than risking arbitrary, non-deterministic behavior at an undetermined
659       * time in the future.
660       *
661 <     * @param index index of first element to be returned from the
662 <     *              list-iterator (by a call to <tt>next</tt>).
661 >     * @param index index of the first element to be returned from the
662 >     *              list-iterator (by a call to <tt>next</tt>).
663       * @return a ListIterator of the elements in this list (in proper
664 <     *         sequence), starting at the specified position in the list.
664 >     *         sequence), starting at the specified position in the list.
665       * @throws IndexOutOfBoundsException if the index is out of range
666       *         (<tt>index &lt; 0 || index &gt; size()</tt>).
667       * @see List#listIterator(int)
# Line 806 | Line 804 | public class LinkedList<E>
804       * Returns a shallow copy of this <tt>LinkedList</tt>. (The elements
805       * themselves are not cloned.)
806       *
807 <     * @return a shallow copy of this <tt>LinkedList</tt> instance.
807 >     * @return a shallow copy of this <tt>LinkedList</tt> instance
808       */
809      public Object clone() {
810          LinkedList<E> clone = null;
# Line 834 | Line 832 | public class LinkedList<E>
832       * in the correct order.
833       *
834       * @return an array containing all of the elements in this list
835 <     *         in the correct order.
835 >     *         in the correct order.
836       */
837      public Object[] toArray() {
838          Object[] result = new Object[size];
# Line 859 | Line 857 | public class LinkedList<E>
857       * does not contain any null elements.
858       *
859       * @param a the array into which the elements of the list are to
860 <     *          be stored, if it is big enough; otherwise, a new array of the
861 <     *          same runtime type is allocated for this purpose.
862 <     * @return an array containing the elements of the list.
860 >     *          be stored, if it is big enough; otherwise, a new array of the
861 >     *          same runtime type is allocated for this purpose.
862 >     * @return an array containing the elements of the list
863       * @throws ArrayStoreException if the runtime type of a is not a
864 <     *         supertype of the runtime type of every element in this list.
865 <     * @throws NullPointerException if the specified array is null.
864 >     *         supertype of the runtime type of every element in this list
865 >     * @throws NullPointerException if the specified array is null
866       */
867      public <T> T[] toArray(T[] a) {
868          if (a.length < size)
# Line 888 | Line 886 | public class LinkedList<E>
886       * is, serialize it).
887       *
888       * @serialData The size of the list (the number of elements it
889 <     *             contains) is emitted (int), followed by all of its
890 <     * elements (each an Object) in the proper order.
889 >     *             contains) is emitted (int), followed by all of its
890 >     *             elements (each an Object) in the proper order.
891       */
892      private void writeObject(java.io.ObjectOutputStream s)
893          throws java.io.IOException {

Diff Legend

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