O que é um vetor em java?

Um vetor em Java, é como uma matriz. No entanto, diferentemente de uma matriz, ele pode encolher ou aumentar em comprimento. Os elementos podem ser anexados ou inseridos ao vetor, o que aumenta seu comprimento. Os elementos também podem ser removidos, o que reduz (diminui) o comprimento do vetor.

Em Java, há a classe e há objetos da classe. Objetos correspondentes de uma classe são instanciados da classe. O vetor é uma classe da qual os objetos vetoriais são instantados. A classe vetorial é encontrada no Java.util.* pacote, que deve ser importado. Este artigo explica o que é um vetor e seus métodos comumente usados.

Conteúdo do artigo

• Construção de um vetor
• Adicionando elementos a um vetor
• Anexando a um vetor
• O comprimento de um vetor
• Acessando um elemento
• Inserção de elementos
• Remoção de elementos
• Conclusão

Construção de um vetor

Um vetor pode ser construído como um vetor vazio ou com elementos. Um vetor é uma coleção. Isso significa que um vetor pode consistir, todos os números inteiros, ou todos os personagens, ou todas as duplas, ou todas as cordas, etc. Na construção, o tipo é indicado em suportes de ângulo. Os suportes de ângulo tomam uma referência, e não um tipo primitivo. Então, deveria ser e não; e não ; e não ; etc. Nas classes de referência, não há problema. Por exemplo, a string é justa e não há outra alternativa. Todos os elementos do vetor são do mesmo tipo.

Construindo um vetor vazio

A maneira de construir um vetor vazio de caracteres é:

Vetor vtr = novo vetor();

onde VTR é o nome do vetor, dado pelo programador. Observe as posições dos dois suportes de ângulo. Observe a presença dos parênteses vazios, no final da declaração. O Vector é uma aula em Java, então tem que começar com um personagem maiúsculo. O programa a seguir tem a criação de um vetor:

importar java.util.*;
classe pública theClass
public static void main (string [] args)
Vetor vtr = novo vetor();

Construindo um vetor com elementos

Um vetor não vazio pode ser construído. A maneira de fazer isso é semelhante ao acima. Isso é:

Vetor vtr = novo vetor(Al);

Estavam aqui, é um Arraylist, outra coleção. O conteúdo dos parênteses deve ser o nome de uma coleção. Nesse caso, o Arraylist precisa ter sido definido da seguinte maneira:

Arraylist AL = novo Arraylist();
al.add ('a'); al.add ('b'); al.add ('e'); al.add ('f');

O programa a seguir mostra como um vetor não vazio pode ser construído com este esquema:

importar java.util.*;
classe pública theClass
public static void main (string [] args)
Arraylist AL = novo Arraylist();
al.add ('a'); al.add ('b'); al.add ('e'); al.add ('f');
Vetor vtr = novo vetor(Al);

Nota: Arraylist também está no Java.util.* pacote.

Adicionando elementos a um vetor

Depois que um vetor foi criado, vazio ou não, os elementos podem ser adicionados.

Adicionando elementos um a um

A sintaxe para adicionar elementos um a um é:

public boolean add (e e)

Ele retorna verdadeiro, se uma mudança ocorreu, e false caso contrário. O código a seguir no método Main () mostra como os elementos são adicionados a um vetor.

Vetor vtr = novo vetor();
vtr.add ('a');
vtr.add ('b');
vtr.add ('e');
vtr.add ('f');

O vetor agora consiste nos personagens, 'a', 'b', 'e' e 'f'.

Adicionando uma lista de elementos

Mais de um elemento pode ser adicionado ao mesmo tempo, de outro vetor. A sintaxe para o método vetorial para isso é:

addall booleano público (coleção c)

Ele retorna verdadeiro, se uma mudança ocorreu.

O código a seguir no método Main () ilustra o seguinte:

Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('e'); vtr.add ('f');
Vetor c = novo vetor();
c.add ('g'); c.add ('h');
vtr.addall (c);

O outro vetor aqui é C.

Anexando a um vetor

As duas maneiras acima de adicionar a um vetor estão anexando: adicionar elementos no final.

O comprimento de um vetor

A duração de um vetor é o tamanho do vetor: o número de elementos que o vetor tem. A classe vetorial tem um método para obter o comprimento de um vetor. A sintaxe completa é:

Public int size ()

O tamanho retornado é um número inteiro. Considere o seguinte código no método Main ():

Vetor vtr1 = novo vetor();
Vetor vtr2 = novo vetor();
Vtr2.add ('a'); Vtr2.add ('b'); Vtr2.add ('e'); Vtr2.add ('f');
int len1 = vtr1.tamanho();
int len2 = vtr2.tamanho();
Sistema.fora.println ("len1 é:" + len1);
Sistema.fora.println ("len2 é:" + len2);

A saída é:

Len1 é: 0
Len2 é: 4

Acessando um elemento

Acessar um elemento significa obter (leitura) ou configuração (alterando) o valor de um elemento no vetor.

Obtendo elemento

A sintaxe completa para obter um elemento é:

public E Get (Int Index)

Uma cópia do elemento é devolvida. A contagem de índice começa de 0. O código a seguir obtém todos os elementos do vetor usando um loop for:

Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('e'); vtr.add ('f');
para (int i = 0; ichar ch = vtr.Entendi);
Sistema.fora.impressão (ch); Sistema.fora.imprimir(", ");

Sistema.fora.println ();

A saída é:

A, b, e, f,

Elemento de configuração

A sintaxe completa para definir (alterar) um elemento é:

Public E Set (índice int, e elemento)

Ele retorna o elemento antigo na posição do índice. Os seguintes conjuntos de códigos (mudam) todos os elementos do vetor:

Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('e'); vtr.add ('f');
vtr.set (0, 'w'); vtr.set (1, 'x'); vtr.set (2, 'y'); vtr.conjunto (3, 'z');
para (int i = 0; iSistema.fora.Imprimir (Vtr.Entendi)); Sistema.fora.imprimir(", ");

Sistema.fora.println ();

A saída é agora:

W X Y Z,

com todos os elementos mudados.

Inserção de elementos

Elementos podem ser inseridos em um vetor. Isso precisa de dois outros tipos de método add ().

O método add (int índice, e elemento)

Este método insere um elemento em uma posição de índice. O elemento que estava nessa posição é deslocado para o lado direito. A sintaxe completa para este método é:

public void add (índice int, e elemento)

No código a seguir, um caractere é inserido na posição do índice 2:

Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('e'); vtr.add ('f');
vtr.add (2, 'd');
para (int i = 0; iSistema.fora.Imprimir (Vtr.Entendi)); Sistema.fora.imprimir(", ");

Sistema.fora.println ();

A ordem de matriz original é:

A, b, e, f

A saída é:

A, B, D, E, F,

'D' foi inserido no índice 2.

Addall (índice int, coleção c)

Isso pode inserir uma lista na posição do índice, empurrando o restante dos elementos, que estavam à direita dessa posição (incluindo o elemento na posição), mais à direita, pelo número de caracteres na lista inserida. A lista a ser inserida pode ser outro vetor (coleção). A sintaxe completa deste método é:

public boolean addall (índice int, coleção c)

Retorna verdadeira, se uma mudança ocorrer; falso caso contrário. O código a seguir ilustra seu uso:

Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('e'); vtr.add ('f');
Vetor c = novo vetor();
c.add ('c'); c.add ('d');
vtr.addall (2, c);
para (int i = 0; iSistema.fora.Imprimir (Vtr.Entendi)); Sistema.fora.imprimir(", ");

Sistema.fora.println ();

A ordem de matriz original é:

A, b, e, f

A saída é:

A, B, C, D, E, F,

A lista ['c', 'd'] foi inserida no índice 2.

Remoção de elementos

Existem muitas maneiras de remover elementos. Apenas duas abordagens são abordadas aqui.

Remover (índice int)

Este método remove o elemento no índice específico. O restante dos elementos à direita é deslocado para a esquerda por um lugar. A sintaxe completa para este método é:

public e remover (índice int)

Ele retorna o elemento que foi removido. O código a seguir ilustra seu uso:

Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('c'); vtr.add ('d'); vtr.add ('e'); vtr.add ('f');
vtr.remover (3);
para (int i = 0; iSistema.fora.Imprimir (Vtr.Entendi)); Sistema.fora.imprimir(", ");

Sistema.fora.println ();

A ordem de matriz original é:

A, B, C, D, E, F

A saída é:

A, B, C, E, F,

'D' no índice 3, foi removido.

vtr.sublist (int deindex, int toIndex).claro()

Essa abordagem remove uma série de elementos de Index Inclusive a ToIndex exclusivo. No código a seguir, Fromindex é 2 e ToIndex é 4. Então, apenas elementos nos índices 2 e 3 são removidos. O código é:

importar java.util.*;
classe pública theClass
public static void main (string [] args)
Vetor vtr = novo vetor();
vtr.add ('a'); vtr.add ('b'); vtr.add ('c'); vtr.add ('d'); vtr.add ('e'); vtr.add ('f');
vtr.sublista (2, 4).claro();
para (int i = 0; iSistema.fora.Imprimir (Vtr.Entendi)); Sistema.fora.imprimir(", ");

Sistema.fora.println ();

A ordem de matriz original é:

A, B, C, D, E, F

A saída é:

A, b, e, f,

A lista de caracteres consecutivos ['C', 'D'] foi removida.

Conclusão

Um vetor em Java, é como uma matriz. No entanto, diferentemente de uma matriz, ele pode encolher ou aumentar em comprimento. Os elementos podem ser anexados ou inseridos ao vetor, o que aumenta seu comprimento. Os elementos também podem ser removidos, o que reduz o comprimento. Este artigo explicou o que é um vetor e seus métodos comumente usados.