Kotlin Vector

Vector is a wrapper over an array, where in the array can grow in size, or reduce in size dynamically, without the developer having to manage the size. Vector is part of Java Collections framework. We have access to Vector class in Kotlin through the Java Collections framework.

Vector is synchronized, so it is a thread safe construct to use. If thread safety is not of your requirement, it is advisable to use an ArrayList instead. If vector is tried to be modified concurrently, it will throw ConcurrentModificationException.

Vector implements the List interface. We can create a Vector by importing the class, java.util.Vector, and creating an instance of it. In the following example, we created a Vector of planets.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    println("Planets = " + planets)
}

Output:
Planets = [Mercury, Venus, Earth, Pluto]

We can find out the current capacity of the Vector by calling the capacity function. In the following example, we see that the Vector capacity is 10, even though we are only using it to store four planets.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    println("Vector capacity = " + planets.capacity())
}

Output:
Vector capacity = 10

We can use ensureCapacity function to set a capacity for the Vector. In the following example, we used ensureCapacity to increase the capacity to 100.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.ensureCapacity(100)
    println("Vector capacity = " + planets.capacity())
}

Output:
Vector capacity = 100

We can use addElement method to add element to the end of a Vector. In the following example, we used addElement method to add a brand new planet to our solar system.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.addElement("Sirius A3")
    println("Vector = " + planets)
}

Output:
Vector = [Mercury, Venus, Earth, Pluto, Sirius A3]

We can also use add method to add an element to end of a Vector. In the following example, we used add method to add a brand new planet to our solar system.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.addElement("Sirius A3")
    for(planet in planets)
    {
        println(planet);
    }
}

Output:
Mercury
Venus
Earth
Pluto
Sirius A3

We can iterate a vector using a for each loop. In the following example, we are iterating through the planets vector using for each loop.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth
Pluto

We can get the first element of a Vector using firstElement method. In the following example, we are retrieving the first planet from planets vector using firstElement method.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    var firstPlanet = planets.firstElement()
    println("First planet = " + firstPlanet)
}

Output:
First planet = Mercury

We can get the last element of a Vector using lastElement method. In the following example, we are retrieving the last planet from planets vector using lastElement method.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    var lastPlanet = planets.lastElement()
    println("Last planet = " + lastPlanet)
}

Output:
Last planet = Pluto

Adding elements to an existing Vector
We can use method addAll to add a list of elements to vector. In the following example, we are adding more planets to our vector of planets using addAll method.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.addAll(listOf("Jupiter", "Saturn"))
    for(planet in planets)
    {
        println(planet);
    }
}

Output:
Mercury
Venus
Earth
Pluto
Jupiter
Saturn

Adding element to middle of a Vector
We can use add method, specifying an index where to add the element followed by the element. This accomplishes adding element to that location. In the below example, we are using add method to insert Jupiter in between the Vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.add(2, "Jupiter");

    for(planet in planets)
    {
        println(planet);
    }
}

Output:
Mercury
Venus
Jupiter
Earth
Pluto

Checking for element in Vector
We can use contains method to check if Vector contains the element or not. In the below example, we are checking if Vector contains the planet Pluto.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    if(planets.contains("Pluto"))
    {
        println("Pluto is a Planet!")
    }
    else
    {
        println("Pluto is NOT a Planet!")
    }
}

Output:
Pluto is a Planet!

Removing element from Vector
We can use remove method to remove an element from Vector. In the below example, we are removing the planet Pluto from the Vector of planets.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.remove("Pluto")

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth

What will happen if the element we try to remove is not present in the Vector? Nothing, it just does not remove anything. In the below example, we are trying to remove Jupiter from vector of planets, even though Jupiter is not present in the vector of planets.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.remove("Jupiter")

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth
Pluto

We can remove list of planets altogether using removeAll method. We just need to pass collection of planets to remove. In the below example, we using removeAll method to remove Earth and Pluto from the vector of planets.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.removeAll(listOf("Earth", "Pluto"))

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus

We can remove an element at a particular index using removeAt method. In the following example, we are using removeAt method to remove the second element from the planet vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.removeAt(2)

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Pluto

We can remove elements if a certain condition is met, using a predicate filter. For this Kotlin provides removeIf function. In the below example, we check for the condition of planet name starts with E, and only those planets we remove from the vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.removeIf { x -> x.startsWith("E") }

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Pluto

Reversing a Vector
We can reverse the elements in place for the Vector using reverse function. In the below example, we are reversing the planets vector and printing the vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.reverse()

    for(planet in planets)
    {
        println(planet)
    }
}

Output:
Pluto
Earth
Venus
Mercury

If we don't want to touch the original vector and we would like to reverse the list into another vector instead, we can use reversed function. In the following example we are reversing the vector and collecting the result into another vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    var planetsReversed = planets.reversed()

    println("Original Planets = ")
    for(planet in planets)
    {
        println(planet)
    }

    println("\n\nPlanets Reversed = ")
    for(planet in planetsReversed)
    {
        println(planet)
    }
}

Output:
Original Planets =
Mercury
Venus
Earth
Pluto

Planets Reversed =
Pluto
Earth
Venus
Mercury

Clearing a Vector
We can clear the contents of vector using clear function. In the following example, we are using the clear function to clear the contents of the vector. We also demonstrate a property of vector called size. size property can be used to find out the number of elements in the vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    planets.clear()

    for(planet in planets)
    {
        println(planet)
    }
    println("Size of vector = " + planets.size)
}

Output:
Size of vector = 0

Count of elements in Vector
We can get the count of elements in vector using count function. In the below example, we are using the count function to get the count for the number of planets in the vector.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    println("Count of elements in vector = " + planets.count())
}

Output:
Count of elements in vector = 4

We can also pass a predicate filter to count function, if we want to get count based on some condition. In the following example, we are counting the number of planets that start with the letter E.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Pluto"))

    var numOfPlanetsStartingWithE = planets.count { x -> x.startsWith("E") }

    println("Count of planets starting with E in vector = " + numOfPlanetsStartingWithE)
}

Output:
Count of planets starting with E in vector = 1

Remove duplicates from Vector
We can remove duplicate elements from vector and get a new List, using distinct function. In the below example, we have some duplicate entries in our planets vector. We then used distinct function call to get a new list without the duplicates.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Earth", "Venus", "Pluto"))
    var uniquePlanets = planets.distinct()

    for(planet in uniquePlanets)
    {
        println(planet)
    }
}

Output:
Mercury
Venus
Earth
Pluto

Check if Vector is empty
We can check for emptiness of an vector using isEmpty function. In the following example, we check if vector of planets is empty or not and print a message accordingly.

import java.util.Vector

fun main(args: Array<String>)
{
    var planets =  Vector<String>();
    planets.addAll(listOf("Mercury", "Venus", "Earth", "Earth", "Venus", "Pluto"))

    planets.clear()

    if(planets.isEmpty())
    {
        println("Planets vector is empty!")
    }
    else
    {
        println("Planets vector is NOT Empty!")
    }
}

Output:
Planets vector is empty!

Maximum value in Vector
We can use the max function on vector to find the maximum element. In the below example, we used max function to determine the highest integer in our vector.

package com.cosmiclearn.test

import java.util.Vector

fun main(args: Array<String>)
{
    var numbers =  Vector<Int>();
    numbers.addAll(listOf(21, 44, 99, 74, 33))

    var maxValue = numbers.max()
    println("Vector Max value = " + maxValue)
}

Output:
Vector Max value = 99

Minimum value in Vector
We can use the min function on vector to find the minimum element. In the below example, we used min function to determine the smallest integer in our vector.

package com.cosmiclearn.test

import java.util.Vector

fun main(args: Array<String>)
{
    var numbers =  Vector<Int>();
    numbers.addAll(listOf(21, 44, 99, 74, 33))

    var maxValue = numbers.min()
    println("Vector Min value = " + maxValue)
}

Output:
Vector Min value = 21

Retrieve data from Vector
We can use the get function to get value at a given index. In the following example, we used get function to retrieve the value at position 2 of the Vector.

package com.cosmiclearn.test

import java.util.Vector

fun main(args: Array<String>)
{
    var numbers =  Vector<Int>();
    numbers.addAll(listOf(21, 44, 99, 74, 33))

    var value = numbers.get(2)
    println("value = " + value)
}

Output:
value = 99

Instead of get, we can use indexing operator [] to get value at a given index. In the following example, we used indexing operator to get the value at position 2 of the vector.

package com.cosmiclearn.test

import java.util.Vector

fun main(args: Array<String>)
{
    var numbers =  Vector<Int>();
    numbers.addAll(listOf(21, 44, 99, 74, 33))

    var value = numbers[2]
    println("value = " + value)
}

Output:
value = 99

We can use indexOf function to get the index position of a particular element. In the following example, we used indexOf to get the index position for 99.

package com.cosmiclearn.test

import java.util.Vector

fun main(args: Array<String>)
{
    var numbers =  Vector<Int>();
    numbers.addAll(listOf(21, 44, 99, 74, 33))

    var value = numbers.indexOf(99)
    println("value = " + value)
}

Output:
value = 2