Listas (parte 2 de 3)

Tecnologia em Sistemas para Internet - IFMS

Aula 05 – Listas (parte 2)

Estruturas de DadosProf.º Msc. Sidney Roberto de Sousa

[email protected]

Tec. em Sistemas para Internet - IFMS 2

O que veremos nesta aula?

● Criando uma lista encadeada genérica● A interface List do pacote java.util● Formas de instanciação da interface List


Recapitulando...

● Na aula anterior, vimos uma classe que encapsula uma lista encadeada de valores inteiros

● Ou seja, uma instância daquela classe pode armazenar um conjunto teoricamente infinito de valores inteiros


Problema

● Digamos que desejamos criar uma lista encadeada para armazenar strings

● O que devemos fazer? talvez possamos →re-escrever a classe ListaEncadeada de tal forma que ela possa armazenar strings ao invés de valores inteiros

● Problema resolvido!


Problema

● Digamos que desejamos criar uma lista encadeada para armazenar strings

● O que devemos fazer? → talvez possamos re-escrever a classe ListaEncadeada de tal forma que ela possa armazenar strings ao invés de valores inteiros

● Problema resolvido!?


Problema

● Agora, digamos que estamos implementando um sistema complexo, no qual precisaremos utilizar listas de tipos variados →possivelmente até tipos complexos

● Ex.: lista de usuários, lista de clientes, lista de pedidos, etc.

● Solução: escrever uma cópia da classe ListaEncadeada para cada tipo desejado!


Vamos realmente fazer isto?


Como resolver este problema?

● Realmente, criar uma classe para cada tipo de dados pode ser extremamente inviável!

● A questão é: como escrever o código da classe ListaEncadeada somente uma vez, porém permitindo que o tipo do item a ser armazenado possa ser definido apenas no momento em que a lista for criada?

● Ou seja, precisamos escrever uma classe genérica!


Generics

● Generics ou programação genérica em Java é uma forma de determinar ao compilador qual o tipo que deve ser interpretado em um determinado trecho do programa

● Isto facilita muito o reúso de software no →nosso caso, escrever a classe ListaEncadeada somente uma vez!


Classes NoGenerico e ListaEncadeadaGenerica

(abaixo no blog)


A classe NoGenerico

public class NoGenerico<T> {

private T item;

private NoGenerico<T> proximoItem;

public NoGenerico() { proximoItem = null; }

// Getters e setters para os atributos da classe...

}


A classe NoGenerico


private T item;




}

A classe NoGenerico implementa um nó de uma lista genérica. Assim, cada instância da classe NoGenerico pode armazenar um valor do tipo desejado.


A classe NoGenerico


private T item;




}

A letra T identifica um tipo genérico. Assim, a classe NoGenerico pode utilizar o tipo genérico T em seus atributos e métodos para especificar o uso de um tipo que será definido posteriormente pelo trecho de código que utilizá-la. Você pode batizar o seu tipo genérico conforme o seu gosto. Por convenção, tipos genéricos são batizados com apenas uma letra maiúscula.


A classe NoGenerico


private T item;




}

Uma classe pode ter tantos tipos genéricos forem necessários à sua implementação. Obrigatoriamente, o trecho de código que utilizar a classe que contém os tipos genéricos deve definir qual será o tipo utilizado para cada tipo genérico.


A classe NoGenerico


private T item;




}

O valor do item a ser armazenado é definido com o tipo genérico.


A classe NoGenerico


private T item;




}

O próximo item após o item atual. Note que no instante da declaração do objeto é necessário definir qual será o tipo a ser utilizado. Como ainda não sabemos qual o tipo definitivo a ser utilizado, associamos o tipo T ao tipo do valor do próximo item.


A classe NoGenerico


private T item;




}

O tipo genérico não precisa ser especificado no construtor da classe.


A classe ListaEncadeadaGenerica

● Os métodos e atributos da classe ListaEncadeadaGenerica são parecidos com os da classe ListaEncadeada

● Porém, o tipo genérico é utilizado sempre que o tipo dos ítens armazenados precisa ser referenciado



public class ListaEncadeadaGenerica<T> {

private int tamanho;

private NoGenerico<T> primeiroItem;

private NoGenerico<T> ultimoItem;

public ListaEncadeadaGenerica() {

primeiroItem = null;

ultimoItem = null; tamanho = 0;

}

// Restante da classe...

}









ultimoItem = null; tamanho = 0;

}


}

A classe ListaEncadeadaGenerica utiliza o tipo genérico T para definir qual o tipo do valor a ser armazenado em cada item. O tipo genérico é propagado a cada item da lista no momento de sua instanciação.









ultimoItem = null;

tamanho = 0;

}


}

O primeiro e último ítens da lista são criados com o tipo genérico. Assim, quando a lista for criada, estes ítens estarão preparados para armazenar os valores desejados de forma apropriada.


Utilizando o tipo genérico nas operações da lista

public void adicionarNoInicio(T novoItem) {

if (tamanho == 0) {

primeiroItem = new NoGenerico<T>();

primeiroItem.setItem(novoItem);

ultimoItem = primeiroItem;

} else {

NoGenerico<T> antigoPrimeiroItem = primeiroItem;



primeiroItem.setProximoItem(antigoPrimeiroItem);

}

tamanho++;

}


Utilizando o tipo genérico nas operações da lista

public void adicionarNoInicio(T novoItem) {

if (tamanho == 0) {



ultimoItem = primeiroItem;

} else {

NoGenerico<T> antigoPrimeiroItem = primeiroItem;



primeiroItem.setProximoItem(antigoPrimeiroItem);

}

tamanho++;

}


Utilizando a lista encadeada genérica

ListaEncadeadaGenerica<String> listaEncadeada = new ListaEncadeadaGenerica<String>();

listaEncadeada.adicionarNoInicio("ao");

listaEncadeada.adicionarNoInicio("foi");

listaEncadeada.adicionarNoInicio("João");

listaEncadeada.adicionarNoFinal("bar");

listaEncadeada.adicionarNaPosicao("Paulo", 2);

NoGenerico<String> item = listaEncadeada.pegarItem(1);

// Imprime na tela:

// João Paulo foi ao bar

while (item != null) {

System.out.print(item.getItem() + " ");

item = item.getProximoItem();

}


Utilizando a lista encadeada genérica

ListaEncadeadaGenerica<Double> listaEncadeada = new ListaEncadeadaGenerica<Double>();

listaEncadeada.adicionarNoInicio(2.54);



listaEncadeada.adicionarNoFinal(76D);

listaEncadeada.adicionarNaPosicao(981.39, 2);

NoGenerico<Double> item = listaEncadeada.pegarItem(1);

// Imprime na tela:

// 0.1735 981.39 123.234 2.54 76.0


System.out.print(item.getItem() + " ");


}


Classe Cliente

public class Cliente {

private String cpf;

private Date dataAniversario;

private String nomeCompleto;

private String endereco;

// Getters e setters para os atributos...

}


Criando uma lista de clientes

Cliente cliente1 = new Cliente();

cliente1.setNomeCompleto("Ana Leite");


cliente2.setNomeCompleto("Augusto Macedo");


cliente3.setNomeCompleto("Maria dos Anjos Toledo");

ListaEncadeadaGenerica<Cliente> listaEncadeada = new ListaEncadeadaGenerica<Cliente>();

listaEncadeada.adicionarNoFinal(cliente1);

listaEncadeada.adicionarNoInicio(cliente2);

listaEncadeada.adicionarNaPosicao(cliente3, 2);

NoGenerico<Cliente> item = listaEncadeada.pegarItem(1);


System.out.println(item.getItem().getNomeCompleto());


}


A interface List do pacote java.util

● A interface List possui a definição de várias operações sobre listas

● É a alternativa mais adotada pelos programadores Java para a utilização de listas

● Por ser uma interface, ela não contém a implementação dos seus métodos; apenas a assinatura destes.

● Assim, existem duas implementações na JDK para o uso da interface List:● A classe ArrayList● A classe LinkedList


Instanciando uma lista do tipo List

List<Integer> lista1 = new ArrayList<Integer>();

List<Integer> lista2 = new LinkedList<Integer>();


A classe ArrayList

● A mais prática na maioria dos casos● Por baixo dos panos, ela:

● Oferece de fato acesso direto a um item da lista● Não precisa alocar um novo nó para inserir um item novo

● Na prática, a classe ArrayList implementa uma lista estática, de tamanho inicial 10

● Quando existe a necessidade de se inserir o décimo primeiro item, a lista se redimensiona de forma implícita

● No geral, tem melhor desempenho que a classe LinkedList


A classe ArrayList (vantagens e desvantagens)

● A mais prática na maioria dos casos● Por baixo dos panos, ela:

● Oferece de fato acesso direto a um item da lista● Não precisa alocar um novo nó para inserir um item novo

● Na prática, a classe ArrayList implementa uma lista estática, de tamanho inicial 10

● Quando existe a necessidade de se inserir o décimo primeiro item, a lista se redimensiona de forma implícita

● No geral, tem melhor desempenho que a classe LinkedList


A classe LinkedList

● Implementa uma lista encadeada● O acesso ao primeiro e último ítens é feito de forma mais

rápida do que o oferecido pela classe ArrayList● Por ser uma lista encadeada, o acesso aos ítens

intermediários não é feito de forma direta● Não costuma ser mais prática que ArrayList na maioria

dos casos● Possui um melhor desempenho quando a inserção,

leitura e remoção dos ítens da lista costumam ocorrer nas pontas da lista


A classe LinkedList (vantagens e desvantagens)

● Implementa uma lista encadeada● O acesso ao primeiro e último ítens é feito de forma

mais rápida do que o oferecido pela classe ArrayList● Por ser uma lista encadeada, o acesso aos ítens

intermediários não é feito de forma direta● Não costuma ser mais prática que ArrayList na

maioria dos casos● Possui um melhor desempenho quando a inserção,

leitura e remoção dos ítens da lista costumam ocorrer nas pontas da lista


Utilizando a interface List

● Como as classes ArrayList e LinkedList implementam a classe List, elas obrigatoriamente possuem a mesma assinatura de métodos

● Assim, independente da implementação escolhida, o uso da interface List é feito da mesma forma

● A real diferença entre as implementações só é percebida em termos de desempenho


Utilizando a interface List

Classe ExemploList

(abaixo no blog)


Adicionando ítens

// Inserindo ítens no final da lista

lista.add(12);

lista.add(38);

lista.add(827);

// Inserindo ítens no início da lista

lista.add(0, 125);

lista.add(0, 387);

lista.add(0, 82735);


Concatenando duas listas

List<Integer> listaExtra = new ArrayList<Integer>();

listaExtra.add(11);

listaExtra.add(22);

listaExtra.add(33);

// Adiciona todos os ítens da lista extra no final da

// primeira lista

lista.addAll(listaExtra);


Inserindo uma lista no meio da outra

listaExtra.add(44);

listaExtra.add(55);

listaExtra.add(66);

/**

* Adiciona todos os ítens da lista extra na posição

* desejada da primeira lista

*/

lista.addAll(3, listaExtra);


Removendo ítens por índice

/**

* Removendo ítens da lista pelo índice. Na interface

* List, os elementos são indexados na forma

* [0..tamanho da lista 1]

*/

lista.remove(0);

lista.remove(4);


Removendo ítens por ocorrência

/**

* Removendo um item da lista caso ele exista. O cast

* para Object é necessário para que o compilador

* diferencie a chamada ao método de remoção por

* ocorrência do método de remoção por índice. Retorna

* true caso o item exista; false c.c.

*/

lista.remove((Object) 77); // Retorna false


Verificando a ocorrência de um item

// Verifica se um item está contido na lista

if (lista.contains(12)) {

System.out.println("A lista contém o item 12.");

}


Pegando o índice de um ítem

// Imprime o índice da primeira ocorrência do item de

// valor 125

System.out.println(lista.indexOf((Object) 125));


Verificando a ocorrência de uma sublista

// Verifica se a lista contém uma sublista

if (lista.containsAll(listaExtra)) {

System.out.println("A primeira lista contém a lista extra!");

}


Substituindo um item

// Substituindo o elemento da terceira posição da lista

lista.set(3, 42);


Verificando se a lista está vazia

// Verifica se a lista está vazia

if (lista.isEmpty()) {

System.out.println("A lista está vazia.");

} else {

System.out.println("A lista contém " + lista.size() + " elemento(s).");

}


Verificando a última ocorrência de um valor na lista

System.out.println("A última ocorrência de 55 se dá na posição "

+ lista.lastIndexOf(55));


Pegando o tamanho da lista

System.out.println("Tamanho atual da lista: " + lista.size());


Pegando partes da lista

/**

* Pega uma parte da lista. O primeiro índice é inclusivo; o

* segundo é exclusivo.

*/

List<Integer> outraLista = lista.subList(2, 4);


Convertendo uma lista para vetor

// Converte a lista de inteiros em um vetor de objetos

Object[] vetor = lista.toArray();

// Converte a lista de inteiros em um vetor de inteiros

Integer[] vetorInteiros = new Integer[lista.size()];

lista.toArray(vetorInteiros);


Percorrendo uma lista

for (int i = 0; i < lista.size(); i++) {

System.out.print(lista.get(i) + " ");

}


Percorrendo uma lista com o laço for each

for (Integer item : lista) {

System.out.print(item + " ");

}


That's not all, folks!

Na próxima (e última) aula sobre listas, vamos empileirar e enfileirar algumas coisas...

Listas (parte 2 de 3)

Documents

Transcript of Listas (parte 2 de 3)