LP II
Professor: Wilton Souza
Array
Uma array é sempre um objeto, portanto, a variável
idades é uma referência. Vamos precisar criar um objeto
para poder usar a array. Como criamos o objeto-array?
int[] idades = new int[5];
O que fizemos foi criar uma array de int de 5
posições, e atribuir o endereço no qual ela foi criada.
Agora, podemos acessar as posições do array.
Array
No Java, os índices do array vão de 0 a n-1, onde n é
o tamanho dado no momento em que você criou o
array.
Se você tentar acessar uma posição fora desse
alcance, um erro ocorrerá durante a execução.
Arrays
É comum ouvirmos “array de objetos”. Porém
quando criamos uma array de alguma classe, ela
possui referências.
O objeto, como sempre, está na memória principal e,
na sua array, só ficam guardadas as referências
(endereços).
Arrays
Aluno[] alunos = new Aluno[5];
Aluno aluno = new Aluno ();
aluno.setNome(“Pedro”);
alunos[0] = aluno;
Arrays
Percorrer uma array é muito simples quando fomos
nós que a criamos:
for (int i = 0; i < idades.length; i++) {
System.out.println(idades[i]);
}
Arrays
O Java 5.0 traz uma nova sintaxe para percorremos
arrays.
for (int x : idades) {
System.out.println(x);
}
O mesmo é válido para arrays de referências. Esse for
nada mais é que um truque de compilação para
facilitar essa tarefa de percorrer arrays e torná-la mais
legível.
Listas
Um primeiro recurso que a API de Collections traz
são listas. Uma lista é uma coleção que permite
elementos duplicados e mantém uma ordenação
específica entre os elementos.
Em outras palavras, você tem a garantia de que,
quando percorrer a lista, os elementos serão
encontrados em uma ordem pré-determinada, definida
na hora da inserção dos mesmos.
Listas
A API de Collections traz a interface java.util.List,
que especifica o que uma classe deve ser capaz de
fazer para ser uma lista.
A implementação mais utilizada da interface List é a
ArrayList, que trabalha com um array interno para
gerar uma lista.
Lista
Para criar um ArrayList, basta chamar o construtor:
ArrayList lista = new ArrayList();
lista.add(“Leonardo");
lista.add(“Pedro");
lista.add("Maria");
Lista
Toda lista trabalha do modo mais genérico possível.
Isto é, não há uma ArrayList específica para Strings,
outra para Números, outra para Datas etc. Todos os
métodos trabalham com Object.
Assim, é possível criar, por exemplo, uma lista de
Contas Correntes:
Lista
Aluno a1 = new Aluno ();
a1.setNome(“Thiago”);
Aluno a2 = new Aluno ();
a2.setNome(“João”);
Aluno a3 = new Aluno ();
a3.setNome(“Jeferson”);
List alunos = new ArrayList();
contas.add(a1);
contas.add(a2);
contas.add(a3);
Lista
Para saber quantos elementos há na lista, podemos
usar o método size():
Há ainda um método get(int) que recebe como
argumento o índice do elemento que se quer
recuperar.
for (int i = 0; i < alunos.size(); i++) {
alunos.get(i);
}
Lista
Há ainda outros métodos como remove() que recebe
um objeto que se deseja remover da lista; e
contains(), que recebe um objeto como argumento e
devolve true ou false, indicando se o elemento está ou
não na lista.
Generics
Aluno aluno = new Aluno ();
List lista = new ArrayList();
lista.add(“Sergio");
lista.add(Aluno );
O método get devolve um Object, precisamos fazer o
cast. Mas com uma lista com vários objetos de tipos
diferentes, isso pode não ser tão simples.
Generics
Geralmente, não nos interessa uma lista com vários
tipos de objetos misturados.
A partir do Java 5.0, podemos usar o recurso de
Generics para restringir as listas a um determinado
tipo de objetos.
ArrayList<Aluno> alunos= ArrayList<Aluno>();
alunos.add(a1);
alunos.add(a2);
Listas com Generics
Repare no uso de um parâmetro ao lado de ArrayList:
ele indica que nossa lista foi criada para trabalhar
exclusivamente com objetos do tipo ContaCorrente.
O código abaixo traz uma segurança em tempo de
compilação:
contas.add("uma string");
// isso não compila mais!!
Listas com Generics
O uso de Generics também elimina a necessidade de
casting, já que, seguramente, todos os objetos
inseridos na lista serão do tipo ContaCorrente:
for(int i = 0; i < contas.size(); i++) {
ContaCorrente cc = contas.get(i); // sem casting!
System.out.println(cc.getSaldo());
}
Mapas
Um mapa é composto por um conjunto de
associações entre um objeto chave a um objeto valor.
Mapas
Mapas
O método put(Object, Object) da interface Map
recebe a chave e o valor de uma nova associação.
Para saber o que está associado a um determinado
objeto-chave, passa-se esse objeto no método
get(Object).
Mapa
Aluno a1 = new Aluno ();
a1.setNome(“Thiago”);
Aluno a2 = new Aluno ();
a2.setNome(“João”);
HashMap map= new HashMap();
mapaDeContas.put(“123", a1);
mapaDeContas.put(“321", a2);
Object obj = mapa.get(“123");
Aluno aluno = (Aluno) obj;
System.out.println(aluno.getSaldo());
Mapas
Assim como as coleções, um mapa no Java 5.0 é
parametrizado. O interessante é que ele recebe dois
parâmetros: a chave e o valor:
Mapas
ContaCorrente c1 = new ContaCorrente();
c1.deposita(10000);
ContaCorrente c2 = new ContaCorrente();
c2.deposita(3000);
HashMap<String, ContaCorrente> mapaDeContas;
mapaDeContas = new HashMap<String, ContaCorrente>();
mapaDeContas.put("diretor", c1);
mapaDeContas.put("gerente", c2);.
Exercícios
1) Faça um array de notas de dez posições. Calcule a
média de todas elas. Exiba no conjunto das notas
maiores do que a média calculada.
2) Crie uma classe que insira 30 mil números em um
ArrayList, faça também nessa classe um código que
leia os 30 mil dados inseridos no ArrayList e mostre
esses dados no console.
Exercícios
3) Crie uma classe Funcionario com os atributos e
métodos segundo a sua necessidade, crie também
uma classe de Teste para instanciar a classe
Funcionario e coloque suas referencias em um
HashMap.
Exercícios
4) Crie uma classe Banco que possui um ArrayList de
Conta chamada contas. A classe Banco terá somente
dois atributos: nomeDoBanco e contas. Crie um
método “void adicionaConta(Conta c)”, um método
“Conta recuperaConta(int numeroConta)”. Faça uma
classe de teste para instanciar essas classes.
5) Refaça o exercício anterior alterando o atributo
contas de ArrayList para HashMap.
