/* * @(#)AbstractSequentialList.java 1.33 04/02/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.util; /** * This class provides a skeletal implementation of the List * interface to minimize the effort required to implement this interface * backed by a "sequential access" data store (such as a linked list). For * random access data (such as an array), AbstractList should be used * in preference to this class.
* * This class is the opposite of the AbstractList class in the sense * that it implements the "random access" methods (get(int index), * set(int index, Object element), set(int index, Object * element), add(int index, Object element) and remove(int * index)) on top of the list's list iterator, instead of the other way * around.
* * To implement a list the programmer needs only to extend this class and * provide implementations for the listIterator and size * methods. For an unmodifiable list, the programmer need only implement the * list iterator's hasNext, next, hasPrevious, * previous and index methods.
* * For a modifiable list the programmer should additionally implement the list * iterator's set method. For a variable-size list the programmer * should additionally implement the list iterator's remove and * add methods.
* * The programmer should generally provide a void (no argument) and collection * constructor, as per the recommendation in the Collection interface * specification.
*
* This class is a member of the
*
* Java Collections Framework.
*
* @author Josh Bloch
* @author Neal Gafter
* @version 1.33, 02/19/04
* @see Collection
* @see List
* @see AbstractList
* @see AbstractCollection
* @since 1.2
*/
public abstract class AbstractSequentialList
*
* This implementation first gets a list iterator pointing to the indexed
* element (with listIterator(index)). Then, it gets the element
* using ListIterator.next and returns it.
* @param index index of element to return.
*
* @return the element at the specified position in this list.
* @throws IndexOutOfBoundsException if the specified index is out of
* range (index < 0 || index >= size()).
*/
public E get(int index) {
ListIterator
*
* This implementation first gets a list iterator pointing to the
* indexed element (with listIterator(index)). Then, it gets
* the current element using ListIterator.next and replaces it
* with ListIterator.set.
*
* Note that this implementation will throw an
* UnsupportedOperationException if list iterator does not implement
* the set operation.
*
* @param index index of element to replace.
* @param element element to be stored at the specified position.
* @return the element previously at the specified position.
* @throws UnsupportedOperationException set is not supported
* by this list.
* @throws NullPointerException this list does not permit null
* elements and one of the elements of
*
* This implementation first gets a list iterator pointing to the
* indexed element (with listIterator(index)). Then, it inserts
* the specified element with ListIterator.add.
*
* Note that this implementation will throw an
* UnsupportedOperationException if list iterator does not
* implement the add operation.
*
* @param index index at which the specified element is to be inserted.
* @param element element to be inserted.
* @throws UnsupportedOperationException if the add operation is
* not supported by this list.
* @throws NullPointerException this list does not permit null
* elements and one of the elements of
*
* This implementation first gets a list iterator pointing to the
* indexed element (with listIterator(index)). Then, it removes
* the element with ListIterator.remove.
*
* Note that this implementation will throw an
* UnsupportedOperationException if list iterator does not
* implement the remove operation.
*
* @param index index of the element to be removed from the List.
* @return the element that was removed from the list.
* @throws UnsupportedOperationException if the remove operation
* is not supported by this list.
* @throws IndexOutOfBoundsException if the specified index is out of
* range (index < 0 || index >= size()).
*/
public E remove(int index) {
ListIterator
*
* This implementation gets an iterator over the specified collection and
* a list iterator over this list pointing to the indexed element (with
* listIterator(index)). Then, it iterates over the specified
* collection, inserting the elements obtained from the iterator into this
* list, one at a time, using ListIterator.add followed by
* ListIterator.next (to skip over the added element).
*
* Note that this implementation will throw an
* UnsupportedOperationException if the list iterator returned by
* the listIterator method does not implement the add
* operation.
*
* @return true if this list changed as a result of the call.
* @param index index at which to insert first element from the specified
* collection.
* @param c elements to be inserted into this list.
* @throws UnsupportedOperationException if the addAll operation
* is not supported by this list.
* @throws NullPointerException this list does not permit null
* elements and one of the elements of the specified collection
* is null.
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException if the specified index is out of
* range (index < 0 || index > size()).
* @throws NullPointerException if the specified collection is null.
*/
public boolean addAll(int index, Collection extends E> c) {
boolean modified = false;
ListIterator
*
* This implementation merely returns a list iterator over the list.
*
* @return an iterator over the elements in this list (in proper sequence).
*/
public Iteratorc
is null.
* @throws ClassCastException class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException index out of range
* (index < 0 || index >= size()).
* @throws IllegalArgumentException fromIndex > toIndex.
*/
public E set(int index, E element) {
ListIteratorc
is
* null.
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException if the specified index is out of
* range (index < 0 || index > size()).
*/
public void add(int index, E element) {
ListIteratornext
method)
* @return a list iterator over the elements in this list (in proper
* sequence).
*/
public abstract ListIterator