Menu
Topics Index
...
`


Collections Framework > Legacy Classes and Interfaces >
Siva Nookala - 14 Apr 2016
Vector implements a dynamic array. It is similar to Java ArrayList, but with two differences:
  • Vector is synchronized.
  • Vector contains many legacy methods that are not part of the collections framework.
Vector proves to be very useful if you don't know the size of the array in advance or you just need one that can change sizes over the lifetime of a program.

Vector Constructors :
ConstructorDescription
Vector()Constructs an empty vector so that its internal data array has size 10 and its standard capacity increment is zero.
Vector(int initialCapacity)Constructs an empty vector with the specified initial capacity and with its capacity increment equal to zero.
Vector(int initialCapacity, int capacityIncrement)Constructs an empty vector with the specified initial capacity and capacity increment.
Vector(Collection c)Constructs a vector containing the elements of the specified collection, in the order they are returned by the collection's iterator.

Vector Methods :
MethodDescription
boolean add(Object o)Appends the specified element to the end of this Vector.
void add(int index, Object element)Inserts the specified element at the specified position in this Vector.
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.
boolean addAll(int index, Collection c)Inserts all of the elements in the specified Collection into this Vector at the specified position.
void addElement(Object obj)Adds the specified component to the end of this vector, increasing its size by one.
int capacity()Returns the current capacity of this vector.
void clear()Removes all of the elements from this Vector.
Object clone()Returns a clone of this vector.
boolean contains(Object element)Returns true if this vector contains the specified element.
boolean containsAll(Collection c)Returns true if this Vector contains all of the elements in the specified Collection.
void copyInto(Object[] anArray)Copies the components of this vector into the specified array.
Object elementAt(int index)Returns the component at the specified index.
Enumeration elements()Returns an enumeration of the components of this vector.
void Java StringBuffer ensureCapacity() Method With Example(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.
boolean equals(Object o)Compares the specified Object with this Vector for equality.
Object firstElement()Returns the first component (the item at index 0) of this vector.
Object get(int index)Returns the element at the specified position in this Vector.
int hashCode()Returns the hash code value for this Vector.
int indexOf(Object element)Returns the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element.
int indexOf(Object element, int index)Returns the index of the first occurrence of the specified element in this vector, searching forwards from index, or returns -1 if the element is not found.
void insertElementAt(Object obj, int index)Inserts the specified object as a component in this vector at the specified index.
boolean isEmpty()Tests if this vector has no components.
Iterator iterator()Returns an iterator over the elements in this list in proper sequence.
Object lastElement()Returns the last component of the vector.
int lastIndexOf(Object element)Returns the index of the last occurrence of the specified element in this vector, or -1 if this vector does not contain the element.
int lastIndexOf(Object element, int index)Returns the index of the last occurrence of the specified element in this vector, searching backwards from index, or returns -1 if the element is not found.
ListIterator listIterator()Returns a list iterator over the elements in this list (in proper sequence).
ListIterator listIterator(int index)Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
Object remove(int index)Removes the element at the specified position in this Vector.
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.
boolean removeAll(Collection c)Removes from this Vector all of its elements that are contained in the specified Collection.
void removeAllElements()Removes all components from this vector and sets its size to zero.
boolean removeElement(Object obj)Removes the first (lowest-indexed) occurrence of the argument from this vector.
void removeElementAt(int index)Deletes the component at the specified index.
protected void removeRange(int fromIndex, int toIndex)Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
boolean retainAll(Collection c)Retains only the elements in this Vector that are contained in the specified Collection.
Object set(int index, Object element)Replaces the element at the specified position in this Vector with the specified element.
void setElementAt(Object obj, int index)Sets the component at the specified index of this vector to be the specified object.
void setSize(int newSize)Sets the size of this vector.
int size()Returns the number of components in this vector.
List subList(int fromIndex, int toIndex)Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive.
Object[] toArray()Returns an array containing all of the elements in this Vector in the correct order.
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.
String toString()Returns a string representation of this Vector, containing the String representation of each element.
void trimToSize()Trims the capacity of this vector to be the vector's current size.

Vector
import java.util.Enumeration;
import java.util.Vector;

class VectorTest
{
    public static void main(String arg[])
    {
        // initial size is set to 3, increment is 2
        Vector v = new Vector(3, 2);
        System.out.println(" size: " + v.size()); // sixe method
        System.out.println("Initial capacity: " + v.capacity()); // capacity method
        
        v.add(1); // add method
        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: " + v.firstElement()); // first element method
        System.out.println("Last element: " + v.lastElement()); // last element method
        
        if (v.contains(new Integer(3))) // contains method
            System.out.println("Vector contains 3.");
        
        // enumerate the elements in the vector.
        Enumeration e = v.elements(); // Enumeration
        System.out.print("Elements in vector : ");
        while (e.hasMoreElements())
            System.out.print(e.nextElement() + " ");    
    }
}
OUTPUT

size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3.
Elements in vector : 1 2 3 4 5.45 6.08 7 9.4 10 11 12

DESCRIPTION

In this program, a Vector constructor is taken where the initial size is set to 3 and the increment of size 2 for every additional element. The size of vector is 0 because no element in inserted and capacity is 3 i.e. initial size set is 3. Four Integers are added, now the capacity becomes 5 i.e. initial 3 + increment 2, a double is added to vector the capacity remains same and again two elements are added then the capacity becomes 7 i.e. 5+2, and again two elements are added so capacity becomes 9 and again two elements are added to the vector. The first and last elements are retrieved and the existence of 3 elements checked and then vector is assigned to Enumeration and printed the vector elements.

THINGS TO TRY
  • Add element 8 in to the vector at index 8 by using add(int index, Object element).
  • Use the clone, clear, elementAt or get and hashCode methods to clone, clear, to get element at specified index and to get the hash code of the vector.
  • Apply equals, indexOf, isEmpty, lastIndexOf, remove, retain and set methods to vector.
VectorMethodsDemo
import java.util.*;

class VectorMethodsDemo
{
    public static void main(String arg[])
    {
        Vector<Integer> numbers = new Vector<Integer>();
        numbers.add(new Integer(1));
        numbers.add(new Integer(2));
        numbers.add(new Integer(3));
        numbers.add(new Integer(5));
        numbers.add(new Integer(6));
        System.out.println("Vector Elements : " + numbers); // LINE A
        System.out.println("Vector contains 3 : " + numbers.contains(new Integer(3))); // LINE B
        System.out.println("Vector contains 4 : " + numbers.contains(new Integer(4))); // LINE C
        ArrayList al = new ArrayList(); // LINE D
        al.add(3);
        al.add(5);
        System.out.println("numbers contains all elements of al : " +  numbers.containsAll(al));    // LINE E
        System.out.println("Index value of 3 is : " + numbers.indexOf(3));    // LINE F
        numbers.add(new Integer(4)); // 4 will be added at the end of the stack
        numbers.remove(new Integer(6));    // LINE G
        System.out.println("Modified Vector: " + numbers);
        numbers.clear();    // LINE H
        System.out.println("Vector Elements after clear method : " + numbers);    
    }
}
OUTPUT

Vector Elements : [1, 2, 3, 5, 6]
Vector contains 3 : true
Vector contains 4 : false
numbers contains all elements of al : true
Index value of 3 is : 2
Modified Vector: [1, 2, 3, 5, 4]
Vector Elements after clear method : []

DESCRIPTION

In the above program, At LINE A we are printing all the elements in the stack. At LINE B contains method is used to find 3 in the stack, the output is true, since 3 is present in the stack. But at LINE C the output is false, since 4 is not present in the stack. At LINE D empty ArrayList is created and elements are add to the list. At LINE E we are checking wheter all the elements al are present in the numbers Vector. At LINE F we are finding the index value of 3 using IndexOf method. At LINE G we are removing 6 from numbers using remove method. At LINE H we are clearing all the elements in the vector by using clear method.

THINGS TO TRY
  • Insert the below line of code above LINE A and see the output.
    numbers.insertElementAt(new Integer(3), 3);
    The output for the above line of code is :
    Vector Elements : [1, 2, 3, 3, 5, 6]
    Here the insertElementAt method inserts the specified object in the specified field.
  • Insert the below line of code after LINE E.
    numbers.removeAll(al);
    System.out.println("The modified Vector is : " + numbers);
    The output for the above code is :
    The modified Vector is : [1, 2, 6]
    Here, numbers.removeAll method removes all the elements of al from the vector numbers.

0
Wrong
Score more than 2 points

© meritcampus 2016 - 2017

All Rights Reserved.