Java Vector

Probablemente ya te hayas topado con arreglos en Java y sepas que uno de sus principales inconvenientes es la constancia del tamaño. Una vez que haya creado una matriz de cierto tamaño, no podrá cambiarla más tarde. Hay varias clases de marco de Java Collection en el lenguaje Java que resuelven este problema. Uno de ellos es Java Vector Class. Se discutirá en este artículo.

¿Qué es la clase vectorial?

Como escribimos en el prefacio, la clase Vector de Java Collection Framework elimina el problema del tamaño estático de las matrices. Java Vector es una especie de matriz dinámica y puede crecer o reducir su tamaño. Usando la clase de colección Vector , podemos almacenar un grupo de elementos como objetos simples y manipularlos a través de varios métodos. La clase Vector está disponible en el paquete java.util . Por lo tanto, Vector en Java se puede usar si no conoce el tamaño de la matriz de antemano, o si necesita una "matriz" que pueda cambiar las dimensiones durante la vida útil del programa. Hay que decir de inmediato que el Vectorclass ya es bastante antigua, y posteriormente aparecieron colecciones que pueden sustituirla en la gran mayoría de los casos. El "análogo" popular de Java Vector es la clase ArrayList . La diferencia más importante entre estas clases es que Vector está sincronizado, mientras que ArrayList no lo está. Hablaremos de otras diferencias entre estas dos clases y los análogos más modernos de la clase Vector un poco más adelante en la sección "Qué tiene de malo la clase Vector".

Métodos vectoriales de Java

Aquí están los métodos vectoriales de Java :

• void add(int index, Object element) inserta el elemento especificado en la posición especificada del vector.

• boolean add(Object o) agrega el elemento especificado al final del vector.

• boolean addAll(Collection c) agrega todos los elementos de la colección especificada al final del vector, en el orden en que son devueltos por el iterador de la colección especificada.

• boolean addAll(int index, Collection c) inserta todos los elementos dentro de la colección especificada en el vector en la posición especificada.

• void addElement(Object obj) agrega el componente especificado al final de este vector, aumentando su tamaño en uno.

• int capacity() devuelve la capacidad actual de este vector.

• void clear() elimina todos los elementos de este vector.

• Object clone() devuelve un clon de este vector.

• boolean contains(Object elem) comprueba si el objeto especificado es un componente de este vector.

• boolean containsAll(Collection c) devuelve verdadero si el vector contiene todos los elementos de la colección especificada.

• void copyInto(Object[] anArray) copia los componentes de este vector en la matriz especificada.

• Object elementAt(int index) devuelve el componente en el índice especificado.

• Elementos de enumeración () devuelve una enumeración de los componentes de este vector.

• void asegurarCapacity(int minCapacity) aumenta la capacidad de este vector, si es necesario, para garantizar que pueda contener al menos la cantidad de componentes dada por el argumento de capacidad mínima.

• boolean equals(Object o) compara el objeto especificado con este vector.

• Object firstElement() devuelve el primer componente (elemento en el índice 0) de este vector.

• Object get(int index) devuelve el elemento en la posición especificada en este vector.

• int hashCode() devuelve el valor del código hash para este vector.

• int indexOf(Object elem) busca la primera ocurrencia del argumento dado, probando la igualdad usando el método equals.

• int indexOf(Object elem, int index) busca la primera aparición del argumento dado, comenzando en index y probando la igualdad usando el método equals.

• void insertElementAt(Object obj, int index) inserta el objeto especificado como un componente en este vector en el índice especificado.

• boolean isEmpty() prueba este vector en busca de componentes faltantes.

• Object lastElement() devuelve el último componente del vector.

• int lastIndexOf(Object elem) devuelve el índice de la última aparición del objeto especificado en este vector.

• int lastIndexOf(Object elem, int index) busca hacia atrás el objeto especificado, comenzando en el índice especificado, y le devuelve el índice.

• Eliminar objeto (índice int) elimina el elemento en la posición especificada en este vector.

• boolean remove(Object o) elimina la primera aparición del elemento especificado en este vector. Si el vector no contiene un elemento, no cambia.

• booleano removeAll(Colección c) elimina todos los elementos del vector que están contenidos en la Colección especificada.

• void removeAllElements() elimina todos los componentes del vector y establece su tamaño en cero.

• boolean removeElement(Object obj) elimina la primera ocurrencia (índice más bajo) del argumento de este vector.

• void removeElementAt(int index) elimina un elemento en el índice.

• protected void removeRange(int fromIndex, int toIndex) elimina de esta lista todos los elementos cuyo índice se encuentra entre fromIndex, inclusive, y toIndex, exclusivamente.

• booleano retenerTodo(Colección c) retiene solo los elementos en el vector que están contenidos en la Colección especificada.

• Conjunto de objetos (índice int, elemento de objeto) reemplaza el elemento en la posición especificada en este vector con el elemento especificado.

• void setElementAt(Object obj, int index) establece el componente en el índice especificado de este vector como el objeto dado.

• void setSize(int newSize) establece el tamaño de este vector.

• int size() devuelve el número de componentes en este vector.

• List subList(int fromIndex, int toIndex) devuelve una representación (vista) de la parte de esta Lista entre fromIndex, inclusive, y toIndex, exclusivamente.

• Object[] toArray() devuelve una matriz que contiene todos los elementos de este vector en el orden correcto.

• Object[] toArray(Object[] a) devuelve una matriz que contiene todos los elementos de este vector en el orden correcto; el tipo de ejecución de la matriz devuelta es el tipo de la matriz especificada.

• String toString() devuelve una representación de cadena de este vector que contiene una representación de cadena de cada elemento.

• void trimToSize() recorta la capacidad de este vector al tamaño actual del vector.

Ejemplo de vector de Java

import java.util.Vector;

public class VectorExample {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       //adding some vector elements
       vector.add("Johnny");
       vector.add("Ivy");
       vector.add("Ricky");
       System.out.println(vector); 
       
       //adding more vector elements       
       vector.add("Johnny");
       vector.add("Paul");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Johnny"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Johnny", 1));
       vector.clear(); //deleting all vector elements
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

La salida de este programa está aquí abajo:

¿Qué tiene de malo la clase vectorial?

De acuerdo con la documentación de la clase Vector de Java , si no necesita una implementación segura para subprocesos en su programa, se recomienda usar ArrayList en lugar de Vector (el participante más efectivo de Collection Framework). Cambiemos un poco el ejemplo anterior, usando la clase ArrayList en lugar de Vector .

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {

       public static void main(String[] args) {
           List vector = new ArrayList();
           //Vector vector = new Vector();
           System.out.println("the size of the empty vector = " +  vector.size());
           vector.add("Johnny");
           vector.add("Ivy");
           vector.add("Ricky");
           System.out.println(vector);
           vector.add("Johnny");
           vector.add("Paul");
           System.out.println(vector);
           System.out.println("the size of the vector = " +  vector.size());
           //System.out.println("the first element of the vector = " + vector.firstElement());

           //here the program will print out the first appearance of "Johnny" element
           System.out.println(vector.indexOf("Johnny"));
           //program will print out the first appearance of "Johnny" element starting from the element 1
           //System.out.println(vector.indexOf("Johnny", 1));
           vector.clear();
           System.out.println("the size of the vector after clear method = " +  vector.size());

       }
   }

Comentamos la línea con vector.indexOf("Johnny", 1) , porque no existe tal método en esta variación en la clase ArrayList . Por la misma razón, la línea vector.firstElement() fue comentada. En todos los demás aspectos, el programa produce el mismo resultado que el primero. Por supuesto, en tal ejemplo, no está claro por qué ArrayList es mejor que Vector . Esto requiere más conocimiento sobre, por ejemplo, hilos. Enumeramos las razones aquí. En primer lugar, aunque la clase Vector está sincronizada, no puede llamarse completamente segura para subprocesos, aunque esto parece extraño. El caso es que Vector sincroniza cada operación, no todo Vectorinstancia en sí. Esto puede ser un problema en los programas en los que necesita sincronizar todo el conjunto de operaciones en lugar de operaciones individuales. Digamos, si un hilo está iterando sobre un vector y otro hilo está modificando estructuralmente una instancia del vector, el iterador lanzará una ConcurrentModificationException . Resulta que dos subprocesos pueden trabajar con una instancia de Vector al mismo tiempo si realizan operaciones diferentes. En segundo lugar, el vectorclass no tiene el mejor rendimiento porque sus objetos tienen una matriz redimensionable y sincronización. Esta combinación significa una sobrecarga adicional para las operaciones de bloqueo, ya sea que se requiera sincronización o no. Claro, esto afecta el rendimiento. Además, sincronizar el vector en cada operación también tiene un efecto negativo en el rendimiento, ya que adquiriremos un bloqueo una y otra vez para cada operación. Si se sincronizara toda la instancia de la clase, el bloqueo también se adquiriría una vez, lo que es mucho más eficiente. En tercer lugar, Vector admite algunos métodos heredados. Por ejemplo elementos (). Este método devuelve una enumeración de los componentes del vector. Los programadores suelen utilizar Iterator o ListIterator para Enumeración, y por varias razones. En particular, Enumeration no tiene definido un método remove() , lo que significa que la lista no se puede modificar estructuralmente durante la iteración. Además, a diferencia de ListIterator, Enumeration no ofrece acceso bidireccional. Como puede ver, Vector tiene bastantes problemas. ¿Qué sucede si aún necesita una implementación segura para subprocesos de la interfaz List? En este caso, ArrayList no ayudará, pero puede usar, por ejemplo, la clase CopyOnWriteArrayList en lugar de Vector ; se posiciona como una variante segura para subprocesos de ArrayList. También puede sincronizar ArrayList usando el método CollectionssynchronedList () .

Vector realmente tiene algunos problemas... ¿por qué todavía está en Java y por qué debería enseñarse?

Surge la pregunta: ¿por qué estamos estudiando la clase Vector ? ¿Y por qué aún no se ha eliminado de Java? El hecho es que Java profesa el principio de compatibilidad con versiones anteriores. Esto significa que todo el código antiguo escrito hace muchos años será entendido por las versiones modernas de Java. Además, existen bastantes aplicaciones de nivel empresarial en el entorno Java que han sido compatibles durante décadas. Es muy posible que tenga que lidiar con un "dinosaurio" de este tipo en su trabajo, por lo que debe estar preparado para sorpresas, como código con clases heredadas ineficaces.