Java/Vetores

Definição de vetor[editar | editar código-fonte]

Um vetor é uma estrutura de dados formada por um conjunto de dados ou outros elementos de um mesmo tipo ou uma mesma estrutura. O vetor pode ter uma dimensão ou mais. Também chamado de matriz quando de duas dimensões, funciona de modo análogo às matrizes matemáticas. O acesso aos dados é feito através de "coordenadas" (índices).

A programação faz um grande uso de vetores. Cada item de um vetor é chamado de elemento. Cada um dos elementos possui uma posição dentro do vetor, à qual referenciamos através do índice do elemento. Cada um dos "domínios" (conjunto de posições, endereços de armazenamentos) do vetor, nos chamamos de dimensão. Já o tipo de dado (ou de elemento) corresponde ao "contradomínio" do vetor, ou seja, o conjunto de literais ou de outro tipo de elemento que o vetor pode armazenar.

Veja um vetor de uma dimensão e dez elementos:

Ele possui 10 elementos que são acessados (referenciados) pelos índices:

 [0], [1], [2], [3], [4], [5], [6], [7], [8], [9].

Os índices de cada elemento são escritos entre colchetes [ ].

Veja um vetor de duas dimensões e vinte e cinco elementos (5 x 5):

Ele possui 25 elementos que são acessados (referenciados) pelos índices:

 [0][0], [1][0], [2][0], [3][0], [4][0],
 [0][1], [1][1], [2][1], [3][1], [4][1],
 [0][2], [1][2], [2][2], [3][2], [4][2],
 [0][3], [1][3], [2][3], [3][3], [4][3],
 [0][4], [1][4], [2][4], [3][4], [4][4].

Cada elemento é representado por dois índices (um para cada dimensão), entre colchetes e adjacentes [ ][ ].

Veja um vetor de três dimensões e cento e vinte e cinco elementos (5 x 5 x 5):

Ele possui 125 elementos que são acessados (referenciados) pelos índices:

[0][0][0], [1][0][0], [2][0][0], [3][0][0], [4][0][0],
[0][1][0], [1][1][0], [2][1][0], [3][1][0], [4][1][0],
[0][2][0], [1][2][0], [2][2][0], [3][2][0], [4][2][0],
[0][3][0], [1][3][0], [2][3][0], [3][3][0], [4][3][0],
[0][4][0], [1][4][0], [2][4][0], [3][4][0], [4][4][0],
[0][0][1], [1][0][1], [2][0][1], [3][0][1], [4][0][1],
[0][1][1], [1][1][1], [2][1][1], [3][1][1], [4][1][1],
[0][2][1], [1][2][1], [2][2][1], [3][2][1], [4][2][1],
[0][3][1], [1][3][1], [2][3][1], [3][3][1], [4][3][1],
[0][4][1], [1][4][1], [2][4][1], [3][4][1], [4][4][1],
[0][0][2], [1][0][2], [2][0][2], [3][0][2], [4][0][2],
[0][1][2], [1][1][2], [2][1][2], [3][1][2], [4][1][2],
[0][2][2], [1][2][2], [2][2][2], [3][2][2], [4][2][2],
[0][3][2], [1][3][2], [2][3][2], [3][3][2], [4][3][2],
[0][4][2], [1][4][2], [2][4][2], [3][4][2], [4][4][2],
[0][0][3], [1][0][3], [2][0][3], [3][0][3], [4][0][3],
[0][1][3], [1][1][3], [2][1][3], [3][1][3], [4][1][3],
[0][2][3], [1][2][3], [2][2][3], [3][2][3], [4][2][3],
[0][3][3], [1][3][3], [2][3][3], [3][3][3], [4][3][3],
[0][4][3], [1][4][3], [2][4][3], [3][4][3], [4][4][3],
[0][0][4], [1][0][4], [2][0][4], [3][0][4], [4][0][4],
[0][1][4], [1][1][4], [2][1][4], [3][1][4], [4][1][4],
[0][2][4], [1][2][4], [2][2][4], [3][2][4], [4][2][4],
[0][3][4], [1][3][4], [2][3][4], [3][3][4], [4][3][4],
[0][4][4], [1][4][4], [2][4][4], [3][4][4], [4][4][4].

Declaração de um vetor[editar | editar código-fonte]

Para declarar um vetor, utiliza-se a seguinte sintaxe:

 tipo[] identificador;

ou

 tipo identificador[];

Onde:

tipo = tipo de dado ou de elemento;

identificador = nome do vetor.

Um vetor de duas dimensões é criado do seguinte modo:

 tipo[][] identificador;

ou

 tipo identificador[][];

Um vetor de três dimensões é criado do seguinte modo:

 tipo[][][] identificador;

ou

 tipo identificador[][][];

E assim, por diante - um vetor de quatro dimensões é criado do seguinte modo:

 tipo[][][][] identificador;

ou

 tipo identificador[][][][];

Dados em um vetor[editar | editar código-fonte]

Os elementos dos vetores podem ser atribuídos da seguinte forma (separados por vírgulas e entre chaves. Por exemplo, em um vetor unidimensional poderíamos indicar os dados de seus elementos assim:

{x₀,x₁,x₂, ... ,x_n}

onde cada um dos valores X é um valor do elemento de índice correspondente no vetor. A numeração dos índices começa a partir do 0 e pode ser somente número natural, ou seja, inteiro maior ou igual a zero.

Vetores podem ser declarados e iniciados conforme o seguinte exemplo - cada dimensão é delimitada por chaves e cada elemento é separado do outro através de vírgulas:

 int[] vetor={34, 27, 3, 2};

Outro modo de uso é declarando, iniciando com o tamanho (quantidade de elementos) do vetor e depois atribuindo os valores, como o equivalente a seguir:

 int[] vetor= new int[4];
 vetor={34, 27, 3, 2};

Ou então, atribuindo os elementos individualmente:

 int[] vetor= new int[4];
 vetor[0]=34;
 vetor[1]=27;
 vetor[2]=3;
 vetor[3]=2;

Observação: lembre-se que o ponto é utilizado para separar a parte inteira da parte fracionário de um número (notação inglesa) enquanto que a vírgula separa elementos.

Vetores de caracteres também são chamados de strings (cadeias de caracteres) e podem ser representados como um conjunto de caracteres cercado por aspas. Podemos declarar e atribuir tipos não básicos. No exemplo a seguir, frase é um vetor de objetos da classe String. Cada elemento de frase é também um vetor de caracteres. Por exemplo, "Bom dia" é o primeiro elemento do vetor frase e também, por si só, é um vetor de caracteres {'B','o','m',' ','d','i','a'}.

 String[] frase={"Bom dia","Boa tarde","Boa noite"};

Acessando os elementos do vetor[editar | editar código-fonte]

Para representar ou acessar um único elemento de um vetor, usa-se a sintaxe:

identificador[i₁][i₂][i₃]...[i_n]

onde:

identificador = nome do vetor;

i_n = é a literal que representa o elemento de índice n.

Assim, no exemplo acima, frase[0] é igual a "Bom dia".

Observação: como a numeração dos índices começa em 0, frase poderá ter somente, no exemplo acima, os índices 0, 1 ou 2.

Cada dimensão do vetor é representada por um conjunto de colchetes. Assim, um vetor x de:

uma dimensão é acessado:

x[i₁]

duas dimensões é acessado:

x[i₁][i₂]

três dimensões é acessado:

x[i₁][i₂][i₃]

quatro dimensões é acessado:

x[i₁][i₂][i₃][i₄]

e assim por diante.

Comparando um vetor de duas dimensões com uma matriz algébrica[editar | editar código-fonte]

Por exemplo, podemos representar a seguinte matriz:

$B={\begin{bmatrix}8&0&9&2\\2&4&3&1\end{bmatrix}}$

assim, em Java:

 int[][] B=new int[2][4];
 B={{8,0,9,2},
    {2,4,3,1}};

ou assim:

 int[][] B={{8,0,9,2},
            {2,4,3,1}};

ou assim:

 int[][] B=new int[2][4];
 B[0][0] = 8;
 B[0][1] = 0;
 B[0][2] = 9;
 B[0][3] = 2;
 B[1][0] = 2;
 B[1][1] = 4;
 B[1][2] = 3;
 B[1][3] = 1;

Declarando, iniciando e atribuindo valores a um vetor de duas ou mais dimensões[editar | editar código-fonte]

Para se atribuir valores às várias dimensões de vetor, separamos cada dimensão num bloco (por chaves) e seus elementos separados por vírgulas.

Exemplo de vetor de duas dimensões (2 elementos x 3 elementos):

 float[][] V={{1.5,2.7,3.5}, {1.2,3.0,4.5}};

O exemplo acima corresponde à seguinte matriz:

$V={\begin{bmatrix}1,5&2,7&3,5\\1,2&3,0&4,5\end{bmatrix}}$

Então, no caso de duas dimensões, geralmente se formata o código em Java assim (para lembrar a representação "biordenada" da matriz):

 float[][] V={{1.5, 2.7, 3.5},
              {1.2, 3.0, 4.5}};

Cada dimensão está agrupada por chaves. Cada um dos elementos da dimensão são separados por vírgulas. Os números fracionários são representados com ponto ao invés de vírgula (entre a parte inteira e a fracionária).

Exemplo de um vetor de 3 dimensões (4 elementos x 3 elementos x 2 elementos), lembre-se que cada dimensão está agrupada entre chaves

 int[][] V2={
 {{1,65}, {2,47}, {33,5}},
 {{1,32}, {22,7}, {53,65}},
 {{1,5}, {12,7}, {23,5}},
 {{1,2}, {2,7}, {3,66}}};

Equivale à sobreposição (num espaço tridimensional) dessas duas matrizes (formando a terceira dimensão):

{\begin{bmatrix}1&2&33\\1&22&53\\1&12&23\\1&2&3\end{bmatrix}}

e

{\begin{bmatrix}65&47&5\\32&7&65\\5&7&5\\2&7&66\end{bmatrix}}