Artigos Java Desmistificando a Certificação SCJP6 Parte VII - Parte 2/3

Declaração, Iniciação e Construção de Arrays

No Java, os arrays são objetos que guardam várias variáveis do mesmo tipo. Eles podem conter referências ou primitivos.

Os arrays são bastante eficientes, mas na maior parte dos casos o ideal será utilizar um dos tipos Collection do pacote java.util, incluindo ArraysList, HashMap e TreeSet.

Declarando um Array

Ao declarar a variável de referência procure sempre inserir os colchetes logo após o tipo declarado. Desse modo, o programador que ler o código poderá notar, facilmente, que se trata de um array long e não de um tipo primitivo long. Abaixo segue algumas formas válidas de declarar um array: 


        int [ ] numero1;
        int numero [ ]; // colchetes após o identificador. Válido, porém, menos legível.
        Threads th [ ];
        Threads [ ] th1;
        String [ ] [ ] [ ] nomes;
        String [ ] nomes1 [ ];

Instanciando arrays

Instanciar um array quer dizer criar o objeto array no heap, aliás, onde todos os objetos residem. Para criarmos um objeto array, Java terá que saber quanto de espaço poderá ser alocado, então, é preciso especificar o tamanho do array no momento da instanciação.

Perceba que os arrays multidimensionais são basicamente arrays com outros arrays. Então, um array bidimensional de tipo int será, na verdade, um objeto com tipo de array int (int [ ]), em que cada elemento desse array fará referência a outro array de int.

A segunda dimensão guardará os tipos primitivos int. O próximo código declara e instancia um array bidimensional do tipo float. 


        float [ ] [ ] tabelas = new float [6] [ ];

Veja que somente os primeiros colchetes tem um tamanho. Isso é permitido em Java, já que a JVM precisa saber apenas o tamanho do objeto atribuído á variável de referência tabelas.

Inicializando um array

Array de objetos não armazena objetos, mas sim referências a objetos. Elementos individuais do array podem ser acessados com um número de índice. O número de índice inicia sempre no zero, ou seja, para um array de cinco elementos, os números de índice irão de 0 a 4.

O índice de um array não pode ser negativo. Em seguida, temos tentativas inválidas e válidas de acesso a um array. 


        int [ ] a = new int [6];
        a[5] = 2;
        a[6] = 3; // exceção, o índice só vai até 5

        int [ ] b = new int [3];
        int c = -4;
        b[c] = 5 // exceção, o índice não pode ser negativo

A variável length nos informa quantos elementos o array possui, mas não informa se esses elementos foram inicializados.

Se o tipo declarado para o array for uma classe, é possível adicionar nele objetos de qualquer subclasse do tipo declarado. Por exemplo, se Carro for uma subclasse de Automovel e Automovel for uma subclasse de MeioDeTransporte, em um array de MeioDeTransporte você poderá inserir: Carro, MeioDeTransporte e Automovel.

Se o array for declarado como um tipo de Interface, seus elementos poderão fazer referência a qualquer instância das classes que implementem a interface declarada, obviamente.

Você pode ser questionado se é válido um array int ser inserido ao primeiro elemento de um array composto de arrays int, conforme no exemplo a seguir. 


        int [ ] [ ] cadernos = new int [2][];
        int [ ] numericos = new int [5];
        int numero =6;
        cadernos [0] = numero; //inválido, pois se espera uma referência a um array
        cadernos [0] = numéricos;

Mais um exemplo:


        Tiger [ ] [ ] myTigers = new Tiger [3] [ ];
        Tiger [ ] moreTigers = new Gato [4];
        myTigers = myTigers[0]; // Não é possível atribuir uma referência array de uma dimensão a uma referência array
        de duas dimensões.
        myTigers = myTigers [0] [0]; // Não é possível atribuir uma referência a um objeto a um array.
        myTigers[2] = myTigers[2] [3]; //Espera-se uma referêcia array de uma dimensão para essa atribuição.
        myTigers[0][1] = moreTigers; //Não é possível atribuir um objeto array a uma referência não array.

Blocos de inicialização

Já tratamos sobre 2 lugares de uma classe em que se pode colocar código que realize operações: construtores e métodos. Os blocos de iniciação são o 3º lugar onde operações podem ser feitas. Os blocos de iniciação são executados quando a classe é carregada pela 1ª vez (bloco estático) ou quando uma instância é criada (bloco de inicialização de instância, em outras palavras, não estático). Avalie um exemplo de bloco estático: 


        package devmedia;

        class lnicializacao {
        static int a;
        static {
        a = 5;
        }
        }

        public class Testing {
        public static void main(String args[]) {
        System.out.println(lnicializacao.a);
        }
        }

Observe atentamente o exemplo e a saída:


        package devmedia;

        class Inicializacao {
        static int a;
        static {
        a = 9;
        System.out.println("1º bloco estático: " + a);
        }
        static {
        a = 500;
        System.out.println("2º bloco estático: " + a);
        }
        static {
        a = 5000;
        System.out.println("3º bloco estático " + a);
        }
        }

        public class Teste {
        public static void main(String args[]) {
        System.out.println(Inicializacao.a);
        }
        }

Saída:
1º bloco estático: 9
2º bloco estático: 500
3º bloco estático 5000
5000

Na última parte abordaremos classes Wrapper, Autoboxing e aplicaremos um mini-teste.

Leia todos artigos da série