Vector4D (TotalCrossSDK 6.1.0 API)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<T>
  - - totalcross.util.Vector4D<T>

All Implemented Interfaces:

java.lang.Cloneable, java.lang.Iterable<T>, java.util.Collection<T>, java.util.List<T>, java.util.RandomAccess
```
public class Vector4D<T>
extends java.util.AbstractList<T>
implements java.util.List<T>, java.util.RandomAccess, java.lang.Cloneable
```
The Vector classes implements growable arrays of Objects. You can access elements in a Vector with an index, just as you can in a built in array, but Vectors can grow and shrink to accommodate more or fewer objects.
Vectors try to mantain efficiency in growing by having a capacityIncrement that can be specified at instantiation. When a Vector can no longer hold a new Object, it grows by the amount in capacityIncrement. If this value is 0, the vector doubles in size.
Vector implements the JDK 1.2 List interface, and is therefore a fully compliant Collection object. The iterators are fail-fast - if external code structurally modifies the vector, any operation on the iterator will then throw a ConcurrentModificationException. The Vector class is fully synchronized, but the iterators are not. So, when iterating over a vector, be sure to synchronize on the vector itself. If you don't want the expense of synchronization, use ArrayList instead. On the other hand, the Enumeration of elements() is not thread-safe, nor is it fail-fast; so it can lead to undefined behavior even in a single thread if you modify the vector during iteration.
Note: Some methods, especially those specified by List, specify throwing IndexOutOfBoundsException, but it is easier to implement by throwing the subclass ArrayIndexOutOfBoundsException. Others directly specify this subclass.

Since:

1.0

See Also:

Collection, List, ArrayList, LinkedList

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`capacityIncrement` The amount the Vector's internal array should be increased in size when a new element is added that exceeds the current size of the array, or when `ensureCapacity(int)` is called.
`protected int`	`elementCount` The number of elements currently in the vector, also returned by `size()`.
`protected java.lang.Object[]`	`elementData` The internal array used to hold members of a Vector.

Fields inherited from class java.util.AbstractList
modCount

Constructor Summary

Constructors
Constructor and Description
`Vector4D()` Constructs an empty vector with an initial size of 10, and a capacity increment of 0
`Vector4D(java.util.Collection<? extends T> c)` Constructs a vector containing the contents of Collection, in the order given by the collection.
`Vector4D(int initialCapacity)` Constructs a Vector with the initial capacity specified, and a capacity increment of 0 (double in size).
`Vector4D(int initialCapacity, int capacityIncrement)` Constructs a Vector with the initial capacity and capacity increment specified.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(int index, T element)` Adds an object at the specified index.
`boolean`	`add(T o)` Adds an object to the Vector.
`boolean`	`addAll(java.util.Collection<? extends T> c)` Appends all elements of the given collection to the end of this Vector.
`boolean`	`addAll(int index, java.util.Collection<? extends T> c)` Inserts all elements of the given collection at the given index of this Vector.
`void`	`addElement(T obj)` Adds an element to the Vector at the end of the Vector.
`int`	`capacity()` Returns the size of the internal data array (not the amount of elements contained in the Vector).
`void`	`clear()` Clears all elements in the Vector and sets its size to 0.
`java.lang.Object`	`clone()` Creates a new Vector with the same contents as this one.
`boolean`	`contains(java.lang.Object elem)` Returns true when `elem` is contained in this Vector.
`boolean`	`containsAll(java.util.Collection<?> c)` Returns true if this Vector contains all the elements in c.
`void`	`copyInto(java.lang.Object[] a)` Copies the contents of the Vector into the provided array.
`T`	`elementAt(int index)` Returns the Object stored at `index`.
`java.util.Enumeration<T>`	`elements()` Returns an Enumeration of the elements of this Vector.
`void`	`ensureCapacity(int minCapacity)` Ensures that `minCapacity` elements can fit within this Vector.
`boolean`	`equals(java.lang.Object o)` Compares this to the given object.
`T`	`firstElement()` Returns the first element (index 0) in the Vector.
`T`	`get(int index)` Returns the element at position `index`.
`int`	`hashCode()` Computes the hashcode of this object.
`int`	`indexOf(java.lang.Object elem)` Returns the first occurrence of `elem` in the Vector, or -1 if `elem` is not found.
`int`	`indexOf(java.lang.Object e, int index)` Searches the vector starting at `index` for object `elem` and returns the index of the first occurrence of this Object.
`void`	`insertElementAt(T obj, int index)` Inserts a new element into the Vector at `index`.
`boolean`	`isEmpty()` Returns true if this Vector is empty, false otherwise
`T`	`lastElement()` Returns the last element in the Vector.
`int`	`lastIndexOf(java.lang.Object elem)` Returns the last index of `elem` within this Vector, or -1 if the object is not within the Vector.
`int`	`lastIndexOf(java.lang.Object e, int index)` Returns the index of the first occurrence of `elem`, when searching backwards from `index`.
`T`	`remove(int index)` Removes the element at the specified index, and returns it.
`boolean`	`remove(java.lang.Object o)` Removes the given Object from the Vector.
`boolean`	`removeAll(java.util.Collection<?> c)` Remove from this vector all elements contained in the given collection.
`void`	`removeAllElements()` Removes all elements from the Vector.
`boolean`	`removeElement(java.lang.Object obj)` Removes the first (the lowest index) occurrence of the given object from the Vector.
`void`	`removeElementAt(int index)` Removes the element at `index`, and shifts all elements at positions greater than index to their index - 1.
`protected void`	`removeRange(int fromIndex, int toIndex)` Removes a range of elements from this list.
`boolean`	`retainAll(java.util.Collection<?> c)` Retain in this vector only the elements contained in the given collection.
`T`	`set(int index, T element)` Puts `element` into the Vector at position `index` and returns the Object that previously occupied that position.
`void`	`setElementAt(T obj, int index)` Changes the element at `index` to be `obj`
`void`	`setSize(int newSize)` Explicitly sets the size of the vector (but not necessarily the size of the internal data array).
`int`	`size()` Returns the number of elements stored in this Vector.
`java.util.List<T>`	`subList(int fromIndex, int toIndex)` Obtain a List view of a subsection of this list, from fromIndex (inclusive) to toIndex (exclusive).
`java.lang.Object[]`	`toArray()` Returns an Object array with the contents of this Vector, in the order they are stored within this Vector.
`<S> S[]`	`toArray(S[] a)` Returns an array containing the contents of this Vector.
`java.lang.String`	`toString()` Returns a string representation of this Vector in the form "[element0, element1, ...
`void`	`trimToSize()` Trims the Vector down to size.

Methods inherited from class java.util.AbstractList
iterator, listIterator, listIterator

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List
iterator, listIterator, listIterator, replaceAll, sort, spliterator

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

- Field Detail
  - elementData
```
protected java.lang.Object[] elementData
```
    The internal array used to hold members of a Vector. The elements are in positions 0 through elementCount - 1, and all remaining slots are null.
  - elementCount
```
protected int elementCount
```
    The number of elements currently in the vector, also returned by size().
  - capacityIncrement
```
protected int capacityIncrement
```
    The amount the Vector's internal array should be increased in size when a new element is added that exceeds the current size of the array, or when ensureCapacity(int) is called. If <= 0, the vector just doubles in size.
- Constructor Detail
  - Vector4D
```
public Vector4D()
```
    Constructs an empty vector with an initial size of 10, and a capacity increment of 0
  - Vector4D
```
public Vector4D(java.util.Collection<? extends T> c)
```
    Constructs a vector containing the contents of Collection, in the order given by the collection.
    
    Parameters:
    
    c - collection of elements to add to the new vector
    
    Throws:
    
    java.lang.NullPointerException - if c is null
    
    Since:
    
    1.2
  - Vector4D
```
public Vector4D(int initialCapacity,
                int capacityIncrement)
```
    Constructs a Vector with the initial capacity and capacity increment specified.
    
    Parameters:
    
    initialCapacity - the initial size of the Vector's internal array
    
    capacityIncrement - the amount the internal array should be increased by when necessary, 0 to double the size
    
    Throws:
    
    java.lang.IllegalArgumentException - if initialCapacity < 0
  - Vector4D
```
public Vector4D(int initialCapacity)
```
    Constructs a Vector with the initial capacity specified, and a capacity increment of 0 (double in size).
    
    Parameters:
    
    initialCapacity - the initial size of the Vector's internal array
    
    Throws:
    
    java.lang.IllegalArgumentException - if initialCapacity < 0
- Method Detail
  - copyInto
```
public void copyInto(java.lang.Object[] a)
```
    Copies the contents of the Vector into the provided array. If the array is too small to fit all the elements in the Vector, an IndexOutOfBoundsException is thrown without modifying the array. Old elements in the array are overwritten by the new elements.
    
    Parameters:
    
    a - target array for the copy
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - the array is not large enough
    
    java.lang.NullPointerException - the array is null
    
    See Also:
    
    toArray(Object[])
  - trimToSize
```
public void trimToSize()
```
    Trims the Vector down to size. If the internal data array is larger than the number of Objects its holding, a new array is constructed that precisely holds the elements. Otherwise this does nothing.
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
    Ensures that minCapacity elements can fit within this Vector. If elementData is too small, it is expanded as follows: If the elementCount + capacityIncrement is adequate, that is the new size. If capacityIncrement is non-zero, the candidate size is double the current. If that is not enough, the new size is minCapacity.
    
    Parameters:
    
    minCapacity - the desired minimum capacity, negative values ignored
  - setSize
```
public void setSize(int newSize)
```
    Explicitly sets the size of the vector (but not necessarily the size of the internal data array). If the new size is smaller than the old one, old values that don't fit are lost. If the new size is larger than the old one, the vector is padded with null entries.
    
    Parameters:
    
    newSize - The new size of the internal array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the new size is negative
  - capacity
```
public int capacity()
```
    Returns the size of the internal data array (not the amount of elements contained in the Vector).
    
    Returns:
    
    capacity of the internal data array
  - size
```
public int size()
```
    Returns the number of elements stored in this Vector.
    
    Specified by:
    
    size in interface java.util.Collection<T>
    
    Specified by:
    
    size in interface java.util.List<T>
    
    Specified by:
    
    size in class java.util.AbstractCollection<T>
    
    Returns:
    
    the number of elements in this Vector
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this Vector is empty, false otherwise
    
    Specified by:
    
    isEmpty in interface java.util.Collection<T>
    
    Specified by:
    
    isEmpty in interface java.util.List<T>
    
    Overrides:
    
    isEmpty in class java.util.AbstractCollection<T>
    
    Returns:
    
    true if the Vector is empty, false otherwise
  - elements
```
public java.util.Enumeration<T> elements()
```
    Returns an Enumeration of the elements of this Vector. The enumeration visits the elements in increasing index order, but is NOT thread-safe.
    
    Returns:
    
    an Enumeration
    
    See Also:
    
    AbstractList.iterator()
  - contains
```
public boolean contains(java.lang.Object elem)
```
    Returns true when elem is contained in this Vector.
    
    Specified by:
    
    contains in interface java.util.Collection<T>
    
    Specified by:
    
    contains in interface java.util.List<T>
    
    Overrides:
    
    contains in class java.util.AbstractCollection<T>
    
    Parameters:
    
    elem - the element to check
    
    Returns:
    
    true if the object is contained in this Vector, false otherwise
  - indexOf
```
public int indexOf(java.lang.Object elem)
```
    Returns the first occurrence of elem in the Vector, or -1 if elem is not found.
    
    Specified by:
    
    indexOf in interface java.util.List<T>
    
    Overrides:
    
    indexOf in class java.util.AbstractList<T>
    
    Parameters:
    
    elem - the object to search for
    
    Returns:
    
    the index of the first occurrence, or -1 if not found
  - indexOf
```
public int indexOf(java.lang.Object e,
                   int index)
```
    Searches the vector starting at index for object elem and returns the index of the first occurrence of this Object. If the object is not found, or index is larger than the size of the vector, -1 is returned.
    
    Parameters:
    
    e - the Object to search for
    
    index - start searching at this index
    
    Returns:
    
    the index of the next occurrence, or -1 if it is not found
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index < 0
  - lastIndexOf
```
public int lastIndexOf(java.lang.Object elem)
```
    Returns the last index of elem within this Vector, or -1 if the object is not within the Vector.
    
    Specified by:
    
    lastIndexOf in interface java.util.List<T>
    
    Overrides:
    
    lastIndexOf in class java.util.AbstractList<T>
    
    Parameters:
    
    elem - the object to search for
    
    Returns:
    
    the last index of the object, or -1 if not found
  - lastIndexOf
```
public int lastIndexOf(java.lang.Object e,
                       int index)
```
    Returns the index of the first occurrence of elem, when searching backwards from index. If the object does not occur in this Vector, or index is less than 0, -1 is returned.
    
    Parameters:
    
    e - the object to search for
    
    index - the index to start searching in reverse from
    
    Returns:
    
    the index of the Object if found, -1 otherwise
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index >= size()
  - elementAt
```
public T elementAt(int index)
```
    Returns the Object stored at index.
    
    Parameters:
    
    index - the index of the Object to retrieve
    
    Returns:
    
    the object at index
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index >= size()
    
    See Also:
    
    get(int)
  - firstElement
```
public T firstElement()
```
    Returns the first element (index 0) in the Vector.
    
    Returns:
    
    the first Object in the Vector
    
    Throws:
    
    java.util.NoSuchElementException - the Vector is empty
  - lastElement
```
public T lastElement()
```
    Returns the last element in the Vector.
    
    Returns:
    
    the last Object in the Vector
    
    Throws:
    
    java.util.NoSuchElementException - the Vector is empty
  - setElementAt
```
public void setElementAt(T obj,
                         int index)
```
    Changes the element at index to be obj
    
    Parameters:
    
    obj - the object to store
    
    index - the position in the Vector to store the object
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - the index is out of range
    
    See Also:
    
    set(int, Object)
  - removeElementAt
```
public void removeElementAt(int index)
```
    Removes the element at index, and shifts all elements at positions greater than index to their index - 1.
    
    Parameters:
    
    index - the index of the element to remove
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index >= size();
    
    See Also:
    
    remove(int)
  - insertElementAt
```
public void insertElementAt(T obj,
                            int index)
```
    Inserts a new element into the Vector at index. Any elements at or greater than index are shifted up one position.
    
    Parameters:
    
    obj - the object to insert
    
    index - the index at which the object is inserted
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index > size()
    
    See Also:
    
    add(int, Object)
  - addElement
```
public void addElement(T obj)
```
    Adds an element to the Vector at the end of the Vector. The vector is increased by ensureCapacity(size() + 1) if needed.
    
    Parameters:
    
    obj - the object to add to the Vector
  - removeElement
```
public boolean removeElement(java.lang.Object obj)
```
    Removes the first (the lowest index) occurrence of the given object from the Vector. If such a remove was performed (the object was found), true is returned. If there was no such object, false is returned.
    
    Parameters:
    
    obj - the object to remove from the Vector
    
    Returns:
    
    true if the Object was in the Vector, false otherwise
    
    See Also:
    
    remove(Object)
  - removeAllElements
```
public void removeAllElements()
```
    Removes all elements from the Vector. Note that this does not resize the internal data array.
    
    See Also:
    
    clear()
  - clone
```
public java.lang.Object clone()
```
    Creates a new Vector with the same contents as this one. The clone is shallow; elements are not cloned.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    
    the clone of this vector
  - toArray
```
public java.lang.Object[] toArray()
```
    Returns an Object array with the contents of this Vector, in the order they are stored within this Vector. Note that the Object array returned is not the internal data array, and that it holds only the elements within the Vector. This is similar to creating a new Object[] with the size of this Vector, then calling Vector.copyInto(yourArray).
    
    Specified by:
    
    toArray in interface java.util.Collection<T>
    
    Specified by:
    
    toArray in interface java.util.List<T>
    
    Overrides:
    
    toArray in class java.util.AbstractCollection<T>
    
    Returns:
    
    an Object[] containing the contents of this Vector in order
    
    Since:
    
    1.2
  - toArray
```
public <S> S[] toArray(S[] a)
```
    Returns an array containing the contents of this Vector. If the provided array is large enough, the contents are copied into that array, and a null is placed in the position size(). In this manner, you can obtain the size of a Vector by the position of the null element, if you know the vector does not itself contain null entries. If the array is not large enough, reflection is used to create a bigger one of the same runtime type.
    
    Specified by:
    
    toArray in interface java.util.Collection<T>
    
    Specified by:
    
    toArray in interface java.util.List<T>
    
    Overrides:
    
    toArray in class java.util.AbstractCollection<T>
    
    Parameters:
    
    a - an array to copy the Vector into if large enough
    
    Returns:
    
    an array with the contents of this Vector in order
    
    Throws:
    
    java.lang.ArrayStoreException - the runtime type of the provided array cannot hold the elements of the Vector
    
    java.lang.NullPointerException - if a is null
    
    Since:
    
    1.2
  - get
```
public T get(int index)
```
    Returns the element at position index.
    
    Specified by:
    
    get in interface java.util.List<T>
    
    Specified by:
    
    get in class java.util.AbstractList<T>
    
    Parameters:
    
    index - the position from which an element will be retrieved
    
    Returns:
    
    the element at that position
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index >= size()
    
    Since:
    
    1.2
  - set
```
public T set(int index,
             T element)
```
    Puts element into the Vector at position index and returns the Object that previously occupied that position.
    
    Specified by:
    
    set in interface java.util.List<T>
    
    Overrides:
    
    set in class java.util.AbstractList<T>
    
    Parameters:
    
    index - the index within the Vector to place the Object
    
    element - the Object to store in the Vector
    
    Returns:
    
    the previous object at the specified index
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index >= size()
    
    Since:
    
    1.2
  - add
```
public boolean add(T o)
```
    Adds an object to the Vector.
    
    Specified by:
    
    add in interface java.util.Collection<T>
    
    Specified by:
    
    add in interface java.util.List<T>
    
    Overrides:
    
    add in class java.util.AbstractList<T>
    
    Parameters:
    
    o - the element to add to the Vector
    
    Returns:
    
    true, as specified by List
    
    Since:
    
    1.2
  - remove
```
public boolean remove(java.lang.Object o)
```
    Removes the given Object from the Vector. If it exists, true is returned, if not, false is returned.
    
    Specified by:
    
    remove in interface java.util.Collection<T>
    
    Specified by:
    
    remove in interface java.util.List<T>
    
    Overrides:
    
    remove in class java.util.AbstractCollection<T>
    
    Parameters:
    
    o - the object to remove from the Vector
    
    Returns:
    
    true if the Object existed in the Vector, false otherwise
    
    Since:
    
    1.2
  - add
```
public void add(int index,
                T element)
```
    Adds an object at the specified index. Elements at or above index are shifted up one position.
    
    Specified by:
    
    add in interface java.util.List<T>
    
    Overrides:
    
    add in class java.util.AbstractList<T>
    
    Parameters:
    
    index - the index at which to add the element
    
    element - the element to add to the Vector
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index > size()
    
    Since:
    
    1.2
  - remove
```
public T remove(int index)
```
    Removes the element at the specified index, and returns it.
    
    Specified by:
    
    remove in interface java.util.List<T>
    
    Overrides:
    
    remove in class java.util.AbstractList<T>
    
    Parameters:
    
    index - the position from which to remove the element
    
    Returns:
    
    the object removed
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index >= size()
    
    Since:
    
    1.2
  - clear
```
public void clear()
```
    Clears all elements in the Vector and sets its size to 0.
    
    Specified by:
    
    clear in interface java.util.Collection<T>
    
    Specified by:
    
    clear in interface java.util.List<T>
    
    Overrides:
    
    clear in class java.util.AbstractList<T>
  - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
    Returns true if this Vector contains all the elements in c.
    
    Specified by:
    
    containsAll in interface java.util.Collection<T>
    
    Specified by:
    
    containsAll in interface java.util.List<T>
    
    Overrides:
    
    containsAll in class java.util.AbstractCollection<T>
    
    Parameters:
    
    c - the collection to compare to
    
    Returns:
    
    true if this vector contains all elements of c
    
    Throws:
    
    java.lang.NullPointerException - if c is null
    
    Since:
    
    1.2
  - addAll
```
public boolean addAll(java.util.Collection<? extends T> c)
```
    Appends all elements of the given collection to the end of this Vector. Behavior is undefined if the collection is modified during this operation (for example, if this == c).
    
    Specified by:
    
    addAll in interface java.util.Collection<T>
    
    Specified by:
    
    addAll in interface java.util.List<T>
    
    Overrides:
    
    addAll in class java.util.AbstractCollection<T>
    
    Parameters:
    
    c - the collection to append
    
    Returns:
    
    true if this vector changed, in other words c was not empty
    
    Throws:
    
    java.lang.NullPointerException - if c is null
    
    Since:
    
    1.2
  - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
    Remove from this vector all elements contained in the given collection.
    
    Specified by:
    
    removeAll in interface java.util.Collection<T>
    
    Specified by:
    
    removeAll in interface java.util.List<T>
    
    Overrides:
    
    removeAll in class java.util.AbstractCollection<T>
    
    Parameters:
    
    c - the collection to filter out
    
    Returns:
    
    true if this vector changed
    
    Throws:
    
    java.lang.NullPointerException - if c is null
    
    Since:
    
    1.2
  - retainAll
```
public boolean retainAll(java.util.Collection<?> c)
```
    Retain in this vector only the elements contained in the given collection.
    
    Specified by:
    
    retainAll in interface java.util.Collection<T>
    
    Specified by:
    
    retainAll in interface java.util.List<T>
    
    Overrides:
    
    retainAll in class java.util.AbstractCollection<T>
    
    Parameters:
    
    c - the collection to filter by
    
    Returns:
    
    true if this vector changed
    
    Throws:
    
    java.lang.NullPointerException - if c is null
    
    Since:
    
    1.2
  - addAll
```
public boolean addAll(int index,
                      java.util.Collection<? extends T> c)
```
    Inserts all elements of the given collection at the given index of this Vector. Behavior is undefined if the collection is modified during this operation (for example, if this == c).
    
    Specified by:
    
    addAll in interface java.util.List<T>
    
    Overrides:
    
    addAll in class java.util.AbstractList<T>
    
    Parameters:
    
    c - the collection to append
    
    Returns:
    
    true if this vector changed, in other words c was not empty
    
    Throws:
    
    java.lang.NullPointerException - if c is null
    
    java.lang.ArrayIndexOutOfBoundsException - index < 0 || index > size()
    
    Since:
    
    1.2
  - equals
```
public boolean equals(java.lang.Object o)
```
    Compares this to the given object.
    
    Specified by:
    
    equals in interface java.util.Collection<T>
    
    Specified by:
    
    equals in interface java.util.List<T>
    
    Overrides:
    
    equals in class java.util.AbstractList<T>
    
    Parameters:
    
    o - the object to compare to
    
    Returns:
    
    true if the two are equal
    
    Since:
    
    1.2
  - hashCode
```
public int hashCode()
```
    Computes the hashcode of this object.
    
    Specified by:
    
    hashCode in interface java.util.Collection<T>
    
    Specified by:
    
    hashCode in interface java.util.List<T>
    
    Overrides:
    
    hashCode in class java.util.AbstractList<T>
    
    Returns:
    
    the hashcode
    
    Since:
    
    1.2
  - toString
```
public java.lang.String toString()
```
    Returns a string representation of this Vector in the form "[element0, element1, ... elementN]".
    
    Overrides:
    
    toString in class java.util.AbstractCollection<T>
    
    Returns:
    
    the String representation of this Vector
  - subList
```
public java.util.List<T> subList(int fromIndex,
                                 int toIndex)
```
    Obtain a List view of a subsection of this list, from fromIndex (inclusive) to toIndex (exclusive). If the two indices are equal, the sublist is empty. The returned list is modifiable, and changes in one reflect in the other. If this list is structurally modified in any way other than through the returned list, the result of any subsequent operations on the returned list is undefined.
    
    Specified by:
    
    subList in interface java.util.List<T>
    
    Overrides:
    
    subList in class java.util.AbstractList<T>
    
    Parameters:
    
    fromIndex - the index that the returned list should start from (inclusive)
    
    toIndex - the index that the returned list should go to (exclusive)
    
    Returns:
    
    a List backed by a subsection of this vector
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if fromIndex < 0 || toIndex > size()
    
    java.lang.IllegalArgumentException - if fromIndex > toIndex
    
    Since:
    
    1.2
    
    See Also:
    
    ConcurrentModificationException
  - removeRange
```
protected void removeRange(int fromIndex,
                           int toIndex)
```
    Removes a range of elements from this list. Does nothing when toIndex is equal to fromIndex.
    
    Overrides:
    
    removeRange in class java.util.AbstractList<T>
    
    Parameters:
    
    fromIndex - the index to start deleting from (inclusive)
    
    toIndex - the index to delete up to (exclusive)
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if fromIndex > toIndex

Class Vector4D<T>

Field Summary

Fields inherited from class java.util.AbstractList

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractList

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Field Detail

elementData

elementCount

capacityIncrement

Constructor Detail

Vector4D

Vector4D

Vector4D

Vector4D

Method Detail

copyInto

trimToSize

ensureCapacity

setSize

capacity

size

isEmpty

elements

contains

indexOf

indexOf

lastIndexOf

lastIndexOf

elementAt

firstElement

lastElement

setElementAt

removeElementAt

insertElementAt

addElement

removeElement

removeAllElements

clone

toArray

toArray

get

set

add

remove

add

remove

clear

containsAll

addAll

removeAll

retainAll

addAll

equals

hashCode

toString

subList

removeRange