Enumerados Genéricos Coleções - dei.isep.ipp.ptdei.isep.ipp.pt/~nfreire/JAVA - Tipos Enumerados. Genéricos... · Exemplos Típicos ... Tipos de Cartas: { Duque, Terno, Quadra,

Nelson Freire (ISEP–DEI-PPROG 2012/13) 1/64

Tipos de Dados Enumerados

Genéricos

Coleções

Paradigmas da Programação PPROG


Tipos Enumerados

Tipos Genéricos

Tipos Coleção

Sumário Geral PPROG


Tipos Enumerados

Tipos Genéricos

Tipos Coleção



Interesse

Definição

Implementação

Declaração

Valor de um Tipo Enumerado

Variável de Tipo Enumerado

Métodos Automáticos

name

toString

values

compareTo

equals

valueOf

Ordinal

Métodos Programados

Sumário Tipos Enumerados


Representação Computacional

Conjuntos fixos de constantes

Constantes Enumeradas // relevante ordem das constantes

Constantes Não-Enumeradas // irrelevante ordem das constantes

Exemplos Típicos

Constantes Enumeradas

Dias da semana: { Segunda, Terça, Quarta, Quinta, Sexta, Sábado, Domingo }

Meses do ano: { Janeiro, Fevereiro, Março, Abril, Maio, Junho, Julho, Agosto, Setembro, Outubro, Novembro, Dezembro }

Tipos de Cartas: { Duque, Terno, Quadra, Quina, Sena, Oito, Nove, Dez, Dama, Valete, Rei, Manilha, As}

Notas Escolares: { Mau, Medíocre, Suficiente, Bom, Muito Bom }

Constantes Não-Enumeradas

Conjunto de cores: { Branco, Preto, Azul }

Pontos cardeais: { Norte, Sul, Este, Oeste }

Naipes de cartas: { Copas, Espadas, Ouros, Paus }

Interesse Tipos Enumerados


Tipo Enumerado

É um tipo de dados

Definido pelo utilizador

Valores são constantes ... enumeradas automaticamente desde zero

Característica Importante de um Tipo Enumerado

Estabelece ordem nos seus valores

Valor 1 < Valor 2 < Valor 3 < ... < Valor N

Exemplo

Interessa aos Conjuntos

Dias da Semana = { Segunda, Terça, Quarta, Quinta, Sexta, Sábado, Domingo }

Meses = { Janeiro, Fevereiro, Março, Abril, Maio, Junho, Julho, Agosto, Setembro,

Outubro, Novembro, Dezembro }

Definição de um Tipo Enumerado

Constante 1 Constante 2 Constante 3 ... Constante N

0 1 2 N-1 ... Ordem

Valores do tipo

Tipos Enumerados


Pode ser implementado numa classe especial // desde Java5

Chamada enum

Não instanciável

Possuindo

Valores do Tipo // Ex:

Métodos Automáticos // adicionados automaticamente pelo compilador name // para obter nome de 1 valor toString // para obter descrição textual de 1 valor values // para obter array contendo todos os valores do tipo enumerado compareTo // para determinar ordem relativa de 2 valores ( v1 <, > ou = v2) equals // para testar igualdade de 2 valores valueOf // para converter nome de valor (string) no valor correspondente ordinal // para obter ordem (posição) de 1 valor

Métodos Programados Métodos de Instância Métodos de Classe

Variáveis Instância Classe

Herda implicitamente a classe Enum

public abstract class Enum< E extends Enum<E> > implements Comparable<E>, Serializable { ... }

package java.lang

Implementação de um Tipo Enumerado Tipos Enumerados


Pode ser

Classe Independente // Dentro de package

Classe Interna // Dentro de classes e interfaces

Declaração : Localização 1/3

Netbeans 1. Clique direito na package 2. New Java Enum

Constantes de Interfaces Por omissão

public static final

Tipos Enumerados


Sintaxe

Modificador de acesso

public

package

nome

Deve ter letra inicial maiúscula

constantes

Podem ter letras maiúsculas e/ou minúsculas

Enumeradas automaticamente desde 0 pelo compilador

Exemplos

Declaração : Classe Independente 2/3

[modificador de acesso] enum nome { constante1, constante2, ..., constanteN }

Constantes enumeradas desde 0

AMARELO=0 ; AZUL=1 ; BRANCO=2 ; ENCARNADO=3

[...] significa opcional

Tipos Enumerados


Como atributo

Sintaxe

Modificador de acesso: private, package, protected ou public

nome deve ter letra inicial maiúscula

constantes podem ter letras maiúsculas e/ou minúsculas

Exemplo

Proibida num método

Declaração : Classe Interna de uma Classe

public class Exemplo { ... public static enum Cor { AMARELO, AZUL, BRANCO, ENCARNADO } // public acesso exterior … }

3/3

public class Exemplo { … public void metodo() { enum Cor { AMARELO, AZUL, BRANCO, ENCARNADO } } }

[modificador de acesso] [static] enum nome { constante1, constante2, ..., constanteN }

Tipos Enumerados


Referir um valor

Caso Geral

Sintaxe

tipo_enumerado.constante_enumerada

// prefixo operador_ponto nome_constante

Exemplos

Caso Particular

Tipo enumerado declarado como classe interna

Indicação no exterior da classe hospedeira

Sintaxe

Classe_hospedeira.tipo_enumerado.constante_enumerada

Exemplos

Valor de um Tipo Enumerado Tipos Enumerados

Cor.ENCARNADO; // indica valor ENCARNADO do tipo Cor

Cor.AMARELO; // indica valor AMARELO do tipo Cor

Exemplo.Cor.ENCARNADO; // indica valor ENCARNADO do tipo Exemplo.Cor

Exemplo.Cor.AMARELO; // indica valor AMARELO do tipo Exemplo.Cor

public class Exemplo { public static enum Cor { ... } // public acesso exterior … }


Declaração

Sintaxe

tipo_enumerado nome_variável [= valor_do_tipo_enumerado];

Exemplo

Só pode guardar valores do tipo enumerado declarado

Exemplo

Variável c só pode armazenar valores do tipo enumerado Cor

Variável de um Tipo Enumerado

public class Exemplo {

public static enum Cor { AMARELO, AZUL, BRANCO, ENCARNADO } …

public void metodo() {

Cor c; // inicializada a null, por omissão ... } }

Cor c = Cor.ENCARNADO;

c = Cor.BRANCO;

Tipos Enumerados


Interesse

Obter nome de um valor

Declaração

public String name() { … } // método de instância

Retorna

Nome do valor sobre o qual é aplicado o método

Método name


public static enum Cor { AMARELO, AZUL, BRANCO, ENCARNADO }


// método name aplicado a valor

String nome = Cor.ENCARNADO.name(); // nome = ENCARNADO ...

// método aplicado a variável de tipo enumerado Cor c1 = Cor.BRANCO; // variável c1 do tipo enumerado Cor

System.out.println( c1.name() ); // imprime BRANCO } }

Tipos Enumerados


Interesse

Obter descrição textual de um valor

Declaração

public String toString() { … } // método de instância

Retorna

Por omissão (i.e. se não for redefinido)

Semelhante ao método name

Retorna nome do valor sobre o qual é aplicado o método

Método toString 1/2 Tipos

Enumerados




// método toString aplicado a valor

String descricao = Cor.ENCARNADO.toString(); // descricao = ENCARNADO, por omissão ...

// método aplicado a variável de tipo enumerado Cor c1 = Cor.BRANCO; // variável c1 do tipo enumerado Cor

System.out.println( c1.toString() ); // imprime BRANCO } }


Pode ser redefinido para cada valor

Exemplo

Método toString 2/2


public static enum DiasDaSemana {

SABADO { public String toString() { return "Sábado"; } } , // redefinição toString()

DOMINGO { public String toString() { return "Domingo"; } },

SEGUNDA { public String toString() { return "Segunda-feira"; } },

TERCA { public String toString() { return "Terça-feira"; } },

QUARTA { public String toString() { return "Quarta-feira"; } },

QUINTA { public String toString() { return "Quinta-feira"; } },

SEXTA { public String toString() { return "Sexta-feira"; } } }


String dia = DiasDaSemana.SEGUNDA.toString(); // dia = "Segunda-feira"

}

}

Tipos Enumerados


Interesse

Obter array contendo todos os valores do tipo enumerado

Exemplo: varrimento de todos os valores do tipo enumerado

Declaração

public static tipoEnumerado[] values() { ... }

Método de classe (static)

Aplica-se ao tipo enumerado

Exemplo: Cor.values()

Retorna

Array com todos os valores do tipo enumerado sobre o qual é aplicado o método

Método values



public void metodo() { ...

// Imprimir todas as descrições de valores do tipo Cor

for( Cor c : Cor.values() ) System.out.println( c ); // por omissão: c.toString() } }

Tipos Enumerados


Interesse

Determinar posição relativa de 2 valores do mesmo tipo enumerado

Declaração

public int compareTo(TipoEnumeradoDoRecetor o){ … } // tipo enum implementa Comparable

Retorna Valor Inteiro // método de instância

-1 // valor1 < valor2 0 // valor1 = valor2 1 // valor1 > valor2

Método compareTo


public static enum Nota { MAU, MEDIOCRE, SUFICIENTE, BOM, MUITO BOM }


Nota n1 = ... , n2 = ...; // Ex: Nota n1 = Nota.BOM, n2 = Nota.MAU;

if ( n1.compareTo(n2) > 0 )

System.out.println( n1.name() + " é melhor do que " + n2.name() );

else if ( n1.compareTo(n2) < 0 )

System.out.println(" n1.name() + " é pior do que " + n2.name() "); else System.out.println(" Notas iguais "); } }

Exemplo valor1.compareTo( valor2 )

Tipos Enumerados


Interesse

Testar a igualdade de 2 valores

Declaração

public boolean equals(Object o) // método de instância

Retorna

Resultado do teste de igualdade entre Object o e valor sobre o qual é aplicado o método

true ou false

Método equals




ArrayList figuras = new ArrayList(); // para guardar instâncias de figuras geométricas ...

for( Object obj : figuras){

Figura f = (Figura) obj;

if( f.getCor().equals( Cor.ENCARNADO ) ) // Equivalente : f.getCor() == Cor.ENCARNADO

System.out.println( f ); // imprime só figuras de cor ENCARNADO } } }

Tipos Enumerados


Interesse

Converter nome dum valor no valor correspondente

Exemplo

Declaração

public static tipo_enumerado valueOf(String name)

Método de classe (static)

Aplicado ao tipo enumerado

Exemplo

Retorna

Valor com nome passado por parâmetro

Exemplo

Caso não exista valor com esse nome

Gerado erro de execução Lançada exceção IllegalArgumentException

Exemplo

Método valueOf 1/2 Tipos

Enumerados

Cor c = Cor.valueOf ("BRANCO"); // c = Cor.BRANCO

Cor.valueOf ("BRANCO")

Ex: Cor.valueOf ("branco")

"BRANCO" Cor.BRANCO


Exemplo


...


…


Scanner ler = new Scanner(System.in);

System.out.println("Escreva uma cor (AMARELO, AZUL, BRANCO, ENCARNADO):");

String cor = ler.next().toUpperCase(); // utilizador define cor …

for( Object obj: figuras ) { // figuras é contentor ArrayList

Figura f = (Figura) obj;

if ( f.getCor() == Cor.valueOf( cor ) ) // getCor devolve valor do tipo Cor

System.out.println( f ); // imprime só figuras com cor

} }

}

Método valueOf 2/2 Tipos

Enumerados


Interesse

Obter ordem (posição) de um valor // ordem = valor da constante enumerada

Declaração

public int ordinal() // método de instância

Retorna

Ordem (posição) do valor sobre o qual é aplicado o método

Método ordinal


public static enum Mes { JANEIRO, FEVEREIRO, MARCO, ABRIL, MAIO, JUNHO, JULHO, AGOSTO, SETEMBRO, OUTUBRO, NOVEMBRO, DEZEMBRO }


Mes m1 = Mes.DEZEMBRO; // posição 11

Mes m2 = Mes.ABRIL; // posição 3

System.out.println("Faltam " + m1.ordinal () – m2.ordinal () + " meses para o Natal");

...

} }

Tipos Enumerados


Exemplo: meses do ano - caraterizados pelo nome e nº de dias // conjunto fixo enumerado

Métodos Programados

public enum Mes {

// Valores do tipo (Instâncias do tipo) Janeiro(31), Fevereiro(28), Marco(31) { public String toString() { return "Março"; } }, Abril(30), Maio(31),

Junho(30), Julho(31), Agosto(31), Setembro(30), Outubro(31), Novembro(30), Dezembro(31);

// Variável de instância private int numeroDeDias;

// Construtor do tipo (privado) private Mes( int numeroDeDias ) { this.numeroDeDias = numeroDeDias; }

// Métodos de instância (aplicados aos valores do tipo. Ex: int d = Mes.Janeiro.numeroDeDias(2013); ) public int numeroDeDias(int ano) { if( ordinal()==1 && anoBissexto(ano) ) return numeroDeDias+1; return numeroDeDias; } public int numeroDeDiasDoAnoCorrente() { Calendar c = Calendar.getInstance(); if( ordinal()==1 && anoBissexto( c.get( Calendar.YEAR ) ) ) return numeroDeDias+1; return numeroDeDias; }

public int ordem(){ return ordinal()+1; }

// Métodos de classe (aplicados ao tipo. Ex: Mes m = Mes.obterMes(1); ) public static Mes obterMes( int ordem) { return ordem>0 && ordem<13 ? Mes.values()[ordem-1] : null; }

private static boolean anoBissexto( int ano ) { return ano % 4 == 0 && ano % 100 != 0 || ano % 400 == 0; }

}

Tipos Enumerados


Tipos Enumerados

Tipos Genéricos

Tipos Coleção



Definição

Tipo Genérico

Tipo Parametrizado

Interesse

Classes e Interfaces Genéricos

Parâmetro de Tipo Genérico

Sumário Genéricos


Definição Simples

É um tipo com parâmetros de tipos genéricos // genérico = não concreto (Ex típicos: E, T)

Identificador (Sintaxe)

nome_tipo<lista_parâmetros_tipos_genéricos> // <tipo_genérico_1, ..., tipo-genérico_n>

Exemplo

ArrayList<E> // tipo ArrayList genérico

// E : parâmetro tipo genérico


Permite passar tipo concreto

Para dentro da declaração de tipo genérico

Interesse

Permitir a tipo genérico

Criar diferentes tipos concretos

Exemplos

ArrayList<Pessoa>

ArrayList<Figura>

ArrayList<Contribuinte>

Tipo Genérico 1/2 Genéricos

public class ArrayList<E> extends … { … public boolean add( E e ) { ensureCapacity(size + 1); elementData[size++] = e; return true; } }

Declaração de ArrayList Genérico

< > operador diamante


Definição Completa

É um tipo referência (classe ou interface) que usa na sua definição, como parâmetros, um ou mais tipos referência genéricos que serão substituídos por tipos referência concretos na instanciação do tipo genérico

Exemplo

Tipo genérico de ArrayList

ArrayList<E>

Concretizações // tipos parametrizados = instanciações do tipo genérico

ArrayList<Pessoa>

ArrayList<Figura>

ArrayList<Contribuinte>

Identificador de Tipo Genérico

Tem 2 componentes (Ex: ArrayList<E>)

Tipo referência

Lista de parâmetros formais de tipos referência

Parâmetros genéricos (Ex típicos: E, T)

Representam qualquer tipo referência concreto

Tipo_Referência <Tipo_Ref_1, ..., Tipo_Ref_N> Lista de Parâmetros

Tipo Genérico 2/2 Genéricos


Definição Completa

Tipo obtido por instanciação do tipo genérico, substituindo os parâmetros de tipo genérico (ex: E) por tipos concretos (ex: Figura)

Definição Simples

Tipo com um ou mais parâmetros de tipo concreto

Tipo Parametrizado

(Parâmetro Tipo Genérico) (Parâmetro Tipo Concreto)

public class ArrayList<E> extends … {

…

public boolean add( E e ) {

ensureCapacity(size + 1);

elementData[size++] = e;

return true;

} }

public class ArrayList<Figura> extends … {

…

public boolean add( Figura e ) {

ensureCapacity(size + 1);

elementData[size++] = e;

return true;

} }

Tipo Genérico ( Ex: ArrayList<E> )

Tipo Parametrizado ( Ex: ArrayList<Figura> )

instanciado

substituído

1/2 Genéricos


Pode ser usado em declarações de

Variáveis // Ex: ArrayList<Figura> f ;

Parâmetros formais de métodos // Ex: public void metodo( ArrayList<Figuras> a ) { … }

Tipos de retorno de métodos // Ex: public ArrayList<Figuras> metodo2(){ … }

Convenção

Identificadores de parâmetros de tipo genérico

Usam só 1 letra

Típicas

E, T, U, etc.

Tipo Parametrizado 2/2 Genéricos


Interesse dos Genéricos

Tornar mais segura a programação ... do que a baseada em contentores com elementos Object

Eliminando o excessivo downcasting

Permitindo ao compilador verificar o tipo de objetos adicionados ao contentor

Exemplo do Problema

Interesse 1/2 Genéricos


public static void main(String[] args) {

ArrayList figuras = new ArrayList(); // ArrayList com elementos do tipo Object

figuras.add( new Circulo() ); // Preenchimento do contentor

figuras.add( new Rectangulo() );

figuras.add( new Pessoa() ); // Adicionado objeto que não é tipo Figura // Compilador aceita qualquer objeto // Provoca apenas erro de execução no ciclo abaixo ...

// Algoritmo para calcular e mostrar áreas

for( Object obj : figuras )

System.out.println( ( (Figura) obj ).area() ); // downcasting operação insegura } }


Exemplo da Solução



ArrayList<Figura> figuras = new ArrayList()<Figura>(); // ArrayList com elementos do tipo Figura

figuras.add( new Circulo() ); // Preenchimento do contentor

figuras.add( new Rectangulo() );

figuras.add( new Pessoa() ); // provoca erro de compilação

...

// Algoritmo para calcular e mostrar áreas

for( Figura fig : figuras )

System.out.println( fig.area() ); // não há downcasting } }

Interesse 2/2 Genéricos


Classes e Interfaces Genéricos Tipos Genéricos podem ser

Classes

Interfaces

Tipos Java podem ser classificados em

Tipos parametrizados (genéricos)

Tipos não-parametrizados (não-genéricos)

Também designados raw types

Existem por questões de retrocompatibilidade

Na plataforma JCF (desde Java5)

Todas as classes e interfaces são genéricos

Exceção

Tipos Enumerados

Genéricos



Também pode ser um tipo genérico

Exemplo

Tipo Genérico

ArrayList< ArrayList<E> > // Matriz bidimensional

// Elementos do tipo E

Tipo Parametrizado

ArrayList < ArrayList<Figura> > // Matriz bidimensional

// Elementos do tipo Figura

Genéricos

ArrayList<Figura> Elemento 0

Elemento 1

Elemento N

ArrayList<Figura>

ArrayList<Figura>


Tipos Enumerados

Tipos Genéricos

Tipos Coleção



Coleção Natural

Noção

Processamento em Java

Coleção Java

Noção

Tipos de Organização

Java Collections Framework (JCF)

Introdução

Classes e Interfaces

Estrutura dos Interfaces Collection

Listas de Tipo List<E>

Interface List<E>

Classe ArrayList<E>

Filas de Espera

Classes

Arrays

Collections

Sumário Coleções


Noção de Coleção Coleção

Grupo de Itens

Exemplos

Cartas de um Jogador de Poker

Pasta de Correio Eletrónico

Lista Telefónica

Coleção de Cartas

Coleção de Mensagens

Nome Telefone

António 224529345

Joana 221343455

Coleção de mapeamentos de nomes para telefones

Coleções


Processamento de Coleções Frequente no desenvolvimento de aplicações

Java fornece Plataforma de Coleções Java (JCF)

Código disponibilizado na Biblioteca Collections

Coleções

http://java.sun.com/javase/technologies/


Noção de Coleção Java Coleção Java

É uma estrutura de dados nativa

Permite definir contentores de objetos

Para servirem de unidades de representação e processamento de um grupo de objetos

Armazenam objetos de forma organizada

Possuem estrutura e comportamento próprios

Exemplo

Coleção com organização Stack (Pilha)

Objetos armazenados de forma sequencial (ordenada) // Estrutura

Funciona segundo disciplina LIFO (Last In First Out) // Comportameto

Objeto X

Objeto Y

Objeto Z

Coleção

Contentor

Coleções


Tipos de Coleções

Tipo Características Exemplo

Conjunto (Set) Implementa um conjunto matemático finito

Não há noção de ordem (posição): 1º, 2º, n-ésimo ou último elemento

Não são permitidos elementos repetidos

Conjunto de artigos científicos

Lista (List) Implementa uma sequência

Há noção de ordem

São permitidos elementos repetidos

Pasta de correio electrónico

Fila de Espera (Queue) Destinada a guardar elementos à espera de serem processados

A ordem de processamento é do tipo FIFO

Pedidos de serviço recebidos por um servidor

Pilha (Stack) Destinada a guardar elementos à espera de serem processados

A ordem de processamento é do tipo LIFO

Conjunto de endereços navegados num browser Web

Mapeamento (Map) Implementa correspondências unívocas (1 para 1) entre objetos do tipo chave-valor

As chaves são o domínio das correspondências e são únicas

Lista Telefónica

Coleções


Java Collections Framework (JCF) Plataforma JCF

Surgiu em 1999

Na versão JDK 1.2 (JAVA2)

Alterada na JDK 1.5 (JAVA5) de 2004 Devido à introdução de tipos genéricos

Pertence à package java.util

Disponibiliza múltiplas estruturas de dados Tipos

Interfaces Classes abstratas Classes concretas

Representam Estruturas de dados usadas frequentemente no desenvolvimento de aplicações

Muito genéricas Para processamento de qualquer tipo de dados Propriedades de cada estrutura de dados são independentes do seu conteúdo Exemplo

ArrayList para guardar Carros, Livros, Empregados, etc.

Muito eficientes

Atendendo à importância da JCF, analisemos a sua estrutura interna (a parte que nos interessa)

1/3 Coleções


Java Collections Framework (JCF) Classes e Interfaces disponibilizados

Utilitários para arrays Classe Arrays // Presta serviços a arrays: ordenação, pesquisa, etc.

Utilitários para coleções Classe Collections // Presta serviços a coleções: ordenação, pesquisa, etc.

Interfaces Collections

Definem as APIs essenciais de todas as classes JCF

Categorias Conjunto Lista Mapeamento Fila

Classes Abstratas

Implementações parciais de classes que satisfazem certos interfaces

Interesse Criação de subclasses concretas com implementações diferentes

Classes Wrapper

Exemplos: Integer, Long, Float, Double, Boolean, Character

Adicionam funcionalidades a outras classes Permitem a conversão de tipos primitivos em tipos referência e vice-versa

2/3 Coleções


Java Collections Framework (JCF) Estrutura das Interfaces Collection

São interfaces genéricos

Há 2 hierarquias de coleções

Coleções com 1 parâmetro

Coleções 2 parâmetros

As correspondências (maps) não herdam de

Collection porque têm 2 parâmetros

Todas as coleções com 1 parâmetro

São de um dos tipos

Conjuntos

Listas

Filas

Coleções de cada um destes tipos

Têm a mesma API (métodos públicos)

Uso simplificado

3/3

Map<K,V>

SortedMap<K,V>

Collection<E>

SortedSet<E>

Iterable<E>

Set<E> List<E> Queue<E>

Deque<E>

Hierarquias de Interfaces Collection do JCF

Coleções


List<E> Interface que herda 2 outros interfaces

Implementado de formas diferentes ... em classes concretas Exemplos

ArrayList<E> // implementa array dinâmico Vector<E> // implementa array dinâmico ... para ambientes multitarefa LinkedList<E> // implementa lista duplamente ligada Stack<E> // implementa pilha

Listas de Tipo List<E> 1/2 Coleções

Collection<E>

Iterable<E>

List<E>

Deque<E>

Queue<E>

Implementações de List<E>

ArrayList<E> LinkedList<E> Vector<E>

Stack<E>

AbstractCollection<E>

AbstractList<E>

AbstractSequentialList<E>

Classe Abstrata

Classe Concreta


Classes que implementam interface List<E>

Possuem os métodos apresentados na figura

Implementação destes métodos deve satisfazer as propriedades de uma lista

Sequência de elementos (há ordem)

Posição de cada elemento representada por índice inteiro (iniciado em zero)

Elementos podem ser inseridos em qualquer posição da lista

Pode conter elementos repetidos

Pode conter elementos null

Listas de Tipos List<E> 2/2 Coleções


É coleção do tipo Lista

É tipo List<E> // implementa interface List<E>

Implementação

Array dinâmico // nº de elementos pode variar durante execução de programa

Cresce // adicionando novos elementos

Decresce // removendo elementos

É estrutura de dados indexada

Semelhante ao array

Índice

Indica a posição dos elementos

Número inteiro desde zero

É tipo genérico

Parâmetro E define o tipo de elementos do array

Elementos só podem ser instâncias

Parâmetro E tem de ser um tipo referência (classe ou interface)

Classe ArrayList<E> 1/8

E1 E1 E2 E1 E2 E3

Array Dinâmico

E1 E2

Coleções


Modelo de Memória (em Execução)

RAM

referência

...

N Elemento

...

atributo 1

Instância

Heap

Stack

atributo M

...

atributo 1

atributo M’

...

...

...

Instância

referência 1º Elemento

ArrayList Parametrizado

Classe ArrayList<E> 2/8 Coleções


Declaração de Variável de Tipo ArrayList Parametrizado

Tipo ArrayList<Figura> é instância do tipo ArrayList<E>

Instanciação de um Tipo Parametrizado

Tamanho inicial zero // tamanho = nº objetos adicionados

Capacidade inicial 10 // capacidade = nº de elementos alocados em memória; >= tamanho

Capacidade inicial de 50 elementos // 1ªs 50 adições são mais rápidas (sem custos de alocação)

Podem ser adicionados mais de 50 elementos

Tamanho inicial zero

colecao é um objeto do tipo Collection<E>

Exemplos ArrayList Stack

Figura

Retangulo Circulo

ArrayList<Figura> figuras = new ArrayList<Figura> ();

ArrayList<Figura> figuras = new ArrayList<Figura> ( 50 );

ArrayList<Figura> figuras;


ArrayList<Figura> figuras = new ArrayList<Figura> ( colecao );

Coleções


Atribuídos elementos de outra lista ( elementos de índices [0,5[ do arraylist figuras )

Novos elementos são cópias de referências da outra lista figuras (não são cópias de objetos)

figuras e figuras2 partilham objetos

Modelo de memória no slide seguinte

RAM

referência

...

1º Elemento

...

atributo 1

objetos Heap

Stack

atributo M

...

...

...

referência 1º Elemento ArrayList figuras

... ArrayList figuras2

Modelo de Memória (em Execução)


ArrayList<Figura> figuras2 = figuras.subList(0,5);

Coleções


• Métodos para Adicionar Elementos

boolean add( E e ) adiciona e no final do arraylist e incrementa size de 1 unidade

retorna true (sucesso) ou false (insucesso)

e pode ser null

gera um erro de execução se e não for do tipo E ou null

void add( int índice, E e ) desloca uma posição à direita os elementos >= índice e adiciona e

na posição índice

E set( int índice, E e ) adiciona e na posição índice e retorna o elemento substituído

gera erro de execução com índice fora dos limites válidos ( [0, size()[ )

• boolean addAll( Colection c ) adiciona todos os elementos da coleção c no final do arraylist

boolean addAll( int índice, Collection c ) insere todos os elementos da coleção c no arraylist, a partir de índice

desloca para a direita os elementos >= índice



• Métodos para Remover Elementos

void clear() remove todos os elementos do arraylist

E remove( int índice ) remove e retorna o elemento índice, deslocando os elementos > índice para o correspondente índice imediata/ inferior


boolean remove( Object obj ) remove a 1ª ocorrência de obj no arraylist, caso exista

desloca os elementos > índice para o correspondente índice

imediata/ inferior

retorna true se obj for encontrado; senão, retorna false



Métodos de Pesquisa de Elementos

boolean isEmpty() retorna true se o arraylist estiver vazio

caso contrário, retorna false

boolean contains( Object obj ) retorna true se o arraylist possuir obj


usa método equals de obj

boolean containsAll( Collection c ) retorna true se o arraylist possuir todos os elementos de c


gera erro de execução se c = null ou se um ou mais elementos de c forem incompatíveis com o arraylist

int indexOf( Object obj ) retorna o índice da 1ª ocorrência de obj no arraylist, caso exista

caso não exista, retorna -1

usa método equals de obj

int lastIndexOf( Object obj ) semelhante ao anterior, mas relativo à última ocorrência



Outros Métodos

int size() retorna o nº de elementos adicionados ao arraylist

é diferente de capacidade

E get( int índice ) retorna o elemento na posição índice do arraylist


String toString() retorna a representação textual do arraylist

consiste numa lista, delimitada por parêntesis [ ... ], contendo as representações textuais dos elementos adicionados e separados por vírgulas

List<E> subList( int i1, int i2 ) retorna sublista contendo os elementos de índices [i1, i2-1[

retorna referências de objetos (i.e., não objetos)

Object clone() retorna cópia do arraylist

elementos são cópias de referências

partilham objetos com o arraylist clonado

Object[] toArray() retorna array contendo todos os elementos do arrayList na mesma ordem



Operações de iteração (varrimento)

Para percorrer todos os elementos do arraylist

Formas

Ciclo for sobre o índice do arraylist

Operador foreach sobre o ArrayList

Sintaxe

Exemplo

ArrayList<String> nomes = new ArrayList<String>();

...

for( int i=0; i < nomes.size(); i++ ){ // tradicional ciclo for sobre arrays

System.out.println( nomes.get(i) )

}

for( Tipo_Elemento variável : nomeArrayList ){

instruções // sobre variável }

for( String nome : nomes ){ // lê-se: para cada nome da lista nomes

System.out.println( nome ); // nome guarda sucessiva/ cada elemento de nomes }



public class ExemploArrayListGenerico {

public static void main( String[] args ) {

ArrayList<Figura> a = new ArrayList();

Retangulo r = new Retangulo();

a.add( r );

a.add( new Circulo() );

...

for( Figura f : a )

System.out.printf( "%s Área: %.1f %n", f, f.area() );

System.out.println( "Tamanho do arraylist: " + a.size() );

Figura f1 = a.set( 1, new Retangulo() ); // Substitui figura índice 1

if( a.contains( r ) ) System.out.println( r + " contido no arraylist " );

else System.out.println( r + " não contido no arraylist " );

Figura f2 = a.remove( 0 ); // f2 guarda figura de índice 0 removida de a

if ( a.remove( r ) ) System.out.println( r + " Removida");

else System.out.println( r + " Não removida") ;

}

}

Figura

público area()

Retangulo

público area()

Circulo

público area()



Queue<E> Interface que herda 2 outros interfaces

Implementado de formas diferentes ... em classes concretas.

Exemplos:

PriorityQueue<E> // implementa fila de espera com elementos ordenados

LinkedList<E> // implementa lista duplamente ligada

Filas de Espera de Tipo Queue<E> Coleções

Collection<E>

Iterable<E>

Queue<E>

Implementações de Queue<E>

PriorityQueue<E>

AbstractCollection<E>

AbstractQueue<E>

Deque<E>

LinkedList<E>

Classe Abstrata

Classe Concreta


Package

java.util

Presta serviços

A arrays

Serviço

public static List<T> asList( T[] a )

Converte array num objeto do tipo List<T>

import java.util.Arrays;


public static enum Cor { AMARELO, AZUL, BRANCO}


System.out.println( Arrays.asList( Cor.values() ) ); // imprime: [AMARELO,AZUL,BRANCO]

}

}

Classe Arrays 1/5 Coleções


public class Figura implements Comparable<Figura> {

private double cor; ... public int compareTo( Figura f ) { if ( area() > f.area() ) return 1; else if ( area() < f.area() ) return -1; else return 0; } }

Serviço

public static void sort( Object[] a )

Ordena array a de forma ascendente,

segundo ordem natural dos elementos

Todos elementos do array a têm de ser do tipo

Comparable (genérico ou não)

Classe Arrays 2/5

Circulo Retangulo

Interface Comparable<T>

implementa

Figura

público compareTo()


public class ProgramaPrincipal {


Figura[] figuras = new Figura[10];

figuras[0] = new Circulo();

figuras[1] = new Rectangulo(); ... Arrays.sort( figuras ); // pela área

for( Figura f : figuras ){

System.out.println( f ); // fig. ordenadas } }

}

Coleções


Comparator<Figura> c = new Comparator<Figura>() {

public int compare( Figura f1, Figura f2 ) {

double area1 = f1.area(); double area2 = f2.area();

if ( area1 == area2 ) return 0; else if (area 1 > area2 ) return 1; else return -1; } } ; // classe anónima, cria 1 objeto

Serviço

public static void sort( T[] a, Comparator <T> c )

Ordena array a segundo critério de ordenação definido no objeto c (Comparator genérico ou não)

Vantagens Não obriga a alterar as classes dos elementos do array Permite ordenar mesmo array usando critérios diferentes

Classe Arrays 3/5

Circulo Retangulo

Figura

implementa

Classe Auxiliar (Anónima)

Interface Comparator<T>

público compare()






figuras[1] = new Rectangulo(); ... Comparator<Figura> c = ... Arrays.sort( figuras, c ); // pela área

for( Figura f : figuras ){ System.out.println( f ); // fig. ordenadas } }

}

Coleções


Serviço

public static int binarySearch( Object[] a, Object key )

Pesquisa objeto key no array a, usando o algoritmo de pesquisa binária

Array deve estar ordenado de forma ascendente, segundo ordem natural dos elementos (usando método Arrays.sort( Object[] a ) ); senão, o resultado é indefinido

Retorna índice do objeto key procurado; se houver vários, retorna o índice de um deles; se não for encontrado retorna -1

gera erro de execução se não for possível comparar key com os elementos do array

Classe Arrays 4/5








figuras[1] = new Rectangulo(); ... Figura key = new Circulo(); Arrays.sort( figuras ); int indice = Arrays.binarySearch( figuras, key ); ... }

} Procura objeto com área de key

Coleções


Serviço

public static int binarySearch( T[] a, T key , Comparator<T> c )

Pesquisa objeto key no array a, usando algoritmo de pesquisa binária

Array deve estar ordenado de forma ascendente, segundo critério de ordenação em c (usando método Arrays.sort( T[] a, Comparator<T> c ) ); senão, o resultado é indefinido

Retorna o índice do objeto key procurado; se houver vários, retorna o índice de um deles; retorna -1 se não for encontrado

gera um erro de execução se não for possível comparar key com os elementos do array

Classe Arrays 5/5








Figura[] figuras = new Figura[10]; figuras[0] = new Circulo(); figuras[1] = new Rectangulo(); ... Figura key = new Circulo(); Comparator<Figura> c = ... Arrays.sort( figuras, c ); // pela área int indice = Arrays.binarySearch( figuras, key, c );

... }

}

Procura objeto com área de key

Coleções


Package

java.util

Presta serviços

A coleções

Serviço

public static void shuffle( List<?> lista )

Faz permutas aleatórias dos elementos da lista passada por parâmetro

import java.util.Collections;



ArrayList<Carta> cartas = new ArrayList<Carta>(); // para guardar cartas de jogo

cartas.add( new Carta(Naipe.PAUS, Tipo.DAMA) ); // Naipe e Tipo - tipos enumerados

cartas.add( new Carta(Naipe.OUROS, Tipo.REI) ); ... cartas.shuffle(); // cartas baralhadas ... }

}

Classe Collections 1/5 Coleções




Serviço

public static void sort( List<T> lista )

Ordena a lista de forma ascendente,

segundo a ordem natural dos elementos

Todos elementos da lista têm de ser do tipo

Comparable (genérico ou não)

Classe Collections 2/5




ArrayList<Figura> figuras = new ArrayList<Figura>();

figuras.add( new Circulo() );

figuras.add( new Rectangulo() ); ... Collections.sort( figuras ); // pela área

for( Figura f : figuras )

System.out.println( f ); // figuras ordenadas }

}

Circulo Retangulo

Interface Comparable<T>

implementa

Figura

público compareTo()

Coleções






Serviço

public static void sort( List<T> lista, Comparator<T> c )

Ordena a lista segundo critério de ordenação definido no objeto c (Comparator genérico ou não)

Vantagens Não obriga a alterar as classes dos elementos da lista Permite ordenar a mesma lista usando critérios diferentes





ArrayList<Figura> figuras = new ArrayList<Figura>(); figuras.add( new Circulo() ); figuras.add( new Rectangulo() ); ... Comparator<Figura> c = ... Collections.sort( figuras, c ); // pela área for( Figura f : figuras ) System.out.println( f ); // figuras ordenadas

} }

Circulo Retangulo

Figura

implementa

Classe Auxiliar (Anónima)

Interface Comparator<T>

público compare()

Coleções


Serviço

public static int binarySearch( List<T> lista, T key )

Pesquisa objeto key na lista, usando algoritmo de pesquisa binária

A lista deve estar ordenada de forma ascendente, segundo ordem natural dos elementos (usando o método Arrays.sort( List<T> lista ) ); senão, o resultado é indefinido

Retorna índice do objeto key procurado; se houver vários, retorna o índice de um deles; se não for encontrado retorna -1

gera erro de execução se key não puder ser comparado com os elementos da lista



private double cor; ... public int compareTo( Figura f ) { if ( area() > f.area() ) return 1; else if (area() < f.area() ) return -1; else return 0; } }




ArrayList<Figura> figuras = new ArrayList<Figura>(); figuras.add( new Circulo() ); figuras.add( new Rectangulo() );

... Figura key = new Circulo(); Collections.sort( figuras ); int indice = Collections.binarySearch( figuras, key );

... }

}


Coleções


Serviço

public static int binarySearch( List<T> lista, T key , Comparator<T> c )

Pesquisa o objeto key na lista, usando o algoritmo de pesquisa binária

A lista deve estar ordenada de forma ascendente, segundo critério de ordenação em c (usando o método Arrays.sort( T[] a, Comparator<T> c ) ); senão, o resultado é indefinido

Retorna o índice do objeto key procurado; se houver vários, retorna o índice de um deles; retorna -1 se não for encontrado

gera um erro de execução se não for possível comparar key com os elementos do array


Comparator<Figura> c = new Comparator<Figura>(){







ArrayList<Figura> figuras = new ArrayList<Figura>(); figuras.add( new Circulo() ); figuras.add( new Rectangulo() ); ... Figura key = new Circulo(); Comparator<Figura> c = ... Collections.sort( figuras, c ); // pela área int indice = Collections.binarySearch( figuras, key, c ); ...

} }


Coleções

Documents

Enumerados Genéricos Coleções - dei.isep.ipp.ptdei.isep.ipp.pt/~nfreire/JAVA - Tipos Enumerados. Genéricos... · Exemplos Típicos ... Tipos de Cartas: { Duque, Terno, Quadra,