java collections api: listas - tecnologia da informação · 11.3.1 visualizar arrays como listas e...
TRANSCRIPT
COLÉGIO ESTADUAL ULYSSES GUIMARÃES
CURSO TÉCNICO PROFISSIONALIZANTE EM INFORMÁTICA
ERINALDO SANCHES NASCIMENTO
JAVA COLLECTIONS API: LISTAS
FOZ DO IGUAÇU
2013
LISTA DE QUADROS
QUADRO 1 – EXEMPLO DE LIST, LINKEDLIST E LISTITERATOR ........................... 3
QUADRO 2 – VISUALIZAR MATRIZ COMO LISTA E CONVERTER LISTA PARA
MATRIZ. ............................................................................................................... 7
QUADRO 3 – A CLASSE HORA. ................................................................................. 8
QUADRO 4 – CLASSE COMPARATOR PERSONALIZADA ..................................... 10
QUADRO 5 – MÉTODO SORT DE COLLECTIONS COM UM OBJETO
PERSONALIZADO DE COMPARATOR ............................................................. 11
SUMÁRIO
11 LISTAS NO JAVA COLLECTIONS API ................................................................ 1 11.1 INTERFACE COLLECTION ................................................................................. 1 11.2 ITERADORES ..................................................................................................... 3 11.3 LISTA ENCADEADA............................................................................................ 3 11.3.1 Visualizar Arrays como Listas e Converter Listas para Arrays ......................... 6 11.3.2 Ordenar com a Interface Comparator ............................................................... 8 11.4 EXERCÍCIOS .................................................................................................... 12 11.5 BIBLIOGRAFIA .................................................................................................. 13
1
11 LISTAS NO JAVA COLLECTIONS API
A linguagem Java inclui, na sua biblioteca, uma aplicação de estruturas de
dados comuns. Esta parte da linguagem é popularmente conhecida como a API
Collections. O TAD lista é uma das estruturas de dados implementadas na API
Collections.
11.1 INTERFACE COLLECTION
A API Collections reside no pacote java.util. A ideia de uma coleção que
armazena uma coleção de objetos tipados de forma idêntica, é captada na interface
Collection.
Muitos dos métodos na interface Collection fazem as coisas que seus nomes
sugerem. Estes métodos estão resumidos na Tabela 1.
Método Descrição
boolean add(E obj) Adiciona obj para a coleção chamada.
boolean addAll(Collection<? extends E> c) Adiciona todos os elementos de c
para a coleção chamada.
binarySearch() Localiza um objeto em uma lista.
void clear() Remove todos os elementos da
coleção chamada.
boolean contains(Object obj) Retorna true se obj é um elemento da
coleção chamada.
boolean containsAll(Collection<?> c) Retorna true se a coleção invocada
contém todos os elementos de c.
copy() Copia referências de uma lista para
outra.
disjoint() Determina se duas coleções não têm
elementos em comum.
boolean equals(Object obj) Retorna true se a coleção invocada e
obj forem iguais.
2
Método Descrição
fill() Define cada elemento da lista para se
referir a um objeto especificado.
frequency() Calcula quantos elementos da
coleção são iguais ao elemento
especificado.
int hashCode() Retorna o código hash para a coleção
chamada.
boolean isEmpty() Retorna true se a coleção invocada
estiver vazia.
Iterator<E> iterator() Retorna um iterador para a coleção
chamada.
max() Retorna o maior elemento em uma
coleção.
min() Retorna o menor elemento de uma
coleção.
boolean remove(Object obj) Remove uma ocorrência de obj da
coleção chamada.
boolean removeAll(Collection<?> c) Remove todos os elementos de c da
coleção chamada.
boolean retainAll(Collection<?> c) Remove todos os elementos da
coleção invocada exceto aqueles em
c.
reverse() Inverte os elementos de uma lista.
shuffle() Ordena aleatoriamente os elementos
de uma lista.
sort() Classifica os elementos de uma lista.
int size() Retorna o número de elementos
mantidos na coleção chamada.
Object[] toArray() Retorna uma matriz que contém a
cópia de todos os elementos
armazenados na coleção chamada.
<T> T[] toArray(T array[]) Retorna uma matriz que contém a
3
Método Descrição
cópia dos elementos da coleção
chamada.
Tabela 1 - Os métodos definidos por Collection.
11.2 ITERADORES
Coleções que implementam a interface Iterable deve fornecer um método
chamado iterator que retorna um objeto do tipo Iterator. O Iterator é uma interface
definida no pacote java.util.
Através do método iterator, cada coleção pode criar e retornar para o cliente
um objeto que implementa a interface Iterator e armazenar internamente seu
conceito de uma posição atual.
Quando se tem uma coleção de objetos, tais como os nós de uma lista
encadeada, muitas vezes é preciso passar por todos os objetos da coleção, um de
cada vez e executar alguma ação em cada objeto. Um iterador é qualquer objeto
que permite percorrer a lista desta forma.
11.3 LISTA ENCADEADA
O Quadro 1 demonstra várias operações sobre listas encadeadas. O
programa cria duas listas encadeadas de Strings. Os elementos da lista são
adicionados de uma para a outra. Em seguida, todas as Strings são convertidas em
maiúsculas, e uma série de elementos são excluídos.
Quadro 1 – Exemplo de List, LinkedList e ListIterator
1 package listaencadeada;
2
3 import java.util.LinkedList;
4
4 import java.util.List;
5 import java.util.ListIterator;
6
7 public class ListaEncadeadaIterador {
8 public static void main(String[] args) {
9 //adiciona os elementos de cores para lista1
10 String[] cores1 =
11 {"preto","amarelo","azul","verde","prata","laranja"};
12 List<String> lista1 = new LinkedList<String>();
13 for (String cor : cores1)
14 lista1.add(cor);
15 //adiciona os elementos de cores2 para lista2
16 String[] cores2 =
17 {"dourado", "branco", "marrom", "azul", "cinza", "prata"};
18 List<String> lista2 = new LinkedList<String>();
19 for (String cor : cores2)
20 lista2.add(cor);
21
22 lista1.addAll(lista2);//concatena listas
23 lista2 = null;//libera recursos
24 imprimeLista(lista1);//imprime os elementos da lista1
25
26 converteStringsParaMaiuscula(lista1); //converte string para
maiúscula
27 imprimeLista(lista1);//imprime os elementos da lista1
28
29 System.out.print("\nExclusão dos elementos 4 a 6...");
30 removeItens(lista1, 4, 7); //remove os itens 4-6 da lista
31 imprimeLista(lista1);//imprime os elementos da lista1
32 imprimeListaReversa(lista1);//imprime a lista em ordem reversa
33 }//fim do método principal
34
35 private static void imprimeLista(List<String> lista){
5
36 System.out.println("\nLista: ");
37 for (String cor : lista)
38 System.out.printf("%s ", cor);
39 System.out.println();
40 }//fim do método imprimeLista
41
42 private static void converteStringsParaMaiuscula(List<String> lista){
43 ListIterator<String> iterador = lista.listIterator();
44 while (iterador.hasNext()){
45 String cor = iterador.next();//obtem item
46 iterador.set(cor.toUpperCase());//converte para maiúscula
47 }//fim do loop
48 }//fim do método
49
50 private static void removeItens(List<String> lista,
51 int inicio, int fim){
52 lista.subList(inicio, fim).clear();//remove itens
53 }//fim do método
54
55 private static void imprimeListaReversa(List<String> lista){
56 ListIterator<String> iterador = lista.listIterator(lista.size());
57 System.out.println("\nLista Revertida:");
58 //imprime a lista em ordem reversa
59 while (iterador.hasPrevious())
60 System.out.printf("%s ", iterador.previous());
61 }//fim do método
62 }//fim da classe
As linhas 12 e 18 criam as LinkedLists lista1 e lista2 do tipo String.
LinkedList é uma classe genérica que tem um parâmetro de tipo para especificar o
tipo de argumento String, neste exemplo. As linhas 13-14 e 19-20 acrescentam
elementos das matrizes de cores1 e cores2 até o final de lista1 e lista2,
respectivamente.
6
A linha 22 chama o método de List, addAll, para anexar todos os elementos
de lista2 até o final de lista1. Linha 23 define lista2 como nulo, de modo que a
LinkedList para o qual lista2 se refere possa ser lixo coletado. A linha 24 chama o
método imprimetLista (linhas 35-40) para exibir a saída de conteúdo de lista1. A
linha 26 chama o método converteStringsParaMaiuscula (linhas 42-48) que converte
cada elemento String para letras maiúsculas, seguida da linha 27 que chama
novamente imprimeLista para exibir as sequências modificadas. A linha 30 chama o
método removeItems (linhas 50-53) que remove os elementos a partir de índice 4
até, mas não incluindo, o índice de 7 da lista. A linha 32 chama o método
imprimeListaReversa (linhas 55-61) que imprime a lista em ordem inversa.
A figura 1 exibe a saída produzida pela classe apresentada no quadro 1.
Figura 1 – Saída produzida pela classe ListaEncadeadaIterador.
11.3.1 Visualizar Arrays como Listas e Converter Listas para Arrays
O quadro 2 usa o método Arrays asList para exibir uma matriz como uma
lista e usa o método List toArray para obter uma matriz de uma coleção LinkedList.
O programa chama o método asList para criar uma exibição de lista de uma matriz,
que é usado para inicializar um objeto LinkedList, em seguida, adiciona uma série de
Strings para o LinkedList e chama o método toArray para obter uma matriz contendo
referências para as Strings.
7
Quadro 2 – Visualizar matriz como lista e converter lista para matriz.
1 package listaencadeada;
2
3 import java.util.Arrays;
4 import java.util.LinkedList;
5
6 public class VisualizarArrayComoLista {
7 public static void main(String[] args) {
8 String[] cores = {"preto", "azul", "amarelo"};
9 LinkedList<String> links =
10 new LinkedList<String>(Arrays.asList(cores));
11 links.addLast("red");
12 links.add("violeta");
13 links.add(3, "verde");
14 links.addFirst("azul claro");
15
16 cores = links.toArray(new String[links.size()]);
17
18 System.out.println("Cores: ");
19
20 for (String cor : cores)
21 System.out.println(cor);
22 }
23 }
A figura 2 exibe a saída produzida pela classe apresentada no quadro 2.
8
Figura 2 – Saída produzida pela classe VisualizArrayComoLista.
11.3.2 Ordenar com a Interface Comparator
O quadro 3 cria a classe Hora, que representa as horas com horas, minutos
e segundos.
Quadro 3 – A classe Hora.
1 package listaencadeada;
2
3 public class Hora {
4 private int hora;
5 private int minuto;
6 private int segundo;
7
8 public Hora(){
9 this(0, 0, 0);
10 }
11 public Hora(int h){
12 this(h, 0, 0);
13 }
14 public Hora(int h, int m){
15 this(h, m, 0);
9
16 }
17 public Hora(int h, int m, int s){
18 setHorario(h, m, s);
19 }
20 public Hora(Hora hora){
21 this(hora.getHora(), hora.getMinuto(), hora.getSegundo());
22 }
23
24 public void setHorario(int h, int m, int s) {
25 setHora(h);
26 setMinuto(m);
27 setSegundo(s);
28 }
29 public void setHora(int h) {
30 if (h >= 0 && h < 24)
31 hora = h;
32 else
33 throw new IllegalArgumentException
34 ("A hora deve estar entre 0-23");
35 }
36
37 public void setMinuto(int m) {
38 if (m >= 0 && m < 60)
39 minuto = m;
40 else
41 throw new IllegalArgumentException
42 ("O minuto deve estar entre 0-59");
43 }
44
45 public void setSegundo(int s) {
46 if (s >= 0 && s < 60)
47 segundo = ((s >= 0 && s < 60)? s : 0);
48 else
10
49 throw new IllegalArgumentException
50 ("O segundo deve estar entre 0-59");
51 }
52
53 public int getHora() {
54 return hora;
55 }
56
57 public int getMinuto() {
58 return minuto;
59 }
60
61 public int getSegundo() {
62 return segundo;
63 }
64
65 public String toUniversalString(){
66 return String.format("%02d:%02d:%02d",
67 getHora(),getMinuto(),getSegundo());
68 }
69 }
O quadro 4 cria a classe ComparaHora, que implementa a interface
Comparator para comparar dois objetos Hora.
Quadro 4 – Classe Comparator personalizada
1 package listaencadeada;
2
3 import java.util.Comparator;
4
5 public class ComparaHora implements Comparator<Hora> {
6 public int compare(Hora hora1, Hora hora2){
11
7 int comparaHora =
8 hora1.getHora() - hora2.getHora();
9 if (comparaHora != 0)
10 return comparaHora;
11 int comparaMinuto =
12 hora1.getMinuto() - hora2.getMinuto();
13 if (comparaMinuto != 0)
14 return comparaMinuto;
15 int comparaSegundo =
16 hora1.getSegundo() - hora2.getSegundo();
17 return comparaSegundo;
18 }
19 }
O quadro 5 classifica uma lista usando a classe Comparator personalizada
ComparaHora. A linha 9 cria um ArrayList do objeto Hora. Tanto ArrayList e List são
tipos genéricos e aceitam um argumento que especifica o tipo de elemento da
coleção. As linhas 10-14 criam cinco objetos Hora e adiciona-os à lista. A linha 16
chama o método de classificação, passando-o como um objeto da classe
ComparaHora.
Quadro 5 – Método sort de Collections com um objeto personalizado de Comparator
1 package listaencadeada;
2
3 import java.util.ArrayList;
4 import java.util.Collections;
5 import java.util.List;
6
7 public class ComparaOrdena {
8 public static void main(String[] args) {
8 List<Hora> lista = new ArrayList<Hora>();
9 lista.add(new Hora(6, 24, 34));
12
10 lista.add(new Hora(18, 14, 58));
11 lista.add(new Hora(6, 5, 34));
12 lista.add(new Hora(12, 14, 58));
13 lista.add(new Hora(6, 24, 22));
14 System.out.printf("Elementos fora de ordem: \n%s\n", lista);
15 Collections.sort(lista, new ComparaHora());
16 System.out.printf("Elementos classificados: \n%s\n", lista);
17 }
18 }
11.4 EXERCÍCIOS
1. Crie e exiba em ordem crescente uma lista contendo os elementos de uma matriz
de naipes de cartas.
2. Crie e exiba em ordem decrescente uma lista contendo os elementos de uma
matriz de naipes de cartas.
3. Escreva um programa de reservas de bilhetes de linha aérea. O programa exibe
um menu com as seguintes opções: reserva de bilhete, cancelamento de bilhete,
verificação se um bilhete está reservado para uma pessoa particular e exibição
dos passageiros. A informação é mantida alfabeticamente em uma lista
encadeada (ligada) de nomes. Os limites no número de assentos devem ser
criados através de dois vetores multidimensionais, representando o lado
esquerdo e o lado direito da aeronave.
A figura abaixo representa uma aeronave Airbus A320.