列表

ListADT<T>

列表接口

 

import java.util.Iterator; public interface ListADT<T> { /** * Removes and returns the first element from this list. * * @return the first element from this list */ public T removeFirst (); /** * Removes and returns the last element from this list. * * @return the last element from this list */ public T removeLast (); /** * Removes and returns the specified element from this list. * * @param element the element to be removed from the list */ public T remove (T element); /** * Returns a reference to the first element in this list. * * @return a reference to the first element in this list */ public T first (); /** * Returns a reference to the last element in this list. * * @return a reference to the last element in this list */ public T last (); /** * Returns true if this list contains the specified target element. * * @param target the target that is being sought in the list * @return true if the list contains this element */ public boolean contains (T target); /** * Returns true if this list contains no elements. * * @return true if this list contains no elements */ public boolean isEmpty(); /** * Returns the number of elements in this list. * * @return the integer representation of number of elements in this list */ public int size(); /** * Returns an iterator for the elements in this list. * * @return an iterator over the elements in this list */ public Iterator<T> iterator(); /** * Returns a string representation of this list. * * @return a string representation of this list */ public String toString(); } 

 

ArrayList<T>

 

/** * ArrayList represents an array implementation of a list. The front of * the list is kept at array index 0. This class will be extended * to create a specific kind of list. * * @author Dr. Lewis * @author Dr. Chase * @version 1.0, 08/13/08 */ package jss2; import jss2.exceptions.*; import java.util.Iterator; public class ArrayList<T> implements ListADT<T>, Iterable<T> { protected final int DEFAULT_CAPACITY = 100; private final int NOT_FOUND = -1; protected int rear; protected T[] list; /** * Creates an empty list using the default capacity. */ public ArrayList() { rear = 0; list = (T[])(new Object[DEFAULT_CAPACITY]); } /** * Creates an empty list using the specified capacity. * * @param initialCapacity the integer value of the size of the array list */ public ArrayList (int initialCapacity) { rear = 0; list = (T[])(new Object[initialCapacity]); } /** * Removes and returns the last element in this list. * * @return the last element in the list * @throws EmptyCollectionException if an empty collection exception occurs */ public T removeLast () throws EmptyCollectionException { T result; if (isEmpty()) throw new EmptyCollectionException ("list"); rear--; result = list[rear]; list[rear] = null; return result; } /** * Removes and returns the first element in this list. * * @return the first element in the list * @throws EmptyCollectionException if an empty collection exception occurs */ public T removeFirst() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("list"); T result = list[0]; rear--; /** shift the elements */ for (int scan=0; scan < rear; scan++) list[scan] = list[scan+1]; list[rear] = null; return result; } /** * Removes and returns the specified element. * * @param element the element to be removed and returned * from the list * @return the removed elememt * @throws ElementNotFoundException if an element not found exception occurs */ public T remove (T element) { T result; int index = find (element); if (index == NOT_FOUND) throw new ElementNotFoundException ("list"); result = list[index]; rear--; /** shift the appropriate elements */ for (int scan=index; scan < rear; scan++) list[scan] = list[scan+1]; list[rear] = null; return result; } /** * Returns a reference to the element at the front of this list. * The element is not removed from the list. Throws an * EmptyCollectionException if the list is empty. * * @return a reference to the first element in the * list * @throws EmptyCollectionException if an empty collection exception occurs */ public T first() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("list"); return list[0]; } /** * Returns a reference to the element at the rear of this list. * The element is not removed from the list. Throws an * EmptyCollectionException if the list is empty. * * @return a reference to the last element of this list * @throws EmptyCollectionException if an empty collection exception occurs */ public T last() throws EmptyCollectionException { if (isEmpty()) throw new EmptyCollectionException ("list"); return list[rear-1]; } /** * Returns true if this list contains the specified element. * * @param target the element that the list is searched for * @return true if the target is in the list, false if otherwise */ public boolean contains (T target) { return (find(target) != NOT_FOUND); } /** * Returns the array index of the specified element, or the * constant NOT_FOUND if it is not found. * * @param target the element that the list will be searched for * @return the integer index into the array containing the target * element, or the NOT_FOUND constant */ private int find (T target) { int scan = 0, result = NOT_FOUND; boolean found = false; if (! isEmpty()) while (! found && scan < rear) if (target.equals(list[scan])) found = true; else scan++; if (found) result = scan; return result; } /** * Returns true if this list is empty and false otherwise. * * @return true if the list is empty and false if otherwise */ public boolean isEmpty() { return (rear == 0); } /** * Returns the number of elements currently in this list. * * @return the integer representation of the number of elements in the list */ public int size() { return rear; } /** * Returns an iterator for the elements currently in this list. * * @return an iterator for the elements in this list */ public Iterator<T> iterator() { return new ArrayIterator<T> (list, rear); } /** * Returns a string representation of this list. * * @return the string representation of this list */ public String toString() { String result = ""; for (int scan=0; scan < rear; scan++) result = result + list[scan].toString() + "/n"; return result; } /** * Creates a new array to store the contents of this list with * twice the capacity of the old one. */ protected void expandCapacity() { T[] larger = (T[])(new Object[list.length*2]); for (int scan=0; scan < list.length; scan++) larger[scan] = list[scan]; list = larger; } }  

 

unOrderedList 接口

/** * UnorderedListADT defines the interface to an unordered list collection. * Elements are stored in any order the user desires. * * @author Dr. Lewis * @author Dr. Chase * @version 1.0, 08/13/08 */ package jss2; public interface UnorderedListADT<T> extends ListADT<T> { /** * Adds the specified element to the front of this list. * * @param element the element to be added to the front of this list */ public void addToFront (T element); /** * Adds the specified element to the rear of this list. * * @param element the element to be added to the rear of this list */ public void addToRear (T element); /** * Adds the specified element after the specified target. * * @param element the element to be added after the target * @param target the target is the item that the element will be added * after */ public void addAfter (T element, T target); }  

 

ArrayUnorderedList

 

/** * ArrayUnorderedList represents an array implementation of an unordered list. * * @author Dr. Lewis * @author Dr. Chase * @version 1.0, 08/12/08 */ package jss2; import jss2.exceptions.*; public class ArrayUnorderedList<T> extends ArrayList<T> implements UnorderedListADT<T> { /** * Creates an empty list using the default capacity. */ public ArrayUnorderedList() { super(); } /** * Creates an empty list using the specified capacity. * * @param initialCapacity the integer intial size of the list */ public ArrayUnorderedList (int initialCapacity) { super(initialCapacity); } /** * Adds the specified element to the front of this list. * * @param element the element to be added to the front of the list */ public void addToFront (T element) { if (size() == list.length) expandCapacity(); /** shift elements to make room */ for (int scan=rear; scan > 0; scan--) list[scan] = list[scan-1]; list[0] = element; rear++; } /** * Adds the specified element to the rear of this list. * * @param element the element to be added to the list */ public void addToRear (T element) { if (size() == list.length) expandCapacity(); list[rear] = element; rear++; } /** * Adds the specified element after the specified target element. * Throws an ElementNotFoundException if the target is not found. * * @param element the element to be added after the target element * @param target the target that the element is to be added after */ public void addAfter (T element, T target) { if (size() == list.length) expandCapacity(); int scan = 0; while (scan < rear && !target.equals(list[scan])) scan++; if (scan == rear) throw new ElementNotFoundException ("list"); scan++; for (int scan2=rear; scan2 > scan; scan2--) list[scan2] = list[scan2-1]; list[scan] = element; rear++; } }  

 

 

ArrayIterator<T>

/** * ArrayIterator represents an iterator over the elements of an array. * * @author Dr. Lewis * @author Dr. Chase * @version 1.0, 8/19/08 */ package jss2; import java.util.*; public class ArrayIterator<T> implements Iterator { private int count; // the number of elements in the collection private int current; // the current position in the iteration private T[] items; /** * Sets up this iterator using the specified items. * * @param collection the collection for which the iterator will be created * @param size the size of the collection */ public ArrayIterator (T[] collection, int size) { items = collection; count = size; current = 0; } /** * Returns true if this iterator has at least one more element * to deliver in the iteraion. * * @return true if this iterator has at least one more element to deliver */ public boolean hasNext() { return (current < count); } /** * Returns the next element in the iteration. If there are no * more elements in this itertion, a NoSuchElementException is * thrown. * * @return the next element in the iteration * @throws NoSuchElementException if a no such element exception occurs */ public T next() { if (! hasNext()) throw new NoSuchElementException(); current++; return items[current - 1]; } /** * The remove operation is not supported in this collection. * * @throws UnsupportedOperationException if an unsupported operation * exception occurs */ public void remove() throws UnsupportedOperationException { throw new UnsupportedOperationException(); } }