Existem várias possibilidades para o uso de arrays. Elaborei um exemplo para demonstrar a utilização aplicando sobre um cadastro de clientes. Objetivo deste exemplo é mostrar uma maneira de utilizar array com Java.
Para saber o que é um array veja a definição da Wikipédia
sobre array. Os principais pontos que devem ser observados para entender o uso de Array em Java na minha opinião são:
- Um array em Java precisa ser declarado usando os colchetes ( [ ] );
- O caso mais comum do uso de array requer que este seja inicializado (alocar memória) e neste momento, deve-se informar o seu tamanho; Ex. String[] listaClientes = new String[quantidade];
- Para acessar os dados do array basta usar os colchetes, seguido por seu índice. Ex. listaClientes[i] = JOptionPane.showInputDialog("Nome do cliente "+(i+1));
- Quando um array for criado na memória ele será inicializado com valores default do tipo de dados conforme o tipo de sua declaração. Ou seja, um array de tipo String terá valor null em cada elemento disponível até que seja atribuído outro valor String. Se for tipo primitivo int, o valor default é 0 (zero) para cada elemento; float será 0.0 e assim sucessivamente;
- Para determinar o tamanho do array de forma dinâmica devemos usar o atributo length. Ex. listaClientes.length
- Para recuperar os valores devemos usar o seu índice. Veja a ilustração acima. Ex. listaClientesTemporario += listaClientes[i] + "\n"
O programa a seguir utiliza um exemplo para cadastrar clientes e recuperar os seus dados cadastrados na memória. Tentei levar em consideração todos os pontos mencionados.
import javax.swing.JOptionPane;
/**
* Esse programa visa exemplificar a utilização de array, aplicando sobre um
* cadastro de clientes.
*
* @author Douglas Daniel Del Frari
*/
public class CadastroClientes {
// array de clientes
private static String[] listaClientes;
private static String menu = "CADASTRO CLIENTES\n\n" +
"1 --> Cadastrar clientes\n" +
"2 --> Listar clientes\n" +
"3 --> Sair";
/**
* Método inicial das aplicações Java SE
* @param args argumentos opcionais
*/
public static void main(String[] args) {
// escolha do usuario
String opcao = "";
do {
opcao = JOptionPane.showInputDialog(menu);
if (opcao.equals("1")) {
// cadastrar clientes
cadastrarClientes();
} else if (opcao.equals("2")) {
// listar clientes
listarClientes();
}
} while (!opcao.equals("3")); // comparacao usando String
} // fim do main
/**
* Lista os clientes cadastrados no ARRAY.
*/
private static void listarClientes() {
if (listaClientes!=null) {
// acumula a listagem numa variavel local
String listaClientesTemporario = "Lista de Clientes \n\n";
for (int i = 0; i < listaClientes.length; i++) {
listaClientesTemporario += listaClientes[i] + "\n";
}
// exibe na tela a listagem de clientes
JOptionPane.showMessageDialog(null,listaClientesTemporario);
} else {
// se nao tiver clientes o ARRAY será null, entao pode-se tratar com
// uma mensagem personalizada.
JOptionPane.showMessageDialog(null,
"É necessário realizar cadastro de clientes primeiro");
}
}
/**
* Esse metodo cadastra os usuarios na quantidade
* informada pelo usuario.
*/
private static void cadastrarClientes() {
// utiliza o metodo showInputDialog para perguntar a quantidade e
// converte o valor de String para inteiro e armazena na variavel
// local quantidade.
int quantidade = Integer.parseInt(JOptionPane
.showInputDialog("Quantos clientes deseja cadastrar?"));
// inicializa o ARRAY com tamanho informado pelo usuario
listaClientes = new String[quantidade];
// percorre todo tamanho do ARRAY e cadastra seus elementos
for (int i = 0; i < quantidade; i++) {
listaClientes[i] = JOptionPane.showInputDialog("Nome do cliente "+(i+1));
}
JOptionPane.showMessageDialog(null, "Clientes cadastrados");
}
} // fim da classe
Considerações
Observe que o exemplo propõe utilizar uma variável global (atributo listaClientes) que é um tipo array de String. Isto porque utilizou-se métodos que são utilizados forá do escopo do método principal (main). Além disso, propomos utilizar uma interface gráfica usando a classe JOptionPane e dois dos seus métodos estáticos (showMessageDialog para exibir dados e showInputDialog para fazer a entrada de dados do usuário).
O array foi inicializado somente após o usuário determinar a quantidade de clientes a ser cadastrada. Assim podemos percorrer o cadastro de cada cliente até o fim do array (ver o método cadastrarClientes()). Se o usuário optar pela visualização da listagem de clientes antes de cadastrar algum cliente, optamos por mostrar uma mensagem para alertar que é necessário realizar o cadastro antes de listar (basta verificar se o array não está nulo - if (listaClientes!=null))
Essa solução não leva em consideração possíveis erros do usuário. Por exemplo, se no momento de informar a quantidade de clientes a ser cadastrada ele colocar um valor que não pode ser convertido para inteiro (ex. um caracter qualquer), teremos um erro de lógica e uma exceção será gerada. Neste caso precisaríamos usar um tratamento de exceção (try/catch).
Questões para debate
- Por que foi utilizado uma variável do tipo String para pegar a opcão de escolha do usuário durante a exibição da menu principal? Qual a diferença se usássemos o tipo inteiro?
- Modularizar o programa em partes menores trás algumas vantagens? Quais?
- O que acontece quando acabar o espaço deste tamanho (quantidade)?
