Vector in Java

Vector in Java

Introduction

Vectors in Java uses data in a linear fashion like Array. But it implements a dynamic array that can grow or shrink as and when required to accommodate adding and removing data item. In the Java 2 SDK, the Vector class has been included in the Collection framework to implement the List interface and it comes under the java.util package. The Vector class is favored over the ArrayList class when we are creating a multi-threaded application.

• The Vector class is similar to ArrayList class but Vector is synchronized(the main facet of Vector class is that it is thread-safety. ).
• The Vector class is created dynamic Array which can grow and shrink.
• Vector class is a child class of AbstractList class and implements on List interface
• Duplicate element/objects are allowed in Vector
• Insertion order is maintained
• It allows NULL insertion
• Vectors don’t support primitives data types like short, int, double, char, etc.

Advantages of Vector in Java

1. Due to its Dynamic size, memory wastage is not happening.
2. Vector class is synchronized and it helps in the multithreaded program and helps to check data corruption.
3. Vectors have some legacy methods which can be implemented only on vector class and not on the ArrayLists class.

Note: The Vector class may reduce the performance of the developed application as it is thread safety and it only allowed one thread as it locked the thread and the remaining thread have to wait until a thread released the object lock. So it is recommended that if we do not need thread safety, then we should use the ArrayList class instead of Vector class.  

The Vector class defines the following constructors

public Vector() This a constructor creates an empty vector and its initial data array size is 10

public Vector(int n) This A constructor creates an empty vector with specified size n.

Vector (int initSize, int incrSize) This form of constructor creates an empty vector with its initial and increment capacity.

Vector (Collection c) This a constructor creates a vector containing the elements of the specified collection c.

Apart from the above constructor's Vector define three protected data member which are as follows

protected int capacity increment

This data member of the vector is automatically incremented when its size becomes greater than its capacity.

 protected int  elementCount

The number of valid elements in the vector.

protected int elementData[]

The array holds the elements of the vector.

Exmpale

import java.util.*;

public class TheVectorClassExample

{

    public static void main(String args[]) { 

    

        Vector<String> student = new Vector<String>(4); 

        //Adding elements to a student Vector

        student.add("Zainab"); 

        student.add("Sachin");

        student.add("Junaid"); 

        student.add("Salim"); 

        student.add("Ashis"); 

        student.add("Deva"); 

        student.add("Danny"); 

        //Checking the size and capacity of Vector

        System.out.println("The Size of Vector is: "+student.size()); 

        System.out.println("Default capacity is: "+student.capacity()); 

        //Display Vector elements 

        System.out.println("Vector element is: "+student); 

        student.addElement("Rat"); 

        student.addElement("Cat"); 

        student.addElement("Deer"); 

        //Again check size and capacity after two insertions 

        System.out.println("Size after addition: "+student.size()); 

        System.out.println("Capacity after addition is: "+student.capacity()); 

        //Display Vector elements again 

        System.out.println("Elements are: "+student); 

        //Checking if Tiger is present or not in this student or         

        if(student.contains("Tiger")) 

        { 

            System.out.println("Tiger is present at the index " +student.indexOf("Tiger")); 

        } 

        else 

        { 

            System.out.println("Tiger is not present in the list."); 

        } 

        //Get the first element 

        System.out.println("The first animal of the studenttor is = "+student.firstElement());  

        //Get the last element 

        System.out.println("The last animal of the studenttor is = "+student.lastElement());  

        // Using Enumeration

        Enumeration en = student.elements();

        System.out.println("\nStudent are:");

        while(en.hasMoreElements())

            System.out.print(en.nextElement() + " ");

    } 

}

How to copy a Vector into an Array?

import java.util.*;

public class Vector2JavaArray

{

    public static void main(String[] args) {

 

        // Vector class object

        Vector<String> vector = new Vector<String>();

        vector.add("Aman");

        vector.add("Bimal");

        vector.add("Jamil");

        vector.add("Sachin");

        vector.add("Vikas");

        System.out.println("Actual vector elements:" + vector);

        

        // Create an Array 

        String[] copyArray = new String[vector.size()];

        

        // Here we use copyInto Method to copy 

        vector.copyInto(copyArray);

        

        System.out.println("Copied Array as OUTPUT:");

        for (String name : copyArray) 

        {

            System.out.println(name);

        }

    }

}

Sample output

Actual vector elements:[Aman, Bimal, Jamil, Sachin, Vikas]

Copied Array as OUTPUT:

Aman

Bimal

Jamil

Sachin

Vikas

More Articles

Linked List in Java

ArrayList in Java

Read More

• Share

Java Access Modifiers

Java Access Modifiers

Java Access Modifiers

In this tutorial, I’ll describe how Java access modifiers work in detail. They manage the visibility and their members (methods and data). There are three Java access modifiers public, private, and protected. There is another modifier namely default which is implemented by default.

Java Access Modifiers Explained With Examples

Access Modifier	within class	within package	outside package by subclass only	outside package	Outside Class
Public	Y	Y	Y	Y	Y
Protected	Y	Y	Y	Y	N
Private	Y	N	N	N	N
Default	Y	Y	Y	N	N

Access Modifier

within class

within package

outside package by subclass only

outside package

Outside Class

Public

Y

Y

Y

Y

Y

Protected

Y

Y

Y

Y

N

Private

Y

N

N

N

N

Default

Y

Y

Y

N

N

Public Access Modifier

The accessibility of this modifier visible everywhere. We can say that public modifier doesn’t put any restriction on the access. This indicate that any public class, method, variable, interface, or constructor is accessible throughout the package. But if it belongs to another package then we need to import it. It has a broad scope among all other modifiers. The public access modifier can be useful to classes and interfaces along with methods, data members and variables.

Example of public modifier

public class FirstClass

{

    public void display()

    {

        System.out.println("I am Public Modifier");

    }

}

public class SecondClass

{

   public static void main()

   {

       FirstClass ob = new FirstClass();

       ob.display();

    }

       

}

Output:

I am Public Modifier

Here, in SecondClass, we can instantiate the FirstClass because its access modifier is public. The variables and methods inside the SecondClass class are also public. Hence, you are able to use it directly in your L SecondClass.

Private Access Modifier

This modifier can access Data members, methods and constructors within the class.             We cannot develop subclasses to that class which has only private constructors. Classes or interface cannot be declared as private because private modifier will make the class useless.

public class PrivateExampleBase

{

   private void display()

    {

        System.out.println("I am Private Modifier");

    }

}

In PrivateExampleBase display() method declare as private and when we called display() method from PrivateExampleDrive then it will generate error “display() has private access in PrivateExampleBase”

public class PrivateExampleDrive

{

   public static void main()

   {

       PrivateExampleBase ob = new PrivateExampleBase();

       ob.display();

    }

}

Another Example: This program is used to show that private members of a class can be accessed in the class only

class StudentClass {

    //private members of the class

    private int rollNo; // define as a private modifier

    private void show() {

        rollNo = 10;

       

        System.out.println("RollNo = " + rollNo);

    }

}

public class PrivateDataMember {

    public static void main(String args[]) {

        //creating StudentClass object

        StudentClass ob = new StudentClass();

        System.out.println(ob.rollNo);

        ob.show();

    }

}

In PrivateDataMember class we will try ti access private data member(rollNo) and also try to access show() method. But it will not be accessecible as it is define as private. And it'll display error as "Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - rollNo has private access in MyFirstApp.StudentClass

            at MyFirstApp.PrivateDataMember.main(PrivateDataMember.java:15)"

Note: Private constructor cannot able to create an instance in another class.

Protected Access Modifier

The protected access modifier methods or data members are accessible within the same package or subclasses in a different package. We cannot declared protected in the classes because it used in the parent-child relationship. But the protected access modifier can be used on the data member, method and constructor.

package MyFirstApp;

class StudentClass {

    //protected members of the class

    protected int rollNo;

    protected void show()

    {

        rollNo = 10;

        System.out.println("RollNo = " + rollNo);

    }

}

public class ProtectedDataMember {

    public static void main(String args[]) {

        //creating Student class object

        StudentClass ob = new StudentClass();

        ob.show();

    }

}

Default Access Modifier

If we don’t mention any access modifier for a class, method or data member then we can say it is a default modifier. It can be accessed into all classes within the same package only. The default access modifier is also sometimes known as the package access modifier.

import java.util.Scanner;

public class Palindrom {

    int n, rev, m, a; // default access modifier

    void input() // this method contain no modifier

    {

        Scanner sc = new Scanner(System.in);

        System.out.println("Enter a number:");

        n = sc.nextInt();

        m = n;

    }

    void palin() // this method contain no modifier

    {

        rev = 0;

        while (m != 0) {

            a = m % 10;

            rev = rev * 10 + a;

            m /= 10;

        }

        if (rev == n) {

            System.out.println("Palindrom");

        } else {

            System.out.println("Not Palindrom");

        }

    }

    public static void main(String[] args) {

        Palindrom ob = new Palindrom();

        ob.input();

        ob.palin();

    }

}

More Tutorials

Linked List in Java

ArrayList in Java

Basic Features of java

Read More

• Share