JAVA COLLECTIONS API: LISTAS - Tecnologia da Informação · 11.3.1 Visualizar Arrays como Listas e...

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


28

29 System.out.print("\nExclusão dos elementos 4 a 6...");

30 removeItens(lista1, 4, 7); //remove os itens 4-6 da lista


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


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());


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.


2

3 import java.util.Arrays;

4 import java.util.LinkedList;

5

6 public class VisualizarArrayComoLista {


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.


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


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


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


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


2

3 import java.util.ArrayList;

4 import java.util.Collections;

5 import java.util.List;

6

7 public class ComparaOrdena {


8 List<Hora> lista = new ArrayList<Hora>();

9 lista.add(new Hora(6, 24, 34));

12





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.

13

11.5 BIBLIOGRAFIA

DEITEL, Paul; DEITEL, Harvey. Java for Programmers. 2nd Ed. Boston: Pearson

Education, Inc., 2012

SAVITCH, Walter. Absolute Java, 5ª ed. New Jersey: Pearson Education, 2012.

WEISS, Mark A. Data Structures and Algorithm Analysis in Java, 3rd Ed. USA:

Pearson2012

JAVA COLLECTIONS API: LISTAS - Tecnologia da Informação · 11.3.1 Visualizar Arrays como Listas e...

Documents

Transcript of JAVA COLLECTIONS API: LISTAS - Tecnologia da Informação · 11.3.1 Visualizar Arrays como Listas e...