Vector is a linear data structure also known as growable arrays. Vectors have the ability to resize themselves automatically when an element is inserted or deleted. In vectors, data is inserted at the end. They are very similar to ArrayList but Vector is synchronized and has some legacy methods that the collection framework does not contain.
Declaration
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
Here, E is the type of element.
Vector API implements Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
Java
// Java program to implement Vector APIimport java.util.*; public class VectorImplement<E> { private Vector<E> vector; // Constructor to create an empty vector(internal array // has size 10) public VectorImplement() { vector = new Vector<E>(); } // Constructor to create a vector with it's element // as specified in given collection public VectorImplement(Collection<? extends E> c) { vector = new Vector<E>(c); } // Constructor to create an empty vector with the given // initial capacity . public VectorImplement(int initialCapacity) { vector = new Vector<E>(initialCapacity); } // Constructor to create an empty vector with the given // initial capacity and capacity increment. public VectorImplement(int initialCapacity, int capacityIncrement) { vector = new Vector<E>(initialCapacity, capacityIncrement); } // method to append a specified element to the Vector. public boolean add(E e) { return vector.add(e); } // method to insert a given element at the specified // position in the Vector. public void add(int index, E element) { vector.add(index, element); } // method to append all of the elements to the Vector. public boolean addAll(Collection<? extends E> c) { return vector.addAll(c); } // method to insert all of the elements of a Collection // at a specified position. public boolean addAll(int index, Collection<? extends E> c) { return vector.addAll(index, c); } // method to append specific element to the vector.Size // of vector increases by 1. public void addElement(E obj) { vector.addElement(obj); } // method to returns the current capacity of vector. public int capacity() { return vector.capacity(); } // method to remove all of the elements of the Vector. public void clear() { vector.clear(); } // method to return a clone of this vector. public Object clone() { return vector.clone(); } // method to check vector contains a specific element. public boolean contains(Object o) { return vector.contains(o); } // method to return true if Vector contains all of the // elements in the specified Collection. public boolean containsAll(Collection<?> c) { return vector.containsAll(c); } // method to Copy the elements of this vector into a // specific array. public void copyInto(Object[] anArray) { vector.copyInto(anArray); } // method to return the element at the specified index. // **/ public E elementAt(int index) { return vector.elementAt(index); } // method to return an enumeration of the element of the // vector. **/ public Enumeration<E> elements() { return vector.elements(); } // method to increase the capacity of this vector to a // minimum capacity. public void ensureCapacity(int minCapacity) { vector.ensureCapacity(minCapacity); } // method to compare a specified elements with this // Vector for equality. public boolean equals(Object o) { return vector.equals(o); } // method to return the first element of the vector public E firstElement() { return vector.firstElement(); } // method to return the element at the specified index // in the Vector. public E get(int index) { return vector.get(index); } // method to return the hash code value for the Vector public int hashCode() { return vector.hashCode(); } // method to return the index of the first occurrence of // the specified element in // this vector, or -1 if the vector does not contain the // specified element. public int indexOf(Object obj) { return vector.indexOf(obj); } // method to return the index of the last occurrence of // a specific element in this // vector, searching backwards from index, or returns // -1 if the element is not found. public int indexOf(Object obj, int index) { return vector.indexOf(obj, index); } // method to insert a specified object at a specified // index public void insertElementAt(E obj, int index) { vector.insertElementAt(obj, index); } // method to test if the vector has no elements. public boolean isEmpty() { return vector.isEmpty(); } // method to return an iterator over the elements in // this list in proper sequence. public Iterator<E> iterator() { return vector.iterator(); } // method to return the last element of the vector. public E lastElement() { return vector.lastElement(); } // method to return the index of the last occurrence of // the specific element in the vector, else return -1 if // the vector does not contain the element. public int lastIndexOf(Object o) { return vector.lastIndexOf(o); } // method to return the index of the last occurrence of // a specific element in the vector, searching backwards // from index, else returns -1 if the element is not // found. public int lastIndexOf(Object o, int index) { return vector.lastIndexOf(o, index); } // method to return a list iterator over the elements in // this list. public ListIterator<E> listIterator() { return vector.listIterator(); } // method to return a list iterator over the elements in // this list starting at the specific position in the // list. public ListIterator<E> listIterator(int index) { return vector.listIterator(index); } // method to remove the element at the specified // position in the Vector. public E remove(int index) { return vector.remove(index); } // method to remove the first occurrence of a specific // element in the Vector. public boolean remove(Object o) { return vector.remove(o); } // method to remove from this Vector all of its elements // that are contained in the specified Collection. public boolean removeAll(Collection<?> c) { return vector.removeAll(c); } // removes all elements from the vector and set size=0. public void removeAllElements() { vector.removeAllElements(); } // method to remove the first occurrence of the element // from the vector. **/ public boolean removeElement(Object obj) { return vector.removeElement(obj); } // method to retain only the elements in Vector that // are contained in specified Collection. public boolean retainAll(Collection<?> c) { return vector.removeAll(c); } // method to replace the element at the specified // position in the Vector with another specified element. public E set(int index, E element) { return vector.set(index, element); } // method to set the element at the specified index of // vector public void setElementAt(E obj, int index) { vector.setElementAt(obj, index); } // method to set the size of vector public void setSize(int newSize) { vector.setSize(newSize); } // method to returns size of vector public int size() { return vector.size(); } // method to return a sub-vector between // fromIndex(inclusive) and toIndex(exclusive). public List<E> subList(int fromIndex, int toIndex) { return vector.subList(fromIndex, toIndex); } // method to trim the capacity to the vector current // size public void trimToSize() { vector.trimToSize(); } public static void main(String[] arg) { // creating a object of VectorImplement class VectorImplement<String> vector = new VectorImplement<String>(); // adding elements to vector vector.add("one"); vector.add("three"); vector.add("five"); vector.add("ten"); vector.addElement("seven"); vector.addElement("six"); // printing the capacity of vector System.out.println("The capacity of the vector is " + vector.capacity()); // printing the elements of vector System.out.println("Elements of vector is "); Enumeration<String> elements = vector.elements(); while (elements.hasMoreElements()) { System.out.print(elements.nextElement() + "\t"); } System.out.println(); // checking if vector contains a specific element System.out.println( "checking if vector contains element - ten"); if (vector.contains("ten") == true) { System.out.print( "The vector contains element ten"); } else { System.out.print( "The vector does not contains element ten"); } System.out.println(); // printing first element of vector System.out.println("The first element of vector is " + vector.firstElement()); // printing first element of vector System.out.println("The last element of vector is " + vector.lastElement()); // removing an element from the vector System.out.println("Removing element ten" + vector.remove("ten")); // printing vector size System.out.println("The size of the vector is " + vector.size()); }} |
Output
The capacity of the vector is 10 Elements of vector is one three five ten seven six checking if vector contains element - ten The vector contains element ten The first element of vector is one The last element of vector is six Removing element tentrue The size of the vector is 5
