structure5
Class Vector<E>

java.lang.Object
  structure5.AbstractStructure<E>
      structure5.AbstractList<E>
          structure5.Vector<E>

All Implemented Interfaces:

java.lang.Cloneable, java.lang.Iterable<E>, List<E>, Structure<E>

public class Vector<E>
extends AbstractList<E>
implements java.lang.Cloneable

An implementation of extensible arrays, similar to that of java.util.Vector. This vector class implements a basic extensible array. It does not implement any of the additional features of the Sun class, including list-like operations. Those operations are available in other implementors of List in this package.

Example usage: To put a program's parameters into a Vector, we would use the following:

 public static void main(String[] arguments)
 {
    Vector<String> argVec = new Vector<String>();
    for (String arg : arguments)
    {
       argVec.add(arg);
    }
    System.out.println(argVec);
 }
 

Since:

JavaStructures 1.0

Field Summary

protected int	capacityIncrement The size of size increment, should the vector become full.
protected static int	defaultCapacity The default size of the vector; may be overridden in the Vector(int) constructor.
protected int	elementCount The actual number of elements logically stored within the vector.
protected E	initialValue The initial value of any new elements that are appended to the vector.

Constructor Summary

Vector()
Construct an empty vector.

Vector(java.util.Collection<E> c)

Vector(int initialCapacity)
Construct an empty vector capable of storing initialCapacity values before the vector must be extended.

Vector(int initialCapacity, int capacityIncr)
Construct a vector with initial capacity, and growth characteristic.

Vector(int initialCapacity, int capacityIncr, E initValue)
Construct a vector with initial size, growth rate and default value.

Vector(Vector<E> that)

Method Summary

void	add(E obj) Add an element to the high end of the array, possibly expanding vector.
void	add(int index, E obj) Insert an element at a particular location.
void	addElement(E o) Add an element to the high end of the array, possibly expanding vector.
int	capacity() Determine the capacity of the vector.
void	clear() Remove all the values of the vector.
java.lang.Object	clone() Construct a shallow copy of the vector.
boolean	contains(E elem) Determine if a value appears in a vector.
void	copyInto(java.lang.Object[] dest) Copy the contents of the vector into an array.
E	elementAt(int index) Fetch the element at a particular index.
void	ensureCapacity(int minCapacity) Ensure that the vector is capable of holding at least minCapacity values without expansion.
E	firstElement() Get access to the first element of the vector.
E	get(int index) Fetch the element at a particular index.
int	indexOf(E elem) Assuming the data is not in order, find the index of a value, or return -1 if not found.
int	indexOf(E elem, int index) Assuming the data is not in order, find the index of a value or return -1 if the value is not found.
void	insertElementAt(E obj, int index) Insert an element at a particular location.
boolean	isEmpty() Determine if the Vector contains no values.
java.util.Iterator<E>	iterator() Construct a iterator over the elements of the vector.
E	lastElement() Fetch a reference to the last value in the vector.
int	lastIndexOf(E obj) Search for the last occurrence of a value within the vector.
int	lastIndexOf(E obj, int index) Find the index of the last occurrence of the value in the vector before the indexth position.
E	remove(E element) Remove an element, by value, from vector.
E	remove(int where) Remove an element at a particular location.
void	removeAllElements() Remove all the elements of the vector.
void	removeElementAt(int where) Remove an element at a particular location.
E	set(int index, E obj) Change the value stored at location index.
void	setElementAt(E obj, int index) Change the value stored at location index.
void	setSize(int newSize) Explicitly set the size of the array.
int	size() Determine the number of elements in the vector.
java.lang.String	toString() Determine a string representation for the vector.
void	trimToSize() Trim the vector to exactly the correct size.

Methods inherited from class structure5.AbstractList

addFirst, addLast, get, getFirst, getLast, remove, removeFirst, removeLast

Methods inherited from class structure5.AbstractStructure

elements, hashCode, values

Methods inherited from class java.lang.Object

equals, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface structure5.Structure

elements, values

Field Detail

elementCount

protected int elementCount

The actual number of elements logically stored within the vector. May be smaller than the actual length of the array.

capacityIncrement

protected int capacityIncrement

The size of size increment, should the vector become full. 0 indicates the vector should be doubled when capacity of the array is reached.

initialValue

protected E initialValue

The initial value of any new elements that are appended to the vector. Normally null. Be aware that references used in this way will result in multiple references to a single object.

defaultCapacity

protected static final int defaultCapacity

The default size of the vector; may be overridden in the Vector(int) constructor.

See Also:

Constant Field Values

Constructor Detail

Vector

public Vector()

Construct an empty vector.

Postcondition:

constructs a vector with capacity for 10 elements

Vector

public Vector(int initialCapacity)

Construct an empty vector capable of storing initialCapacity values before the vector must be extended.

Parameters:

initialCapacity - The size of vector before reallocation is necessary

Precondition:

initialCapacity >= 0

Postcondition:

constructs an empty vector with initialCapacity capacity

Vector

public Vector(int initialCapacity,
              int capacityIncr)

Construct a vector with initial capacity, and growth characteristic.

Parameters:

initialCapacity - The initial number of slots in vector.

capacityIncr - The size of growth of vector.

See Also:

capacityIncrement

Precondition:

initialCapacity >= 0, capacityIncr >= 0

Postcondition:

constructs an empty vector with initialCapacity capacity that extends capacity by capacityIncr, or doubles if 0

Vector

public Vector(int initialCapacity,
              int capacityIncr,
              E initValue)

Construct a vector with initial size, growth rate and default value.

Parameters:

initialCapacity - The initial number of slots in vector.

capacityIncr - The size of the increment when vector grows.

initValue - The initial value stored in vector elements.

Precondition:

initialCapacity, capacityIncr >= 0

Postcondition:

constructs empty vector with capacity that begins at initialCapacity and extends by capacityIncr or doubles if 0. New entries in vector are initialized to initValue.

Vector

public Vector(Vector<E> that)

Vector

public Vector(java.util.Collection<E> c)

Method Detail

ensureCapacity

public void ensureCapacity(int minCapacity)

Ensure that the vector is capable of holding at least minCapacity values without expansion.

Parameters:

minCapacity - The minimum size of array before expansion.

Postcondition:

the capacity of this vector is at least minCapacity

add

public void add(E obj)

Add an element to the high end of the array, possibly expanding vector.

Specified by:

add in interface List<E>

Specified by:

add in interface Structure<E>

Overrides:

add in class AbstractList<E>

Parameters:

obj - The object to be added to the end of the vector.

See Also:

AbstractList.addLast(E)

Postcondition:

adds new element to end of possibly extended vector

addElement

public void addElement(E o)

Add an element to the high end of the array, possibly expanding vector.

Parameters:

obj - The object to be added to the end of the vector.

Postcondition:

adds new element to end of possibly extended vector

remove

public E remove(E element)

Remove an element, by value, from vector.

Specified by:

remove in interface List<E>

Specified by:

remove in interface Structure<E>

Parameters:

element - the element to be removed.

Returns:

the element actually removed, or if none, null.

Postcondition:

element equal to parameter is removed and returned

capacity

public int capacity()

Determine the capacity of the vector. The capacity is always at least as large as its size.

Returns:

The size of the array underlying the vector.

Postcondition:

returns allocated size of the vector

clone

public java.lang.Object clone()

Construct a shallow copy of the vector. The vector store is copied, but the individual elements are shared objects.

Overrides:

clone in class java.lang.Object

Returns:

A copy of the original vector.

Postcondition:

returns a copy of the vector, using same objects

contains

public boolean contains(E elem)

Determine if a value appears in a vector.

Specified by:

contains in interface List<E>

Specified by:

contains in interface Structure<E>

Overrides:

contains in class AbstractList<E>

Parameters:

elem - The value sought.

Returns:

True iff the value appears in the vector.

Postcondition:

returns true iff Vector contains the value (could be faster, if orderedVector is used)

copyInto

public void copyInto(java.lang.Object[] dest)

Copy the contents of the vector into an array. The array must be large enough to accept all the values in the vector.

Parameters:

dest - An array of size at least size().

Precondition:

dest has at least size() elements

Postcondition:

a copy of the vector is stored in the dest array

elementAt

public E elementAt(int index)

Fetch the element at a particular index. The index of the first element is zero.

Parameters:

index - The index of the value sought.

Returns:

A reference to the value found in the vector.

Precondition:

0 <= index && index < size()

Postcondition:

returns the element stored in location index

get

public E get(int index)

Fetch the element at a particular index. The index of the first element is zero.

Specified by:

get in interface List<E>

Parameters:

index - The index of the value sought.

Returns:

A reference to the value found in the vector.

Precondition:

0 <= index && index < size()

Postcondition:

returns the element stored in location index

iterator

public java.util.Iterator<E> iterator()

Construct a iterator over the elements of the vector. The iterator considers elements with increasing index.

Specified by:

iterator in interface java.lang.Iterable<E>

Specified by:

iterator in interface List<E>

Specified by:

iterator in interface Structure<E>

Returns:

an iterator to traverse the vector.

See Also:

AbstractIterator, Iterator, Enumeration, Structure.elements()

Postcondition:

returns an iterator allowing one to view elements of vector

firstElement

public E firstElement()

Get access to the first element of the vector.

Returns:

Access to the first element of the vector.

Precondition:

vector contains an element

Postcondition:

returns first value in vector

indexOf

public int indexOf(E elem)

Assuming the data is not in order, find the index of a value, or return -1 if not found.

Specified by:

indexOf in interface List<E>

Parameters:

elem - The value sought in vector.

Returns:

The index of the first occurrence of the value.

Postcondition:

returns index of element equal to object, or -1; starts at 0

indexOf

public int indexOf(E elem,
                   int index)

Assuming the data is not in order, find the index of a value or return -1 if the value is not found. Search starts at index.

Parameters:

elem - The value sought.

index - The first location considered.

Returns:

The index of the first location, or -1 if not found.

Postcondition:

returns index of element equal to object, or -1; starts at index

insertElementAt

public void insertElementAt(E obj,
                            int index)

Insert an element at a particular location. Vector is grown as needed

Parameters:

obj - The value to be inserted.

index - The location of the new value.

Precondition:

0 <= index <= size()

Postcondition:

inserts new value in vector with desired index, moving elements from index to size()-1 to right

add

public void add(int index,
                E obj)

Insert an element at a particular location. Vector is grown as needed

Specified by:

add in interface List<E>

Parameters:

obj - the value to be inserted.

index - the location of the new value.

Precondition:

0 <= index <= size()

Postcondition:

inserts new value in vector with desired index, moving elements from index to size()-1 to right

isEmpty

public boolean isEmpty()

Determine if the Vector contains no values.

Specified by:

isEmpty in interface List<E>

Specified by:

isEmpty in interface Structure<E>

Overrides:

isEmpty in class AbstractList<E>

Returns:

True iff the vector is empty.

Postcondition:

returns true iff there are no elements in the vector

lastElement

public E lastElement()

Fetch a reference to the last value in the vector.

Returns:

A reference to the last value.

Precondition:

vector is not empty

Postcondition:

returns last element of the vector

lastIndexOf

public int lastIndexOf(E obj)

Search for the last occurrence of a value within the vector. If none is found, return -1.

Specified by:

lastIndexOf in interface List<E>

Parameters:

obj - The value sought.

Returns:

The index of the last occurrence in the vector.

Postcondition:

returns index of last occurrence of object in the vector, or -1

lastIndexOf

public int lastIndexOf(E obj,
                       int index)

Find the index of the last occurrence of the value in the vector before the indexth position.

Parameters:

obj - The value sought.

index - The last acceptable index.

Returns:

The index of the last occurrence of the value, or -1 if none.

Precondition:

index >= 0

Postcondition:

returns the index of last occurrence of object at or before index

clear

public void clear()

Remove all the values of the vector.

Specified by:

clear in interface List<E>

Specified by:

clear in interface Structure<E>

Postcondition:

vector is empty

removeAllElements

public void removeAllElements()

Remove all the elements of the vector. Kept for compatibility with java.util.Vector.

See Also:

clear()

Postcondition:

vector is empty

removeElementAt

public void removeElementAt(int where)

Remove an element at a particular location.

Parameters:

where - The location of the element to be removed.

Precondition:

0 <= where && where < size()

Postcondition:

indicated element is removed, size decreases by 1

remove

public E remove(int where)

Remove an element at a particular location.

Specified by:

remove in interface List<E>

Parameters:

where - The location of the element to be removed.

Returns:

value retrieved from location i (returns null if i invalid)

Precondition:

0 <= where && where < size()

Postcondition:

indicated element is removed, size decreases by 1

setElementAt

public void setElementAt(E obj,
                         int index)

Change the value stored at location index.

Parameters:

obj - The new value to be stored.

index - The index of the new value.

Precondition:

0 <= index && index < size()

Postcondition:

element value is changed to obj

set

public E set(int index,
             E obj)

Change the value stored at location index.

Specified by:

set in interface List<E>

Parameters:

obj - The new value to be stored.

index - The index of the new value.

Returns:

former value of ith entry of list.

Precondition:

0 <= index && index < size()

Postcondition:

element value is changed to obj; old value is returned

setSize

public void setSize(int newSize)

Explicitly set the size of the array. Any new elements are initialized to the default value.

Parameters:

newSize - The ultimate size of the vector.

Precondition:

newSize >= 0

Postcondition:

vector is resized, any new elements are initialized

size

public int size()

Determine the number of elements in the vector.

Specified by:

size in interface List<E>

Specified by:

size in interface Structure<E>

Returns:

The number of elements within the vector.

Postcondition:

returns the size of the vector

trimToSize

public void trimToSize()

Trim the vector to exactly the correct size.

Postcondition:

minimizes allocated size of vector

toString

public java.lang.String toString()

Determine a string representation for the vector.

Overrides:

toString in class java.lang.Object

Returns:

A string representation for the vector.

Postcondition:

returns a string representation of vector