Quando necessitamos armazenar várias variáveis do mesmo tipo, temos à nossa disposição funcionalidades (estruturas de dados homogêneas) da programação chamadas de vetores (unidimensionais) e matrizes (bidimensionais). Você pode armazenar e depois recuperar determinado valor, atribuindo índices às posições dos vetores ou das matrizes.

Vetor

Para exemplificar um vetor (código abaixo), crio uma estrutura do tipo String e assim armazeno estados (UF) brasileiros. Em seguida, escrevo o conteúdo da posição “1”. No caso é escrito “PR” pois vetores sempre têm suas posições iniciais definidas em “0”.

public class Estrutura {

	public static void main(String[] args) {

		String vetor[] = { "TO", "PR", "RJ", "MT", "AM", "SP" };

                System.out.println(vetor[0]);
		System.out.println(vetor[1]);
	}

}

TO
PR

Matriz

Para exemplificar uma matriz (código abaixo), crio uma estrutura do tipo char e assim armazeno estados (X ou O) de um jogo da velha na situação encerrado. Em seguida, escrevo todo o conteúdo.

public class Estrutura {

	public static void main(String[] args) {

		char matriz[][] = { { 'X', 'X', 'X' }, { 'O', 'X', 'O' }, { 'O', 'X', '0' } };

		System.out.print(matriz[0][0] + " ");
		System.out.print(matriz[0][1] + " ");
		System.out.print(matriz[0][2] + " ");
		System.out.println();
		System.out.print(matriz[1][0] + " ");
		System.out.print(matriz[1][1] + " ");
		System.out.print(matriz[1][2] + " ");
		System.out.println();
		System.out.print(matriz[2][0] + " ");
		System.out.print(matriz[2][1] + " ");
		System.out.print(matriz[2][2] + " ");
	}

}

X X X 
O X O 
O X 0 

Exemplos

Ex.: 1 e 2

Para a classe Exemplo01 foi criado um vetor com 5 números e em seguida estes são exibidos através de um laço de repetição for.

public class Exemplo01 {

	public static void main(String[] args) {

		int vetor[] = { 10, 45, 99, 81, 77 };

		for (int a = 0; a < 5; a++) {
			System.out.print(vetor[a] + " ");
		}
	}
	
}

A classe Exemplo02 segue o mesmo raciocínio da classe Exemplo01; porém agora em vez de utilizar um laço de repetição para exibir os valores, utilizo um modo mais grosseiro que é acessando e escrevendo índice por índice.

public class Exemplo02 {

	public static void main(String [] args) {
		
		int vetor[] = { 10, 45, 99, 81, 77 };
		
		System.out.print(vetor[0] + " ");
		System.out.print(vetor[1] + " ");
		System.out.print(vetor[2] + " ");
		System.out.print(vetor[3] + " ");
		System.out.print(vetor[4] + " ");
	}
	
}

Observem abaixo o resultado das classes Exemplo01 e Exemplo02.

10 45 99 81 77 

Ex.: 3 e 4

Para a classe Exemplo03 foi criado um vetor de até 5 posições. Com o primeiro laço de repetição for adiciono números de 0 a 4 em todas as 5 posições do vetor.

public class Exemplo03 {

	public static void main(String[] args) {

		int vetor[] = new int[5];

		for (int a = 0; a < 5; a++) {
			vetor[a] = a;
		}

		for (int b = 0; b < 5; b++) {
			System.out.print(vetor[b] + " ");
		}
	}

}

Para a classe Exemplo04 foi criado um vetor de até 5 posições. Conforme a classe Exemplo03 em vez de utilizar laços for, tanto na hora de inserir valores quanto na hora de ler os valores, estes são feitos do modo manual.

public class Exemplo04 {

	public static void main(String[] args) {

		int vetor[] = new int[5];

		vetor[0] = 0;
		vetor[1] = 1;
		vetor[2] = 2;
		vetor[3] = 3;
		vetor[4] = 4;

		System.out.print(vetor[0]+" ");
		System.out.print(vetor[1]+" ");
		System.out.print(vetor[2]+" ");
		System.out.print(vetor[3]+" ");
		System.out.print(vetor[4]+" ");

	}

}

Observem abaixo o resultado das classes Exemplo03 e Exemplo04.

0 1 2 3 4 

Ex.: 5 e 6

Para o Exemplo05 inseri e mostrei valores de 4 a 0, ambos com laços de repetição for.

public class Exemplo05 {

	public static void main(String[] args) {

		int vetor[] = new int[5];
		int contador = 5;

		for (int a = 0; a < 5; a++) {
			contador--;
			vetor[a] = contador;
		}

		for (int b = 0; b < 5; b++) {
			System.out.print(vetor[b] + " ");
		}
	}

}

Para o Exemplo06 inseri e mostrei valores de 4 a 0, ambos sem laços de repetição.

public class Exemplo06 {

	public static void main(String[] args) {

		int vetor[] = new int[5];

		vetor[0] = 4;
		vetor[1] = 3;
		vetor[2] = 2;
		vetor[3] = 1;
		vetor[4] = 0;

		System.out.print(vetor[0] + " ");
		System.out.print(vetor[1] + " ");
		System.out.print(vetor[2] + " ");
		System.out.print(vetor[3] + " ");
		System.out.print(vetor[4] + " ");
	}

}

Observem abaixo o resultado das classes Exemplo05 e Exemplo06.

4 3 2 1 0 

Ex.: 7 e 8

Para a classe Exemplo07 crio 2 vetores, mostro os valores de ambos vetores e em seguida faço a multiplicação de ambos: vetor1 por vetor2 e mostro os resultados, ambos com laços de repetição for.

public class Exemplo07 {

	public static void main(String[] args) {

		int vetor1[] = { 2, 7, 4, 8 };
		int vetor2[] = { 6, 4, 1, 5 };

		for (int a = 0; a < 4; a++) {
			System.out.print(vetor1[a] + " ");
		}

		System.out.println();
		
		for (int b = 0; b < 4; b++) {
			System.out.print(vetor2[b] + " ");
		}
		
		System.out.println();
		
		for (int c = 0; c < 4; c++) {
			int resultado = vetor1[c] * vetor2[c];
			System.out.print(resultado + " ");
		}

	}

}

Para a classe Exemplo08 faço a mesma coisa que fiz com o Exemplo07, porém desta vez sem laços de repetição.

public class Exemplo08 {

	public static void main(String[] args) {
		
		int vetor1[] = { 2, 7, 4, 8 };
		int vetor2[] = { 6, 4, 1, 5 };

		System.out.print(vetor1[0] + " ");
		System.out.print(vetor1[1] + " ");
		System.out.print(vetor1[2] + " ");
		System.out.print(vetor1[3] + " ");
		
		System.out.println();
		
		System.out.print(vetor2[0] + " ");
		System.out.print(vetor2[1] + " ");
		System.out.print(vetor2[2] + " ");
		System.out.print(vetor2[3] + " ");
		
		System.out.println();
		
		System.out.print(vetor1[0] * vetor2[0] + " ");
		System.out.print(vetor1[1] * vetor2[1] + " ");
		System.out.print(vetor1[2] * vetor2[2] + " ");
		System.out.print(vetor1[3] * vetor2[3] + " ");
		
	}
	
}

Observem abaixo o resultado das classes Exemplo07 e Exemplo08.

2 7 4 8 
6 4 1 5 
12 28 4 40 

Ex.: 9 e 10

Abaixo, no Exemplo09, crio uma matriz com 3 linhas e 3 colunas com valores já inseridos. Para exibir estes valores foram utilizados 2 laços de repetição for aninhados (um dentro do outro). Um exibe as linhas e outro, as colunas.

public class Exemplo09 {

	public static void main(String[] args) {

		int matriz[][] = { { 8, 6, 4 }, { 3, 1, 9 }, { 2, 5, 6 } };
		
		for (int a = 0; a < 3; a++) {
			for (int b = 0; b < 3; b++) {
				System.out.print(matriz[a][b] + " ");
			}
			System.out.println();
		}

	}

}

A classe Exemplo10 seguiu o mesmo raciocínio da classe Exemplo09. Porém, em vez de mostrar os valores com laços de repetição, foi utilizado o modo digamos que manual; mais grosseiro.

public class Exemplo10 {

	public static void main(String[] args) {
		
		int matriz[][] = { { 8, 6, 4 }, { 3, 1, 9 }, { 2, 5, 6 } };
		
		System.out.print(matriz[0][0]+" ");
		System.out.print(matriz[0][1]+" ");
		System.out.print(matriz[0][2]+" ");
		System.out.println();
		System.out.print(matriz[1][0]+" ");
		System.out.print(matriz[1][1]+" ");
		System.out.print(matriz[1][2]+" ");
		System.out.println();
		System.out.print(matriz[2][0]+" ");
		System.out.print(matriz[2][1]+" ");
		System.out.print(matriz[2][2]+" ");
		
	}
	
}

Observem abaixo o resultado das classes Exemplo09 e Exemplo10.

8 6 4 
3 1 9 
2 5 6 

Ex.: 11 e 12

Para o Exemplo11 crio uma matriz 3 por 3 e insiro valores de 1 a 9. Em seguida mostro os valores inseridos. Observem que foram utilizados dois laços de repetição.

public class Exemplo11 {

	public static void main(String[] args) {

		int matriz[][] = new int[3][3];
		int contador = 0;

		for (int a = 0; a < 3; a++) {
			for (int b = 0; b < 3; b++) {
				contador++;
				matriz[a][b] = contador;
			}
		}
		
		for (int c = 0; c < 3; c++) {
			for (int d = 0; d < 3; d++) {
				System.out.print(matriz[c][d] + " ");
			}
			System.out.println();
		}

	}

}

Para o Exemplo12 foi utilizado o mesmo raciocínio do Exemplo11 porém agora, sem laços de repetição.

public class Exemplo12 {

	public static void main(String[] args) {
		
		int matriz[][] = new int[3][3];
		
		matriz[0][0] = 1;
		matriz[0][1] = 2;
		matriz[0][2] = 3;
		matriz[1][0] = 4;
		matriz[1][1] = 5;
		matriz[1][2] = 6;
		matriz[2][0] = 7;
		matriz[2][1] = 8;
		matriz[2][2] = 9;
		
		System.out.print(matriz[0][0]+" ");
		System.out.print(matriz[0][1]+" ");
		System.out.print(matriz[0][2]+" ");
		System.out.println();
		System.out.print(matriz[1][0]+" ");
		System.out.print(matriz[1][1]+" ");
		System.out.print(matriz[1][2]+" ");
		System.out.println();
		System.out.print(matriz[2][0]+" ");
		System.out.print(matriz[2][1]+" ");
		System.out.print(matriz[2][2]+" ");
		
	}
	
}

Observem abaixo o resultado das classes Exemplo11 e Exemplo12.

1 2 3 
4 5 6 
7 8 9 

Ex.: 13 e 14

Para o Exemplo13 criei 2 matrizes com valores inseridos. Mostrei os valores da primeira, os valores da segunda e multipliquei ambas. Tudo foi mostrado com laços de repetição.

public class Exemplo13 {

	public static void main(String[] args) {

		int matriz1[][] = { { 8, 6 }, { 3, 1 } };
		int matriz2[][] = { { 4, 1 }, { 9, 5 } };

		for (int a = 0; a < 2; a++) {
			for (int b = 0; b < 2; b++) {
				System.out.print(matriz1[a][b] + " ");
			}
			System.out.println();
		}

		System.out.println();

		for (int c = 0; c < 2; c++) {
			for (int d = 0; d < 2; d++) {
				System.out.print(matriz2[c][d] + " ");
			}
			System.out.println();
		}

		System.out.println();

		for (int e = 0; e < 2; e++) {
			for (int f = 0; f < 2; f++) {
				int resultado = matriz1[e][f] * matriz2[e][f];
				System.out.print(resultado + " ");
			}
			System.out.println();
		}

	}

}

Para a classe Exemplo14 foi usado o mesmo raciocícinio da classe Exemplo13. Porém reparem que não tiveram laços de repetição.

public class Exemplo14 {

	public static void main(String[] args) {

		int matriz1[][] = { { 8, 6 }, { 3, 1 } };
		int matriz2[][] = { { 4, 1 }, { 9, 5 } };

		System.out.print(matriz1[0][0] + " ");
		System.out.print(matriz1[0][1] + " ");
		System.out.println();
		System.out.print(matriz1[1][0] + " ");
		System.out.print(matriz1[1][1] + " ");

		System.out.println();
		System.out.println();

		System.out.print(matriz2[0][0] + " ");
		System.out.print(matriz2[0][1] + " ");
		System.out.println();
		System.out.print(matriz2[1][0] + " ");
		System.out.print(matriz2[1][1] + " ");

		System.out.println();
		System.out.println();

		System.out.print(matriz1[0][0] * matriz2[0][0] + " ");
		System.out.print(matriz1[0][1] * matriz2[0][1] + " ");
		System.out.println();
		System.out.print(matriz1[1][0] * matriz2[1][0] + " ");
		System.out.print(matriz1[1][1] * matriz2[1][1] + " ");

	}

}

Observem abaixo o resultado das classes Exemplo13 e Exemplo14.

8 6 
3 1 

4 1 
9 5 

32 6 
27 5 

Bom, como puderam notar a ideia dos exemplos foi a seguinte: Exemplo01 e Exemplo02 fazem a mesma coisa, porém de formas diferentes. Exemplo03 e Exemplo04 fazem a mesma coisa e também de formas diferentes. Assim ocorreu sucessivamente até que chegamos aos exemplos Exemplo13 e Exemplo14. Sempre ao final de dois exemplos seguidos era mostrado um resultado. Ou seja, como eram feitas as mesmas coisas de formas diferentes, não convia mostrar dois resultados para cada dois exemplos.

A rede mundial de computadores tem milhões de artigos e documentações falando sobre vetores matrizes, mais precisamente na linguagem Java. Este, de certa forma pode se dizer que defino com uma espécie de guia rápido para matrizes e vetores.

Espero que de certa forma eu possa ter contribuído para a comunidade da programação, mais precisamente da galera que está dando os primeiros passos neste mundo fantástico da programação.