YouTipJava Vector Class
The Vector class implements a dynamic array. It is similar to an ArrayList, but with some differences:
| Feature | Vector | ArrayList |
| --- | --- | --- |
| Synchronization | Synchronized (Thread-safe) | Not synchronized |
| Performance | Slower | Faster |
| Increment | Can be specified | Fixed (50%) |
| Iterator | fail-fast | fail-fast |
| Introduced in | Java 1.0 | Java 1.2 |
**Characteristics:**
1. **Synchronized**: Vector is thread-safe; all its methods are synchronized.
2. **Dynamic Expansion**: It automatically grows when the number of elements exceeds its current capacity.
3. **Legacy Class**: Although still usable, ArrayList is generally recommended.
4. **Implements RandomAccess Interface**: Supports fast random access.
Vector is mainly used when the size of the array is not known beforehand, or when a resizable array is needed.
The Vector class supports 4 types of constructors.
The first constructor creates a default vector with an initial size of 10:
Vector()
The second constructor creates a vector of a specified size.
Vector(int size)
The third constructor creates a vector of a specified size with a specified increment. The increment indicates the number of elements to add each time the vector grows.
Vector(int size, int incr)
The fourth constructor creates a vector containing the elements of the collection c:
Vector(Collection c)
In addition to the methods inherited from its parent class, Vector defines the following methods:
### Common Operations
## Example
// Adding elements
boolean add(E e) // Adds an element to the end
void add(int index, E element) // Inserts an element at the specified position
boolean addAll(Collection c) // Adds all elements from a collection
// Getting elements
E get(int index) // Gets the element at the specified position
E firstElement() // Gets the first element
E lastElement() // Gets the last element
// Removing elements
E remove(int index) // Removes and returns the element at the specified position
boolean remove(Object o) // Removes the first occurrence of the specified element
void clear() // Removes all elements
// Other operations
int size() // Returns the number of elements
int capacity() // Returns the current capacity
void ensureCapacity(int minCapacity) // Ensures the capacity is at least the minimum
void trimToSize() // Trims the capacity to the current size
boolean contains(Object o) // Checks if the vector contains the specified element
int indexOf(Object o) // Returns the index of the first occurrence of the element
| No. | Method Description |
| --- | --- |
| 1 | [void add(int index, Object element)](#) Inserts the specified element at the specified position in this vector. |
| 2 | [boolean add(Object o)](#) Appends the specified element to the end of this vector. |
| 3 | [boolean addAll(Collection c)](#) Appends all of the elements in the specified Collection to the end of this vector, in the order that they are returned by the specified Collection's iterator. |
| 4 | [boolean addAll(int index, Collection c)](#) Inserts all of the elements in the specified Collection into this vector at the specified position. |
| 5 | [void addElement(Object obj)](#) Adds the specified component to the end of this vector, increasing its size by one. |
| 6 | [int capacity()](#) Returns the current capacity of this vector. |
| 7 | [void clear()](#) Removes all of the elements from this vector. |
| 8 | [Object clone()](#) Returns a clone of this vector. |
| 9 | [boolean contains(Object elem)](#) Returns true if this vector contains the specified element. |
| 10 | [boolean containsAll(Collection c)](#) Returns true if this vector contains all of the elements in the specified Collection. |
| 11 | [void copyInto(Object[] anArray)](#) Copies the components of this vector into the specified array. |
| 12 | [Object elementAt(int index)](#) Returns the component at the specified index. |
| 13 | [Enumeration elements()](#) Returns an enumeration of the components of this vector. |
| 14 | [void ensureCapacity(int minCapacity)](#) Increases the capacity of this vector, if necessary, to ensure that it can hold at least the number of components specified by the minimum capacity argument. |
| 15 | [boolean equals(Object o)](#) Compares the specified Object to this vector for equality. |
| 16 | [Object firstElement()](#) Returns the first component (the item at index 0) of this vector. |
| 17 | [Object get(int index)](#) Returns the element at the specified position in this vector. |
| 18 | [int hashCode()](#) Returns the hash code value for this vector. |
| 19 | [int indexOf(Object elem)](#) Returns the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element. |
| 20 | [int indexOf(Object elem, int index)](#) Returns the index of the first occurrence of the specified element in this vector, searching forwards starting at the specified index, or -1 if the element is not found. |
| 21 | [void insertElementAt(Object obj, int index)](#) Inserts the specified object as a component in this vector at the specified index. |
| 22 | [boolean isEmpty()](#) Tests if this vector has no components. |
| 23 | [Object lastElement()](#) Returns the last component of this vector. |
| 24 | [int lastIndexOf(Object elem)](#) Returns the index of the last occurrence of the specified element in this vector; returns -1 if this vector does not contain the element. |
| 25 | [int lastIndexOf(Object elem, int index)](#) Returns the index of the last occurrence of the specified element in this vector, searching backwards starting at the specified index; returns -1 if the element is not found. |
| 26 | [Object remove(int index)](#) Removes the element at the specified position in this vector. |
| 27 | [boolean remove(Object o)](#) Removes the first occurrence of the specified element in this vector. If the vector does not contain the element, it is unchanged. |
| 28 | [boolean removeAll(Collection c)](#) Removes from this vector all of its elements that are contained in the specified Collection. |
| 29 | [void removeAllElements()](#) Removes all components from this vector and sets its size to zero. |
| 30 | [boolean removeElement(Object obj)](#) Removes the first (lowest-indexed) occurrence of the argument from this vector. |
| 31 | [void removeElementAt(int index)](#) Removes the component at the specified index. |
| 32 | [protected void removeRange(int fromIndex, int toIndex)](#) Removes from this List all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. |
| 33 | [boolean retainAll(Collection c)](#) Retains only the elements in this vector that are contained in the specified Collection. |
| 34 | [Object set(int index, Object element)](#) Replaces the element at the specified position in this vector with the specified element. |
| 35 | [void setElementAt(Object obj, int index)](#) Sets the component at the specified index of this vector to be the specified object. |
| 36 | [void setSize(int newSize)](#) Sets the size of this vector. |
| 37 | [int size()](#) Returns the number of components in this vector. |
| 38 | [List subList(int fromIndex, int toIndex)](#) Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive. |
| 39 | [Object[] toArray()](#) Returns an array containing all of the elements in this vector in the correct order. |
| 40 | [Object[] toArray(Object[] a)](#) Returns an array containing all of the elements in this vector in the correct order; the runtime type of the returned array is that of the specified array. |
| 41 | [String toString()](#) Returns a string representation of this vector, containing the String representation of each element. |
| 42 | [void trimToSize()](#) Trims the capacity of this vector to be the vector's current size. |
### Example
The following program illustrates several methods supported by this collection:
## Example
import java.util.*;
public class VectorDemo {
public static void main(String args[]){
// initial size is 3, increment is 2
Vector v = new Vector(3, 2);
System.out.println("Initial size: " + v.size());
System.out.println("Initial capacity: " +
v.capacity());
v.addElement(new Integer(1));
v.addElement(new Integer(2));
v.addElement(new Integer(3));
v.addElement(new Integer(4));
System.out.println("Capacity after four additions: " +
v.capacity());
v.addElement(new Double(5.45));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Double(6.08));
v.addElement(new Integer(7));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Float(9.4));
v.addElement(new Integer(10));
System.out.println("Current capacity: " +
v.capacity());
v.addElement(new Integer(11));
v.addElement(new Integer(12));
System.out.println("First element: " +
(Integer)v.firstElement());
System.out.println("Last element: " +
(Integer)v.lastElement());
if(v.contains(new Integer(3)))
System.out.println("Vector contains 3.");
// enumerate the elements in the vector.
Enumeration vEnum = v.elements();
System.out.println("n Elements in vector:");
while(vEnum.hasMoreElements())
System.out.print(vEnum.nextElement()+" ");
System.out.println();
}
}
The compilation and execution results of the above example are as follows:
Initial size: 0Initial capacity: 3Capacity after four additions: 5Current capacity: 5Current capacity: 7Current capacity: 9First element: 1Last element: 12Vector contains 3.Elements in vector:1 2 3 4 5.45 6.08 7 9.4 10 11 12
[Java Data Structures](#)