Clase Vector en Java

La clase Vector en Java pertenece al paquete java.util, y nos permite almacenar secuencias de datos del mismo tipo, tipo que definimos en el momento de inicializar el vector.

Se encuadra dentro de los datos avanzados de este lenguaje e implementa una matriz que crece de forma automática y contiene elementos a los cuales se puede acceder mediante un índice entero.

Podemos añadir, eliminar e insertar en una posición determinada los elementos.

Similares a los array en su función, pero con la ventaja de no estar obligado a determinar su tamaño, se adaptan fácilmente a la cantidad de elementos que tengamos.

¿Cómo crear un vector en Java?

Para utilizar un vector en nuestro programa no debemos olvidar incluir en la primera línea del mismo la importación de la librería:

import java.util.Vector;

Luego procederemos a crearlo de la misma forma que creamos cualquier otro objeto, con el operador new:

Vector < Integer > mivector = new Vector(20, 5);

Nótese que entre paréntesis hay 2 valores, el primero es la capacidad (initialCapacity) inicial del vector, definido por nosotros, el segundo es el incremento que tendrá (capacityIncrement), cuando llenemos los primeros 20 espacios o referencias.

La función que cumple cada cual es la siguiente:

• initialCapacity, es la cantidad de elementos máximos que puede guardar el vector
• capaciytIncrement, es la cantidad de espacios que añadirá automáticamente el vector, cuando ocupemos toda la capacidad definida previamente.

Como se dijo al principio no es obligatorio colocar la capacidad de almacenamiento ni el incremento, el tamaño inicial por defecto es 10 y cuando llenemos esos 10 espacios, automáticamente se añadirán 10 más.

Algo muy importante a tener en cuenta es el alto costo computacional que significa cada incremento automático, pues esta operación consiste en que el sistema copia todo el contenido en un nuevo vector y duplica su capacidad, cuando este proceso se repite demasiado el uso de la memoria aumenta y esto puede redundar en aplicaciones lentas.

Por lo tanto debemos ser muy cuidadosos y precavidos en los valores de capacidad que determinemos, es preferible aumentar el tamaño de un vector a que este deba incrementarse automáticamente de forma periódica. 

Ventajas y desventajas del uso de vectores en Java

Los vectores poseen dos propiedades maravillosas: 

• Tamaño
• Capacidad

El beneficio principal del uso de vectores es que crece automáticamente con el ingreso de elementos.

La principal desventaja es que el proceso es muy costoso a nivel memoria y recursos del sistema, ya que cuando la capacidad inicial se alcanza, se realiza la copia, ocupando memoria. 

Métodos de los vectores en Java

Los vectores tienen métodos propios para la manipulación de elementos.

• Para añadir elementos a un vector, lo hacemos a través del método .add(), dentro del paréntesis ingresamos los elementos acordes al tipo de dato que le declaramos al vector:

mivector.add(1);
mivector.add(10);
mivector.add(155);

• Si necesitamos eliminar un elemento utilizamos el método .remove(), en este método dentro de los paréntesis colocamos la posición (indice) del dato a borrar

mivector.remove(2);

• Con el método .size(), podemos comprobar el número de elementos existentes en el conjunto actual del vector, este método no lleva ningún parámetro.

System.out.println("Mi vector tiene: "+mivector.size()+" elementos");

• Si necesitamos reducir el tamaño de un vector, hay que realizarlo de forma manual, a través del método .trimToSize(); que permite eliminar los espacios vacíos, que no hayan sido utilizados en el vector.

Si tenemos posiciones vacías a causa de un .remove(); debemos saber que el programa dará error, para que no sucede necesitamos aplicar la cláusula continue

mivector.remove(2);
continue;

• Comparar vectores es relativamente sencillo en Java, debemos utilizar una variable booleana, que reciba el resultado de true o false, y aplicar el método .equals(); tengamos en cuenta que la comparativa se realiza posición a posición, por lo tanto si un elemento se repite, pero se encuentra en una posición distinta de la que está en el otro vector, no se dará como repetido

boolean resultado = mivector.equals(mivector2);

Si son exactamente iguales, devolverá true, si no false.

• Para recorrer o atravesar un vector lo hacemos a través de un bucle for, hay dos maneras, la forma “corta” y la forma “completa”.

Forma abreviada:

for (int i: mivector) {
    System.out.println("Valor actual en el vector: " + i);
}

Con i indicamos que nos muestre el contenido en esa posición.

Forma completa:

    //dentro de las llaves colocamos las acciones que queremos se realicen

 for (int i = 0; i < mivector.size(); i++) {
     if (i % 2 == 0) {
         mivector.remove(i);
         continue;
     }
System.out.println("Valor del elemento que queda es: " + mivector.get(i) + " en la posición: " + i);

En este trozo de código tenemos:

• .size(); cumple la función del length, poner un tope a la cantidad de ejecuciones
• .get(); este método extrae y muestra el contenido de i

Veamos un ejemplo con todo lo explicado:

import java.util.Vector;

public class vector2 {
    public static void main(String[] args) {

        Vector < Integer > mivector = new Vector(10, 5);
        mivector.add(1);
        mivector.add(10);
        mivector.add(155);
        System.out.println("datos que contiene el vector, llamado mivector " + mivector);

        mivector.remove(2);
        System.out.println("datos que contiene ahora el vector, llamado mivector " + mivector);
        mivector.add(155);

        System.out.println("datos que contiene ahora, de nuevo el vector, llamado mivector\n " + mivector);
        Vector < Integer > mivector2 = new Vector();
        mivector2.add(1);
        mivector2.add(10);
        mivector2.add(155);

        Vector < Integer > mivector3 = new Vector();
        mivector3.add(1);
        mivector3.add(10);
        boolean resultado = mivector.equals(mivector2);
        boolean resultado2 = mivector2.equals(mivector3);

        System.out.println("Vector  y vector2, son iguales?: " + resultado);
        System.out.println("Vector2  y vector3, son iguales?: " + resultado2);
        System.out.println("Vector tamaño: " + mivector.size() + " y la capacidad es: " + mivector.capacity());
        Vector < Integer > vector4 = new Vector();
        vector4.add(3);
        vector4.add(9);
        vector4.add(5);
        vector4.add(4);

        for (int i: vector4) {
            System.out.println("Valor actual en el vector4: " + i);
        }
        for (int i = 0; i < vector4.size(); i++) {
            if (i % 2 == 0) {
                vector4.remove(i);
                continue;
            }
            System.out.println("Valor del elemento que queda es: " + vector4.get(i) + " en la posicion: " + i);
        }
    }
}