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:
[wptab name=’Importar’]
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() {
}
}[/wptab]
[wptab name=’Tijolo’]
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");
}
}
}[/wptab]
[wptab name=’Cimento’]
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");
}
}
}[/wptab]
[wptab name=’Main’]
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();
}[/wptab]
[end_wptabset]
Arrays e ciclo “for”
[wptab name=’Arrays’]
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:
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
}[/wptab]
[wptab name=’Ciclo “For” primeiro tipo’]
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));
}[/wptab]
[wptab name=’Ciclo “For” segundo tipo’]
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);
}[/wptab]
[end_wptabset]
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);
}
}
