4. Vector

[Dhanrajpatil123]

Vector

• A vector in Java is a part of the java.util. package and is one of the legacy classes in java that implements the list interface.
• It was introduce in JDK 1.0 before collection framework and is synchronized, making it thread-safe.
• Now it is a part of collection framework.

• However, due it's synchronization overhead, it's generally recommended to use other modern alternatives like ArrayList in single-threaded scenarios. Despite this, Vector is still useful in certain situations, particularly in multi-threaded environments where thread safety is a concern.

Key Features of Vector

---

• Dynamic Array : like ArrayList, Vector is a dynamic array that grows automatically when more elements are added than it's current capacity.
• Synchronized : All the methods in vector are synchronized, which makes it thread-safe. This means multiple thread can work on a vector without the risk of corrupting the data. However, this can introduce performance overhead in single-thread environment.
• Legacy classes : Vector was [art of java's original release and is considered a legacy class. It's generally recommended to use ArrayList in single-threaded environment due to performance consideration.
• Resizing Mechanism : When the current capacity of vector is exceeded, it double it's size by default ( or increase by a specified capacity increment if provided).
• Random Access : Similar to array and ArrayList, Vector allows random access to elements, making it efficient for accessing elements using an index.

Constructor Of Vector

---

• Vector() : creates a vector with an initial capacity of 10.
• Vector(int initialCapacity) : Creates a vector with a specified initial capacity.
• Vector(int initialCapacity, int capacityIncrement) : Creates a vector with an initial capacity and capacity increment ( how muc the vector should grow when it's capacity is exceeded.)
• Vector(Collection<? extends E? c ) : Creates a vector containing the elements of the specified collections.

[Dhanrajpatil123]

Constructor of Vector Practical

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Vector;

public class VariableDataTypeEx {

    public static void main(String[] args) {

        Vector<Integer> vector1 = new Vector<>();
        System.out.println(vector1.capacity());

        Vector<Integer> vector2 = new Vector<>(15);    // custom initial capacity
        System.out.println(vector2.capacity());

        Vector<Integer> vector3 = new Vector<>(5, 3);  // custom capacity increment
        System.out.println(vector3.capacity());
        vector3.add(10);
        vector3.add(10);
        vector3.add(10);
        vector3.add(10);
        vector3.add(10);
        System.out.println(vector3.capacity());
        vector3.add(10);
        System.out.println(vector3.capacity());

        // 1
        Vector<Integer> vector = new Vector<>(Arrays.asList(1, 2, 3, 4, 5));

        // 2
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(1);
        list.add(1);

        Vector<Integer> vector4 = new Vector<>(list);

        System.out.println(vector4);

    }
}

[Dhanrajpatil123]

Methods in Vector

1. add ( E e ) : adds an element at the end.
2. add ( int index, E e ) : insert an element at the specified index.
3. get ( int index ) : retrieves the element at the specified index.
4. set ( int index, E e ) : Replace the element at the specified index.
5. remove ( Object o) : remove the first occurrence of the specified element.
6. remove ( int index ) : remove the element at specified index.
7. size ( ) : returns the number of elements in the vector.
8. isEmpty () : checks if the vector is empty.
9. contains (Object o ) : check if the vector contains the specified element.
10. Clear() : removes all elements from the vector.

[Dhanrajpatil123]

    public static void main(String[] args) {

        Vector<Integer> vector = new Vector<>(5, 3);
        vector.add(10);
        vector.add(20);
        vector.add(30);
        vector.add(40);
        vector.add(50);

        vector.add(1, 200);  //   10, 20, 10, 10, 10, 10

        for (int i = 0; i < vector.size(); i++) {
            System.out.println(vector.get(i));
        }

        System.out.println(vector.get(1));  // 200

        vector.set(2, 30);    // 10, 200, 30, 30, 40, 50

        vector.remove(1);     //  10, 30, 30, 40, 50

        vector.remove(vector.get(3));    // 10, 30, 30, 50

        System.out.println(vector);

        System.out.println(vector.contains(10));   // true

        System.out.println(vector.contains(100));   // false

        System.out.println(vector.isEmpty());   // false

        vector.clear();

        System.out.println(vector.isEmpty());   // true

    }

[Dhanrajpatil123]

Internal Implementation of Vector

---

• Internally, vector uses an array to store it's elements.
• The size of this array grows as needed when more elements are added.
• The default behavior it to double the size of the array when it runs out of the space.

• This resizing operation is a costly one, as it requires copying the old elements to the new, larger array.

Synchronization and performance

• since vector methods are synchronized, it ensures that only one thread can access the vector at a time.
• This makes it thread-safe but can introduce performance overhead in single-threaded environments because synchronization adds locking and unlocking costs.
• In modern java applications, ArrayList is generally preffered over vector when synchronization is not required.
• For thread safe collections, the CopyOnWriteArrayList or ConcurrentHashMap from the java.util.concurrent package is often recommended instead.

[Dhanrajpatil123]

Summary

1. Vector is a legacy synchronized collection class that implements the List interface.
2. It behaves like a dynamic array and grows as needed.
3. It provides thread safety but with a performance cost in single-threaded environment.
4. In modern applications, Arraylist or concurrent alternatives like CopyOnWriteArrayList are typically preffered overr vector unless thread safety is priority.

[Dhanrajpatil123]

ArrayList Not Thread Safe

public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        });

        t1.start();
        t2.start();

        try{
            t1.join();
            t2.join();
        }
        catch (InterruptedException e){
        }

        System.out.println(list.size());     // size can be any thing as per the elements can store 

    }

If you want the exact size and store all elements then always prefer vector

public static void main(String[] args) {

        Vector<Integer> list = new Vector<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
        });

        t1.start();
        t2.start();

        try{
            t1.join();
            t2.join();
        }
        catch (InterruptedException e){
        }

        System.out.println(list.size());   // size - > 2000

    }