Java – Arrays e ciclo “For”

Para dar seguimento aos tutoriais anteriores, não faria sentido não falar de 3 componentes muito úteis em Java e que poderão facilitar a vida a quem está a programar! Começando por explicar o conceito e utilização de arrays, passando pela iteração dos mesmos com ciclos (for e while) e para terminar  HashMaps. O que são estes componentes e em que podem ser úteis? Como usar? Leia o artigo e deixe-nos a sua opinião no final!

Correção do desafio

Após termos lançado um desafio no último tutorial, que pode ser consultado aqui, deixamos ao leitor a devida correção:

Antes de demonstrar as classes novas, é importante clarificar que a classe importar, que será a classe “pai”, irá ter o seguinte corpo:

public class Importar implements Runnable{
    @Override
    public void run() {     
    }
}

A classe tijolo será uma derivada da classe importar:

public class Tijolo extends Importar{
    @Override
    public void run() {
           // Para que nunca pare de correr, colocamos dentro de um ciclo
        while(true){            
            // De 5 em 5 segundos vai escrever
            try {
                Thread.sleep(5000);
            } catch (InterruptedException ex) {
            }
            System.out.println("Importação de tijolo feita");
        }
    }
    
}

A classe cimento será uma derivada da classe importar:

public class Cimento extends Importar{

    @Override
    public void run() {
           // Para que nunca pare de correr, colocamos dentro de um ciclo
        while(true){            
            // De 5 em 5 segundos vai escrever
            try {
                Thread.sleep(7000);
            } catch (InterruptedException ex) {
            }
            System.out.println("Importação de cimento feita");
        }
    }
}

Para testar deverá usar a seguinte classe main:

public static void main(String[] args) {
        Exportar exportacao = new Exportar();
        Produzir producao = new Produzir();
        Cimento cimento = new Cimento();
        Tijolo tijolo = new Tijolo();
        
        Thread t1 = new Thread(exportacao);
        Thread t2 = new Thread(producao);
        Thread t3 = new Thread(cimento);
        Thread t4 = new Thread(tijolo);
        t1.start();t2.start();t3.start();t4.start(); 
    }

Arrays e ciclo “for”

Todos os programadores sabem o que é um array mas, para os mais novatos na linguagem e na área, array é um vetor! Imagine o leitor o seguinte cenário:

array

A variável “meuArray” guarda a palavra “OLÁ!”. Cada caracter, inclusive o ponto de exclamação, ocupam uma posição no array! Em qualquer situação, os índices em Java começam sempre no 0 (zero). É por isso que se diz que para os programadores “o zero também conta”. Como podemos ver acima, o tamanho do array é 4 posições mas termina no índice 3! Um array é definido da seguinte forma:

ArrayList [nome do array] = new ArrayList<[tipo do objeto a passar]>();

Onde em [nome do array] é o nome que lhe queremos dar e, [tipo do objecto a passar] é o tipo que pode ser String, Int, Float, ou até mesmo alguma classe que o leitor tenha criado!

Para simular o que demonstramos na imagem, o leitor poderá usar o seguinte código em que o objectivo é inserir letras dentro do array!

public static void main(String[] args) {
        // ArrayList<[tipo do objeto]> [nome do array] = new ArrayList<>();
        // Neste caso vamos querer passar objetos do tipo string logo
        // ArrayList<String> [nome do array] = new ArrayList<>();
        ArrayList<String> meuArray = new ArrayList<>();
        String letra1 = "O";
        String letra2 = "L";
        String letra3 = "A";
        String letra4 = "!";
        // Adicionar a primeira letra
        // Tamanho do array = 1. Indice 0 ocupado
        meuArray.add(letra1);
        
        // Adicionar a segunda letra
        // Tamanho do array = 2. Indice 0 e 1 ocupados
        meuArray.add(letra2);
        
        // Adicionar a terceira letra
        // Tamanho do array = 3. Indice 0, 1 e 2 ocupados
        meuArray.add(letra3);
        
        // Adicionar a terceira letra
        // Tamanho do array = 4. Indice 0, 1, 2 e 3 ocupados
        meuArray.add(letra4);
        
        // Podemos continuar a adicionar letras
    }

Para testarmos de forma correcta o que escrevemos no array, precisamos de percorrer o mesmo! Para isso, existem funcionalidades que nos permitem aceder aos índices do array de forma muito fácil! Um deles é o ciclo for. Este ciclo pode ser utilizado de várias formas. Uma delas é:

// Percorrer de 0 até ao tamanho (size) do array.
// Neste caso vai de 0 até 1
// A cada iteração incrementa
for(int i = 0; i < meuArray.size(); i++){
       // Escrever o valor da variável i:
       System.out.println(i);
       // meuArray.get(i) -> vai buscar à posição i o que o array tem
       System.out.println(meuArray.get(i));
}

Outro exemplo de utilização do ciclo for e percorrer o array, poderá ser utilizando o tipo do objecto que está presente. Como exemplo:

// Vou buscar string a string
// ao meuArray
   for(String a: meuArray){
        System.out.println(a);
   }

Exercício

Para testar a introdução teórica dada em cima, vamos começar por criar uma classe chamada “Gato” com a seguinte estrutura:

public class Gato {
    String name;
    
    public Gato(String name){
        this.name = name;
    }
}

Na função main, teremos de construir objectos do tipo gato e, o nosso Array irá conter objectos do tipo Gato! Tal cenário é possível da seguinte forma:

public static void main(String[] args) {
        ArrayList<Gato> gatos = new ArrayList<>();
        // Criar dois gatos
        Gato gato1 = new Gato("Tobias");
        Gato gato2 = new Gato("Zacarias");
        // Inserir no array os dois gatos
        gatos.add(gato1);
        gatos.add(gato2);       
    }

Com isto, temos dois gatos dentro do nosso Array! Para testar, basta simplesmente utilizar os ciclos for. Como o leitor deve ter lido, existem dois tipos pelo que vamos testar com ambos:

public static void main(String[] args) {
        ArrayList<Gato> gatos = new ArrayList<>();
        // Criar dois gatos
        Gato gato1 = new Gato("Tobias");
        Gato gato2 = new Gato("Zacarias");
        // Inserir no array os dois gatos
        gatos.add(gato1);
        gatos.add(gato2);    
        
        System.out.println("Teste com o tipo 1 de for");
        for(int i = 0; i < gatos.size(); i++){
            System.out.println(gatos.get(i).name);
        }
        
        System.out.println("Teste com o tipo 2 de for");
        for(Gato g: gatos){
            System.out.println(g.name);
        }
    }

Ficou com dúvidas ou está mestre em arrays e ciclos? Então não perca o próximo tutorial que irá explicar a utilização de ciclos While e o que são HashMaps!