Back to index...

	/*
	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.util;

	/**
	* This class provides a skeletal implementation of the <tt>List</tt>
	* 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), <tt>AbstractList</tt> should be used
	* in preference to this class.<p>
	*
	* This class is the opposite of the <tt>AbstractList</tt> class in the sense
	* that it implements the "random access" methods (<tt>get(int index)</tt>,
	* <tt>set(int index, E element)</tt>, <tt>add(int index, E element)</tt> and
	* <tt>remove(int index)</tt>) on top of the list's list iterator, instead of
	* the other way around.<p>
	*
	* To implement a list the programmer needs only to extend this class and
	* provide implementations for the <tt>listIterator</tt> and <tt>size</tt>
	* methods. For an unmodifiable list, the programmer need only implement the
	* list iterator's <tt>hasNext</tt>, <tt>next</tt>, <tt>hasPrevious</tt>,
	* <tt>previous</tt> and <tt>index</tt> methods.<p>
	*
	* For a modifiable list the programmer should additionally implement the list
	* iterator's <tt>set</tt> method. For a variable-size list the programmer
	* should additionally implement the list iterator's <tt>remove</tt> and
	* <tt>add</tt> methods.<p>
	*
	* The programmer should generally provide a void (no argument) and collection
	* constructor, as per the recommendation in the <tt>Collection</tt> interface
	* specification.<p>
	*
	* This class is a member of the
	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
	* Java Collections Framework</a>.
	*
	* @author Josh Bloch
	* @author Neal Gafter
	* @see Collection
	* @see List
	* @see AbstractList
	* @see AbstractCollection
	* @since 1.2
	*/

	public abstract class AbstractSequentialList<E> extends AbstractList<E> {
	/**
	* Sole constructor. (For invocation by subclass constructors, typically
	* implicit.)
	*/
	protected AbstractSequentialList() {
	}

	/**
	* Returns the element at the specified position in this list.
	*
	* <p>This implementation first gets a list iterator pointing to the
	* indexed element (with <tt>listIterator(index)</tt>). Then, it gets
	* the element using <tt>ListIterator.next</tt> and returns it.
	*
	* @throws IndexOutOfBoundsException {@inheritDoc}
	*/
	public E get(int index) {
	try {
	return listIterator(index).next();
	} catch (NoSuchElementException exc) {
	throw new IndexOutOfBoundsException("Index: "+index);
	}
	}

	/**
	* Replaces the element at the specified position in this list with the
	* specified element (optional operation).
	*
	* <p>This implementation first gets a list iterator pointing to the
	* indexed element (with <tt>listIterator(index)</tt>). Then, it gets
	* the current element using <tt>ListIterator.next</tt> and replaces it
	* with <tt>ListIterator.set</tt>.
	*
	* <p>Note that this implementation will throw an
	* <tt>UnsupportedOperationException</tt> if the list iterator does not
	* implement the <tt>set</tt> operation.
	*
	* @throws UnsupportedOperationException {@inheritDoc}
	* @throws ClassCastException {@inheritDoc}
	* @throws NullPointerException {@inheritDoc}
	* @throws IllegalArgumentException {@inheritDoc}
	* @throws IndexOutOfBoundsException {@inheritDoc}
	*/
	public E set(int index, E element) {
	try {
	ListIterator<E> e = listIterator(index);
	E oldVal = e.next();
	e.set(element);
	return oldVal;
	} catch (NoSuchElementException exc) {
	throw new IndexOutOfBoundsException("Index: "+index);
	}
	}

	/**
	* Inserts the specified element at the specified position in this list
	* (optional operation). Shifts the element currently at that position
	* (if any) and any subsequent elements to the right (adds one to their
	* indices).
	*
	* <p>This implementation first gets a list iterator pointing to the
	* indexed element (with <tt>listIterator(index)</tt>). Then, it
	* inserts the specified element with <tt>ListIterator.add</tt>.
	*
	* <p>Note that this implementation will throw an
	* <tt>UnsupportedOperationException</tt> if the list iterator does not
	* implement the <tt>add</tt> operation.
	*
	* @throws UnsupportedOperationException {@inheritDoc}
	* @throws ClassCastException {@inheritDoc}
	* @throws NullPointerException {@inheritDoc}
	* @throws IllegalArgumentException {@inheritDoc}
	* @throws IndexOutOfBoundsException {@inheritDoc}
	*/
	public void add(int index, E element) {
	try {
	listIterator(index).add(element);
	} catch (NoSuchElementException exc) {
	throw new IndexOutOfBoundsException("Index: "+index);
	}
	}

	/**
	* Removes the element at the specified position in this list (optional
	* operation). Shifts any subsequent elements to the left (subtracts one
	* from their indices). Returns the element that was removed from the
	* list.
	*
	* <p>This implementation first gets a list iterator pointing to the
	* indexed element (with <tt>listIterator(index)</tt>). Then, it removes
	* the element with <tt>ListIterator.remove</tt>.
	*
	* <p>Note that this implementation will throw an
	* <tt>UnsupportedOperationException</tt> if the list iterator does not
	* implement the <tt>remove</tt> operation.
	*
	* @throws UnsupportedOperationException {@inheritDoc}
	* @throws IndexOutOfBoundsException {@inheritDoc}
	*/
	public E remove(int index) {
	try {
	ListIterator<E> e = listIterator(index);
	E outCast = e.next();
	e.remove();
	return outCast;
	} catch (NoSuchElementException exc) {
	throw new IndexOutOfBoundsException("Index: "+index);
	}
	}


	// Bulk Operations

	/**
	* Inserts all of the elements in the specified collection into this
	* list at the specified position (optional operation). Shifts the
	* element currently at that position (if any) and any subsequent
	* elements to the right (increases their indices). The new elements
	* will appear in this list in the order that they are returned by the
	* specified collection's iterator. The behavior of this operation is
	* undefined if the specified collection is modified while the
	* operation is in progress. (Note that this will occur if the specified
	* collection is this list, and it's nonempty.)
	*
	* <p>This implementation gets an iterator over the specified collection and
	* a list iterator over this list pointing to the indexed element (with
	* <tt>listIterator(index)</tt>). Then, it iterates over the specified
	* collection, inserting the elements obtained from the iterator into this
	* list, one at a time, using <tt>ListIterator.add</tt> followed by
	* <tt>ListIterator.next</tt> (to skip over the added element).
	*
	* <p>Note that this implementation will throw an
	* <tt>UnsupportedOperationException</tt> if the list iterator returned by
	* the <tt>listIterator</tt> method does not implement the <tt>add</tt>
	* operation.
	*
	* @throws UnsupportedOperationException {@inheritDoc}
	* @throws ClassCastException {@inheritDoc}
	* @throws NullPointerException {@inheritDoc}
	* @throws IllegalArgumentException {@inheritDoc}
	* @throws IndexOutOfBoundsException {@inheritDoc}
	*/
	public boolean addAll(int index, Collection<? extends E> c) {
	try {
	boolean modified = false;
	ListIterator<E> e1 = listIterator(index);
	Iterator<? extends E> e2 = c.iterator();
	while (e2.hasNext()) {
	e1.add(e2.next());
	modified = true;
	}
	return modified;
	} catch (NoSuchElementException exc) {
	throw new IndexOutOfBoundsException("Index: "+index);
	}
	}


	// Iterators

	/**
	* Returns an iterator over the elements in this list (in proper
	* sequence).<p>
	*
	* This implementation merely returns a list iterator over the list.
	*
	* @return an iterator over the elements in this list (in proper sequence)
	*/
	public Iterator<E> iterator() {
	return listIterator();
	}

	/**
	* Returns a list iterator over the elements in this list (in proper
	* sequence).
	*
	* @param index index of first element to be returned from the list
	* iterator (by a call to the <code>next</code> method)
	* @return a list iterator over the elements in this list (in proper
	* sequence)
	* @throws IndexOutOfBoundsException {@inheritDoc}
	*/
	public abstract ListIterator<E> listIterator(int index);
	}

Back to index...