alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (AbstractSequentialList.java)

This example Java source code file (AbstractSequentialList.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

abstractlist, abstractsequentiallist, collection, index, indexoutofboundsexception, listiterator, nosuchelementexception

The AbstractSequentialList.java Java example source code

/*
 * 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
 * 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 should be used
 * in preference to this class.<p>
 *
 * This class is the opposite of the <tt>AbstractList class in the sense
 * that it implements the "random access" methods (<tt>get(int index),
 * <tt>set(int index, E element), add(int index, E element) and
 * <tt>remove(int index)) 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 and size
 * methods.  For an unmodifiable list, the programmer need only implement the
 * list iterator's <tt>hasNext, next, hasPrevious,
 * <tt>previous and index methods.

* * For a modifiable list the programmer should additionally implement the list * iterator's <tt>set method. For a variable-size list the programmer * should additionally implement the list iterator's <tt>remove and * <tt>add methods.

* * The programmer should generally provide a void (no argument) and collection * constructor, as per the recommendation in the <tt>Collection 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 { /** * 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)). Then, it gets * the element using <tt>ListIterator.next 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)). Then, it gets * the current element using <tt>ListIterator.next and replaces it * with <tt>ListIterator.set. * * <p>Note that this implementation will throw an * <tt>UnsupportedOperationException if the list iterator does not * implement the <tt>set 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)). Then, it * inserts the specified element with <tt>ListIterator.add. * * <p>Note that this implementation will throw an * <tt>UnsupportedOperationException if the list iterator does not * implement the <tt>add 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)). Then, it removes * the element with <tt>ListIterator.remove. * * <p>Note that this implementation will throw an * <tt>UnsupportedOperationException if the list iterator does not * implement the <tt>remove 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)). 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 followed by * <tt>ListIterator.next (to skip over the added element). * * <p>Note that this implementation will throw an * <tt>UnsupportedOperationException if the list iterator returned by * the <tt>listIterator method does not implement the add * 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 method) * @return a list iterator over the elements in this list (in proper * sequence) * @throws IndexOutOfBoundsException {@inheritDoc} */ public abstract ListIterator<E> listIterator(int index); }

Other Java examples (source code examples)

Here is a short list of links related to this Java AbstractSequentialList.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.