Clase vectorial en Java

La clase Vector implementa una array creciente de objetos. Los vectores pertenecen a las clases heredadas, pero ahora son totalmente compatibles con las colecciones. Se encuentra en el paquete java.util e implementa la interfaz List , por lo que podemos usar todos los métodos de la interfaz List como se muestra a continuación:

• Vector implementa una array dinámica, lo que significa que puede crecer o reducirse según sea necesario. Al igual que una array, contiene componentes a los que se puede acceder mediante un índice entero.
• Son muy similares a ArrayList , pero Vector está sincronizado y tiene algunos métodos heredados que el marco de la colección no contiene.
• También mantiene un orden de inserción como un ArrayList. Aún así, rara vez se usa en un entorno sin subprocesos, ya que está sincronizado y, debido a esto, ofrece un rendimiento deficiente al agregar, buscar, eliminar y actualizar sus elementos.
• Los iteradores devueltos por la clase Vector son a prueba de fallas. En el caso de una modificación concurrente, falla y lanza la excepción ConcurrentModificationException.

Sintaxis: 

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

Aquí, E es el tipo de elemento.

• Extiende AbstractList e implementa interfaces de lista .
• Implementa interfaces Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess.
• La subclase directamente conocida es Stack .

Los puntos importantes con respecto al Incremento de la capacidad del vector son los siguientes:

Si se especifica el incremento, Vector se expandirá de acuerdo con él en cada ciclo de asignación. Aún así, si no se especifica el incremento, la capacidad del vector se duplica en cada ciclo de asignación. Vector define tres miembros de datos protegidos:

• int capacityIncreament: contiene el valor del incremento.
• int elementCount: Número de elementos actualmente en el vector almacenados en él.
• Objeto elementData[]: la array que contiene el vector se almacena en él.

Los errores comunes en la declaración de vectores son los siguientes :

• Vector lanza una IllegalArgumentException si el InitialSize del vector definido es negativo.
• Si la colección especificada es nula, lanza NullPointerException . 

Constructores

1. Vector(): crea un vector predeterminado de la capacidad inicial es 10.

Vector<E> v = new Vector<E>();

2. Vector (tamaño int): crea un vector cuya capacidad inicial se especifica por tamaño.

Vector<E> v = new Vector<E>(int size);

3. Vector (tamaño int, incremento int): crea un vector cuya capacidad inicial se especifica por tamaño y el incremento se especifica por incremento. Especifica el número de elementos a asignar cada vez que se redimensiona un vector hacia arriba.

Vector<E> v = new Vector<E>(int size, int incr);

4. Vector(Colección c): Crea un vector que contiene los elementos de la colección c.

vector

Vector<E> v = new Vector<E>(Collection c);

Métodos en clase vectorial

Primero discutamos e implementemos cómo crear y usar un vector antes de aterrizar en los métodos de esta clase.

Ejemplo:

// Java Program to Demonstrate Working of Vector
// Via Creating and Using It
  
// Importing required classes
import java.io.*;
import java.util.*;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
        // Size of the Vector
        int n = 5;
  
        // Declaring the Vector with
        // initial size n
        Vector<Integer> v = new Vector<Integer>(n);
  
        // Appending new elements at
        // the end of the vector
        for (int i = 1; i <= n; i++)
            v.add(i);
  
        // Printing elements
        System.out.println(v);
  
        // Remove element at index 3
        v.remove(3);
  
        // Displaying the vector
        // after deletion
        System.out.println(v);
  
        // iterating over vector elements
        // using for loop
        for (int i = 0; i < v.size(); i++)
  
            // Printing elements one by one
            System.out.print(v.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

Nota:

• Si no se especifica el incremento del vector, su capacidad se duplicará en cada ciclo de incremento.
• La capacidad de un vector no puede ser inferior al tamaño, puede ser igual a él.

Realización de varias operaciones en la clase Vector en Java

Analicemos varias operaciones en la clase Vector que se enumeran a continuación:

1. Agregar elementos
2. Actualización de elementos
3. Quitar elementos
4. Iterando sobre elementos

Operación 1: Adición de elementos

Para agregar los elementos al Vector, usamos el método add() . Este método está sobrecargado para realizar múltiples operaciones basadas en diferentes parámetros. Se enumeran a continuación de la siguiente manera:

• add(Object): Este método se usa para agregar un elemento al final del Vector.
• add(int index, Object): Este método se usa para agregar un elemento en un índice específico en el Vector.

Ejemplo:

// Java Program to Add Elements in Vector Class
  
// Importing required classes
import java.io.*;
import java.util.*;
  
// Main class
// AddElementsToVector
class GFG {
  
    // Main driver method
    public static void main(String[] arg)
    {
  
        // Case 1
        // Creating a default vector
        Vector v1 = new Vector();
  
        // Adding custom elements
        // using add() method
        v1.add(1);
        v1.add(2);
        v1.add("geeks");
        v1.add("forGeeks");
        v1.add(3);
  
        // Printing the vector elements to the console
        System.out.println("Vector v1 is " + v1);
  
        // Case 2
        // Creating generic vector
        Vector<Integer> v2 = new Vector<Integer>();
  
        // Adding custom elements
        // using add() method
        v2.add(1);
        v2.add(2);
        v2.add(3);
  
        // Printing the vector elements to the console
        System.out.println("Vector v2 is " + v2);
    }
}

 Producción:

Vector v1 is [1, 2, geeks, forGeeks, 3]
Vector v2 is [1, 2, 3]

Operación 2: Actualización de Elementos

Después de agregar los elementos, si deseamos cambiar el elemento, se puede hacer usando el método set() . Dado que un Vector está indexado, el elemento que deseamos cambiar está referenciado por el índice del elemento. Por lo tanto, este método toma un índice y el elemento actualizado para insertarlo en ese índice.

Ejemplo

// Java code to change the
// elements in vector class
  
import java.util.*; 
  
public class UpdatingVector { 
    
    public static void main(String args[]) 
    { 
        // Creating an empty Vector 
        Vector<Integer> vec_tor = new Vector<Integer>(); 
  
        // Use add() method to add elements in the vector 
        vec_tor.add(12); 
        vec_tor.add(23); 
        vec_tor.add(22); 
        vec_tor.add(10); 
        vec_tor.add(20); 
  
        // Displaying the Vector 
        System.out.println("Vector: " + vec_tor); 
  
        // Using set() method to replace 12 with 21 
        System.out.println("The Object that is replaced is: "
                        + vec_tor.set(0, 21)); 
  
        // Using set() method to replace 20 with 50 
        System.out.println("The Object that is replaced is: "
                        + vec_tor.set(4, 50)); 
  
        // Displaying the modified vector 
        System.out.println("The new Vector is:" + vec_tor); 
    } 
} 

Vector: [12, 23, 22, 10, 20]
The Object that is replaced is: 12
The Object that is replaced is: 20
The new Vector is:[21, 23, 22, 10, 50]

Operación 3: Eliminación de elementos

Para eliminar un elemento de un vector, podemos usar el método remove() . Este método está sobrecargado para realizar múltiples operaciones basadas en diferentes parámetros. Están:

• remove(Object): Este método se utiliza para eliminar un objeto del Vector. Si hay varios de estos objetos, se elimina la primera aparición del objeto.
• remove(int index): dado que un vector está indexado, este método toma un valor entero que simplemente elimina el elemento presente en ese índice específico en el vector. Después de eliminar el elemento, todos los elementos se mueven hacia la izquierda para llenar el espacio y se actualizan los índices de los objetos.

Ejemplo

// Java code illustrating the removal
// of elements from vector
  
import java.util.*;
import java.io.*;
  
class RemovingElementsFromVector {
    
    public static void main(String[] arg)
    {
  
        // create default vector of capacity 10
        Vector v = new Vector();
  
          // Add elements using add() method
        v.add(1);
        v.add(2);
        v.add("Geeks");
        v.add("forGeeks");
        v.add(4);
  
        // removing first occurrence element at 1
        v.remove(1);
  
        // checking vector
        System.out.println("after removal: " + v);
    }
}

 Producción:

after removal: [1, Geeks, forGeeks, 4]

Operación 4: iterando el vector

Hay varias formas de iterar a través del Vector. Las formas más famosas son usar el bucle for básico en combinación con un método get() para obtener el elemento en un índice específico y el bucle for avanzado .

Ejemplo

// Java program to iterate the elements
// in a Vector
  
import java.util.*;
  
public class IteratingVector {
  
    public static void main(String args[])
    {
          // create an instance of vector
        Vector<String> v = new Vector<>();
  
          // Add elements using add() method
        v.add("Geeks");
        v.add("Geeks");
        v.add(1, "For");
  
        // Using the Get method and the
        // for loop
        for (int i = 0; i < v.size(); i++) {
  
            System.out.print(v.get(i) + " ");
        }
  
        System.out.println();
  
        // Using the for each loop
        for (String str : v)
            System.out.print(str + " ");
    }
}

Geeks For Geeks 
Geeks For Geeks

Nota: Lea la clase ArrayList vs Vector en Java para comprenderlo mejor.

Este artículo es una contribución de Abhishek Verma . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. 

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.