Um array unidimensional é uma lista de variáveis relacionadas. Essas listas são co- muns em programação. Por exemplo, você pode usar um array unidimensional para armazenar os números de conta dos usuários ativos em uma rede. Para declarar um array unidimensional, você usará esta forma geral:
tipo[ ] nome-array = new tipo[tamanho];
Aqui, tipo declara o tipo de elemento do array. (O tipo de elemento também é chamado de tipo base.) O tipo de elemento determina o tipo de dado de cada elemen- to contido no array. O número de elementos que o array conterá é determinado por
tamanho. Como os arrays são implementados como objetos, a criação de um array
é um processo de duas etapas. Primeiro, você declara uma variável de referência de array. Depois, aloca memória para o array, atribuindo uma referência dessa memória à variável de array. Portanto, os arrays Java são alocados dinamicamente com o uso do operador new.
Veja um exemplo. A linha a seguir cria um array int de 10 elementos e o vincula a uma variável de referência de array chamada sample:
int[] sample = new int[10];
Essa declaração funciona como uma declaração de objeto. A variável sample contém uma referência à memória alocada por new. Essa memória é suficientemente grande para conter 10 elementos de tipo int. Como ocorre com os objetos, é possível dividir a declaração anterior em duas. Por exemplo:
int[] sample;
sample = new int[10];
Nesse caso, quando sample é criada, ela não referencia um objeto físico. Só após a segunda instrução ser executada, sample é vinculada a um array.
Um elemento individual de um array é acessado com o uso de um índice. Um
índice descreve a posição de um elemento dentro de um array. Em Java, todos os ar-
rays têm zero como o índice de seu primeiro elemento. Já que a variável sample tem 10 elementos, ela tem valores de índice que vão de 0 a 9. Para indexar um array, de-
vemos especificar o número do elemento desejado, inserido em colchetes. Portanto, o primeiro elemento de sample é sample[0] e o último é sample[9].
Um ponto importante a ser entendido é que cada elemento do array é usado da mesma forma que uma variável “comum”. Por exemplo, você pode atribuir um valor a um elemento, como mostrado aqui:
sample[0] = 3;
Após essa instrução ser executada, o primeiro elemento de sample terá o valor 3. Você pode obter o valor de um elemento para usar em uma expressão, como mostrado a seguir:
2 * sample[0]
Aqui, se sample[0] contiver 3, o resultado da expressão anterior será 6.
O programa a seguir demonstra sample carregando-o com os números de 0 a 9 e exibindo seu conteúdo:
// Demonstra um array unidimensional. class ArrayDemo {
public static void main(String[] args) { int[] sample = new int[10];
int i;
for(i = 0; i < 10; i = i+1) sample[i] = i;
for(i = 0; i < 10; i = i+1)
System.out.println("This is sample[" + i + "]: " + sample[i]); }
}
A saída do programa é mostrada aqui:
This is sample[0]: 0 This is sample[1]: 1 This is sample[2]: 2 This is sample[3]: 3 This is sample[4]: 4 This is sample[5]: 5 This is sample[6]: 6 This is sample[7]: 7 This is sample[8]: 8 This is sample[9]: 9
Conceitualmente, o array sample tem a seguinte aparência:
0
sample [0] sample [1] sample [2] sample [3] sample [4] sample [5] sample [6] sample [7] sample [8] sample [9]
1 2 3 4 5 6 7 8 9
Os arrays são comuns em programação porque nos permitem lidar facilmente com grandes quantidades de variáveis relacionadas. Por exemplo, o programa abaixo encontra o valor mínimo e máximo do array nums percorrendo o array com o uso de um laço for:
// Encontra o valor mínimo e máximo de um array. class MinMax {
public static void main(String[] args) { int[] nums = new int[10];
int min, max;
nums[0] = 99; nums[1] = -10; nums[2] = 100123; nums[3] = 18; nums[4] = -978; nums[5] = 5623; nums[6] = 463; nums[7] = -9; nums[8] = 287; nums[9] = 49;
min = max = nums[0]; for(int i=1; i < 10; i++) { if(nums[i] < min) min = nums[i]; if(nums[i] > max) max = nums[i]; }
System.out.println("min and max: " + min + " " + max); }
}
A saída do programa é mostrada a seguir:
min and max: -978 100123
Observe como o programa funciona. Primeiro ele fornece tanto a min quanto a max o valor de nums[0]. Em seguida, percorre o array nums, um elemento de cada vez, começando com o segundo elemento. Dentro do laço, se o valor de nums[i] for me- nor do que min, ele passará a ser o novo valor mínimo. Da mesma forma, se o valor de nums[i] for maior do que max, ele será o novo valor máximo. O processo continua até todos os elementos de nums serem testados. Como resultado, quando o laço ter- minar, min terá o menor valor do array e max terá o maior.
No programa anterior, o array nums recebeu valores manualmente, usando 10 instruções de atribuição separadas. Embora isso esteja perfeitamente correto, há uma maneira mais fácil de fazê-lo. Os arrays podem ser inicializados quando são criados. A forma geral de inicialização de um array unidimensional é esta:
tipo[ ] nome-array = {val1, val2, val3,..., valN};
Aqui, os valores iniciais são especificados por val1 até valN. Eles são atribuídos em sequência, da esquerda para a direita, em ordem de índice. Java aloca automaticamen- te um array grande o suficiente para conter os inicializadores especificados. Não há
necessidade de usar o operador new explicitamente. Por exemplo, esta é uma maneira melhor de escrever o programa MinMax:
// Usa inicializadores de array. class MinMax2 {
public static void main(String[] args) { int[] nums = { 99, -10, 100123, 18, -978, 5623, 463, -9, 287, 49 }; int min, max;
min = max = nums[0]; for(int i=1; i < 10; i++) { if(nums[i] < min) min = nums[i]; if(nums[i] > max) max = nums[i]; }
System.out.println("Min and max: " + min + " " + max); }
}
Os limites do array são impostos rigorosamente em Java; é um erro de tempo de exe- cução estar abaixo ou acima da extremidade de um array. Se quiser confirmar isso por sua própria conta, teste o programa a seguir, o qual intencionalmente excede um array:
// Demonstra uma situação que excede um array. class ArrayErr {
public static void main(String[] args) { int[] sample = new int[10];
int i;
// gera a transposição de um array for(i = 0; i < 100; i++)
sample[i] = i; }
}
Assim que i alcançar 10, uma ArrayIndexOutOfBoundsException será gerada e o programa será encerrado.
Inicializadores de array.
TENTE ISTO 5-1
Classificando um array
Bubble.java
Uma vez que um array unidimensional organiza os dados em uma lista linear que pode ser indexada, é fácil classificá-lo. Neste projeto, você aprenderá uma ma- neira simples de classificar um array. Como deve saber, há vários algoritmos de classificação. Há a classificação rápida, a classificação por troca e a classificação de shell, para citar apenas três. No entanto, a mais conhecida, simples e fácil de entender se chama classificação por bolha. Embora a classificação por bolha não seja muito eficiente – na verdade, geralmente seu desempenho é inaceitável para a classificação de arrays grandes –, ela pode ser usada de maneira eficaz na clas-
sificação de arrays pequenos. Porém, será usada aqui porque oferece um exemplo excelente que demonstra o poder dos arrays.
PASSO A PASSO
1. Crie um arquivo chamado Bubble.java.
2. A classificação por bolha obtém seu nome da maneira como executa a ope- ração de classificação. Ela usa a comparação repetida e, se necessário, a troca de elementos adjacentes do array. Nesse processo, valores pequenos se movem em direção a uma extremidade e os maiores em direção à outra. A classificação por bolha funciona percorrendo várias vezes o array e trocando os elementos que estiverem fora do lugar quando preciso.
Aqui está o código que forma a base da classificação por bolha. O ar- ray que está sendo classificado se chama nums.
// Esta é a classificação por bolha. for(a=1; a < size; a++)
for(b=size-1; b >= a; b--) {
if(nums[b-1] > nums[b]) { // se fora de ordem // troca elementos t = nums[b-1]; nums[b-1] = nums[b]; nums[b] = t; } }
Observe que a classificação se baseia em dois laços for. O laço interno veri- fica os elementos adjacentes do array, procurando elementos fora de ordem. Quando um par de elementos fora de ordem é encontrado, os dois elementos são trocados. A cada passagem, o menor dos elementos restantes se move para o local apropriado. O laço externo faz esse processo se repetir até o ar- ray inteiro ser classificado.
3. Aqui está o programa Bubble inteiro:
/*
Tente isto 5-1
Demonstra a classificação por bolha. */
class Bubble {
public static void main(String[] args) { int[] nums = { 99, -10, 100123, 18, -978, 5623, 463, -9, 287, 49 }; int a, b, t;
int size;
size = 10; // número de elementos a serem classificados
// exibe o array original
System.out.print("Original array is:"); for(int i=0; i < size; i++)