Vetor Java

Provavelmente você já se deparou com arrays em Java e sabe que uma de suas principais desvantagens é a constância de tamanho. Depois de criar uma matriz de um determinado tamanho, você não poderá alterá-la posteriormente. Existem várias classes da estrutura Java Collection na linguagem Java que resolvem esse problema. Uma delas é a Classe Vetorial Java . Será discutido neste artigo.

O que é classe vetorial

Como escrevemos no prefácio, a classe Vector do Java Collection Framework elimina o problema do tamanho estático dos arrays. Java Vector é um tipo de array dinâmico e pode aumentar ou diminuir de tamanho. Usando a classe de coleção Vector , podemos armazenar um grupo de elementos como objetos simples e manipulá-los por meio de vários métodos. A classe Vector está disponível no pacote java.util . Assim, Vector em Java pode ser usado se você não souber o tamanho do array de antemão, ou se precisar de um "array" que possa mudar de dimensão durante o tempo de vida do programa. Deve-se dizer desde já que o VectorA classe já é bastante antiga e surgiram coleções posteriores que podem substituí-la na grande maioria dos casos. O popular “análogo” do Java Vector é a classe ArrayList . A diferença mais importante entre essas classes é que Vector é sincronizado, enquanto ArrayList não é. Falaremos sobre outras diferenças entre essas duas classes e análogos mais modernos da classe Vector um pouco mais adiante na seção “O que há de errado com a classe Vector”.

Métodos de Vetor Java

Aqui estão os métodos de vetor Java :

• void add(int index, Object element) insere o elemento especificado na posição especificada do vetor.

• boolean add(Object o) adiciona o elemento especificado ao final do vetor.

• boolean addAll(Collection c) adiciona todos os elementos na coleção especificada ao final do vetor, na ordem em que são retornados pelo iterador da coleção especificada.

• boolean addAll(int index, Collection c) insere todos os elementos dentro da Collection especificada no vetor na posição especificada.

• void addElement(Object obj) adiciona o componente especificado ao final desse vetor, aumentando seu tamanho em um.

• int capacidade() retorna a capacidade atual deste vetor.

• void clear() remove todos os elementos deste vetor.

• Object clone() retorna um clone deste vetor.

• boolean contains(Object elem) testa se o objeto especificado é um componente neste vetor.

• boolean containsAll(Collection c) retorna verdadeiro se o vetor contiver todos os elementos da coleção especificada.

• void copyInto(Object[] anArray) copia os componentes desse vetor para o array especificado.

• Object elementAt(int index) retorna o componente no índice especificado.

• Enumeration elements() retorna uma enumeração dos componentes deste vetor.

• void assegurarCapacity(int minCapacity) aumenta a capacidade desse vetor, se necessário, para garantir que ele possa conter pelo menos o número de componentes fornecido pelo argumento de capacidade mínima.

• boolean equals(Object o) compara o objeto especificado com este vetor.

• Object firstElement() retorna o primeiro componente (elemento no índice 0) deste vetor.

• Object get(int index) retorna o elemento na posição especificada neste vetor.

• int hashCode() retorna o valor do código hash para este vetor.

• int indexOf(Object elem) procura a primeira ocorrência do argumento fornecido, testando a igualdade usando o método equals.

• int indexOf(Object elem, int index) procura a primeira ocorrência do argumento fornecido, começando em index e testando a igualdade usando o método equals.

• void insertElementAt(Object obj, int index) insere o objeto especificado como um componente neste vetor no índice especificado.

• boolean isEmpty() testa este vetor em busca de componentes ausentes.

• Object lastElement() retorna o último componente do vetor.

• int lastIndexOf(Object elem) retorna o índice da última ocorrência do objeto especificado neste vetor.

• int lastIndexOf(Object elem, int index) pesquisa para trás o objeto especificado, começando no índice especificado e retorna o índice para ele.

• Object remove(int index) remove o elemento na posição especificada neste vetor.

• boolean remove(Object o) remove a primeira ocorrência do elemento especificado neste vetor. Se o vetor não contém um elemento, ele não muda.

• boolean removeAll(Collection c) remove todos os elementos do vetor contidos na Collection especificada.

• void removeAllElements() remove todos os componentes do vetor e define seu tamanho como zero.

• boolean removeElement(Object obj) remove a primeira ocorrência (menor índice) do argumento deste vetor.

• void removeElementAt(int index) remove um elemento no índice.

• protected void removeRange(int fromIndex, int toIndex) remove desta Lista todos os elementos cujo índice está entre fromIndex, inclusive, e toIndex, exclusivamente.

• boolean reterAll(Collection c) retém apenas os elementos no vetor que estão contidos na Coleção especificada.

• Object set(int index, Object element) substitui o elemento na posição especificada neste vetor pelo elemento especificado.

• void setElementAt(Object obj, int index) define o componente no índice especificado deste vetor como o objeto fornecido.

• void setSize(int newSize) define o tamanho deste vetor.

• int size() retorna o número de componentes neste vetor.

• List subList(int fromIndex, int toIndex) retorna uma representação (view) da parte desta List entre fromIndex, inclusive, e toIndex, exclusivamente.

• Object[] toArray() retorna um array contendo todos os elementos deste vetor na ordem correta.

• Object[] toArray(Object[] a) retorna um array contendo todos os elementos deste vetor na ordem correta; o tipo de execução da matriz retornada é o tipo da matriz especificada.

• String toString() retorna uma representação em string desse vetor contendo uma representação em string de cada elemento.

• void trimToSize() ajusta a capacidade deste vetor para o tamanho atual do vetor.

Exemplo de Vetor 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());

   }
}

A saída deste programa está aqui abaixo:

O que há de errado com a classe Vector?

De acordo com a documentação da classe Java Vector , se você não precisa de uma implementação thread-safe em seu programa, é recomendável usar ArrayList no lugar de Vector (participante mais efetivo do Collection Framework). Vamos mudar um pouco o exemplo acima, usando a classe ArrayList ao invés 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());

       }
   }

Nós comentamos a linha com vector.indexOf("Johnny", 1) , porque não existe tal método nesta variação na classe ArrayList . Pela mesma razão, a linha vector.firstElement() foi comentada. Em todos os outros aspectos, o programa produz o mesmo resultado que o primeiro. Obviamente, em tal exemplo, não está claro por que ArrayList é melhor que Vector . Isso requer mais conhecimento sobre, digamos, threads. Listamos aqui os motivos. Em primeiro lugar, embora a classe Vector seja sincronizada, ela não pode ser chamada de totalmente thread-safe, embora isso pareça estranho. O fato é que o Vector sincroniza cada operação, não o Vector inteiroprópria instância. Isso pode ser um problema em programas nos quais você precisa sincronizar todo o conjunto de operações em vez de operações individuais. Digamos, se um thread estiver iterando sobre um vetor e outro thread estiver modificando estruturalmente uma instância do vetor, o iterador lançará uma ConcurrentModificationException . Acontece que duas threads podem trabalhar com uma instância de Vector ao mesmo tempo se executarem operações diferentes. Em segundo lugar, o vetorA classe não tem o melhor desempenho porque seus objetos têm uma matriz redimensionável e sincronização. Essa combinação significa sobrecarga adicional para operações de bloqueio, seja a sincronização necessária ou não. Claro, isso afeta o desempenho. Além disso, sincronizar o vetor em cada operação também tem um efeito negativo no desempenho, pois adquiriremos um bloqueio repetidamente para cada operação. Se toda a instância da classe fosse sincronizada, o bloqueio também seria adquirido uma vez, o que é muito mais eficiente. Em terceiro lugar, o Vector oferece suporte a alguns métodos herdados. Por exemplo elementos (). Este método retorna uma enumeração dos componentes do vetor. Os programadores costumam usar Iterator ou ListIterator para enumeração e por vários motivos. Em particular, Enumeration não tem um método remove() definido, o que significa que a lista não pode ser modificada estruturalmente durante a iteração. Além disso, ao contrário de ListIterator, Enumeration não oferece acesso bidirecional. Como você pode ver, o Vector tem alguns problemas. E se você ainda precisar de uma implementação thread-safe da interface List? Nesse caso, ArrayList não vai ajudar, mas você pode usar, por exemplo, a classe CopyOnWriteArrayList ao invés de Vector ; ele está posicionado como uma variante thread-safe do ArrayList. Você também pode sincronizar ArrayList usando o método CollectionssyncdList() .

Vector realmente tem alguns problemas... por que ainda está em Java e por que deveria ser ensinado?

Surge a pergunta: por que estamos estudando a classe Vector ? E por que ainda não foi removido do Java? O fato é que Java professa o princípio da compatibilidade com versões anteriores. Isso significa que todo código antigo escrito há muitos anos será compreendido pelas versões modernas do Java. Além disso, existem alguns aplicativos de nível empresarial no ambiente Java que têm suporte há décadas. É bem possível que você tenha que lidar com tal “dinossauro” em seu trabalho, então você precisa estar preparado para surpresas, como código com classes legadas ineficazes.