Saltar para o conteúdo

Java/Vetores

Origem: Wikilivros, livros abertos por um mundo aberto.

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:
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):
Vetor de duas dimensões e vinte e cinco elementos
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):
Vetor de três dimensões e cento e vinte e cinco elementos
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:
{x0,x1,x2, ... ,xn}

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[i1][i2][i3]...[in]
onde:
identificador = nome do vetor;
in = é 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[i1]
  • duas dimensões é acessado:
x[i1][i2]
  • três dimensões é acessado:
x[i1][i2][i3]
  • quatro dimensões é acessado:
x[i1][i2][i3][i4]
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:

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:

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):
e