Programação por Objectos. Java

Transcrição

1 Programação por Objectos Java Parte 9: Classes utilitárias Java 1/83

2 Introdução (1) O Java disponibiliza um conjunto de classes utilitárias: com funcionalidades importantes para o programador. distribuídas no ambiente de desenvolvimento em pacotes (dentro do arquivo src.zip) src/java/lang # classes de linguagem (Integer, )» importado automaticamente src/java/util # utilitários diversos (Vector, ) src/java/math # classemath src/java/io # classes entrada/saída LEEC@IST Java 2/83

3 Introdução (2) O J2SE disponibiliza diversos grupos de interfaces. Neste capítulo abordamos 4: 1.Comparator e Comparable descrevem comparações entre objectos (por exemplo, para ordenação). 2.Collection descrevem colecções de objectos. 3.Map descrevem funções entre objectos. 4.Iterator descrevem varrimentos sobre colecções de objectos, sem conhecer a forma como estão organizados. O código das classes pode ser consultado em LEEC@IST Java 3/83

4 Introdução (3) Hierarquia geral das interfaces de ADTs no J2SE 5 <<interface>> Iterable E <<interface>> Collection E <<interface>> Set E <<interface>> List E <<interface>> Queue E <<interface>> SortedSet E LEEC@IST Java 4/83

5 Introdução (4) Hierarquia geral das interfaces de ADTs no J2SE 5 <<interface>> Iterator E <<interface>> Map K,V <<interface>> ListIterator E <<interface>> SortedMap K,V <<interface>> ConcurentMap K,V LEEC@IST Java 5/83

6 Ordenação (1) Classes que envolvem ordenação implementam uma de duas interfaces: Comparable Comparator Java 6/83

7 Interface Comparable (1) Usada quando existe uma ordem natural (ex: Character, Integer, Date). Implementada dentro da classe pelo método CompareTo, que implica ordem total dentro da classe. Mais simples de implementar, mas menos flexível (que a interface Comparator). LEEC@IST Java 7/83

8 Interface Comparable (2) public interface Comparable<T> { public int compareto(t other); } Valor retornado pelocompareto deve ser: < 0 se o objecto sobre o qual o método é chamado é menor que objecto recebido como parâmetro = 0 se o objecto sobre o qual o método é chamado e o objecto recebido como parâmetro são iguais por equivalência (equals) > 0 caso contrário LEEC@IST Java 8/83

9 Interface Comparable (3) public class Conta implements Comparable<Conta> { private static long numproxconta = 0; protected long numconta; // número da conta protected float quantia; // saldo actual //... public boolean equals(object obj) { return numconta==((conta)obj).numconta; } public int compareto(conta other) { if (numconta > other.numconta) return 1; else if (numconta == other.numconta) return 0; else return -1; } //... } LEEC@IST Java 9/83

10 Interface Comparable (4) Conta mc = new Conta( Manuel Silva,1000); Conta outra = new Conta( Luís Silva,200); System.out.println(mc.compareTo(mc)); System.out.println(mc.compareTo(outra)); System.out.println(outra.compareTo(mc)); No terminal é impresso LEEC@IST Java 10/83

11 Interface Comparable (5) As interfaces são tipos, por isso podemos ter: Comparable<Conta> cc; É possível definir, por exemplo, um algoritmo de ordenação para ordenar uma tabela de objectos Comparable (sem olhar a que classe é que esses objectos pertencem): class Ordena { static Comparable<?>[] ordena(comparable<?>[] objs) { // detalhes da ordenação... return objs; } } LEEC@IST Java 11/83

12 Interface Comparable (6) A classe java.util.arrays oferece um método que permite ordenar objectos numa tabela de Object segundo a sua ordenação natural: public static void sort(object[] a, int fromindex, int toindex) Ordena os objectos da tabelaado índicefromindex (inclusivé) ao índicetoindex (exclusivé). Todos os elementos da tabela no intervalo [fromindex, toindex] têm de implementar a interface Comparable. Todos os elementos nesse intervalo têm de ser mutuamente comparáveis (i.e., obj1.compareto(obj2) não deve lançar uma excepçãoclasscastexception). LEEC@IST Java 12/83

13 Interface Comparable (7) public class Ordena { static Comparable<?>[] ordena(comparable<?>[] objs) { Comparable<?>[] res = new Comparable<?>[objs.length]; System.arraycopy(objs, 0, res, 0, objs.length); java.util.arrays.sort(res, 0, res.length); return res; } } Conta mc = new Conta( Manuel Silva,1000); Conta outra = new Conta( Luís Silva,200); Comparable<?>[] contas = new Comparable<?>[2]; contas[0]=outra; contas[1]=mc; contas = Ordena.ordena(contas); LEEC@IST Java 13/83

14 Interface Comparator (1) Usada quando existe uma ordem dependente da aplicação (ex: ordenação de uma lista de alunos pode ser feita por nome, por número ou pela classificação). Implementada fora da classe (mas pode usar compareto sobre os atributos da classe), concretizando a interface Comparator. Implementação mais complexa, mas mais potente (que a interface Comparable). LEEC@IST Java 14/83

15 Interface Comparator (2) public interface Comparator<T> { public int compare(t o1, T o2); } Valor retornado pelocompare deve ser: < 0 se o objectoo1 é menor que objectoo2 = 0 se o objectoo1 é igual ao objectoo2 > 0 caso contrário LEEC@IST Java 15/83

16 Interface Comparator (3) Características do método compare: sgn(compare(x,y)) == -sgn(compare(y,x)) para todo x, y. Transitividade: ((compare(x,y)>0) && (compare(y,z)>0)) implicacompare(x,z)>0. compare(x,y)==0 implicasgn(compare(x,z)) == sgn(compare(y,z)) para todoz. Inconsistência com equals: não é necessário que (compare(x,y)==0) == (x.equals(y)). Java 16/83

17 Interface Comparator (3) Apesar de não fazer sentido definir uma ordenação natural de contas por saldo, pode ser necessário algures numa aplicação ordenar contas por saldo... import java.util.comparator; public class ComparadorContaPorSaldo implements Comparator<Conta> { public int compare(conta o1, Conta o2) { if (o1.quantia > o2.quantia) return 1; else if (o1.quantia == o2.quantia) return 0; else return -1; } } LEEC@IST Java 17/83

18 Interface Comparator (4) A classe java.util.arrays oferece um método genérico que permite ordenar objectos numa tabela segundo a ordem induzida por um Comparator: public static <T> void sort( T[] a, int fromindex, int toindex, Comparator<? super T> c) Ordena os objectos da tabelaado índicefromindex (inclusivé) ao índicetoindex (exclusivé). Todos os elementos nesse intervalo têm de ser mutuamente comparáveis pelocomparator (i.e., obj1.compare(obj2) não deve lançar uma excepção ClassCastException). LEEC@IST Java 18/83

19 Interface Comparator (5) Uma tabela de contas poderia então ser ordenada por saldo da seguinte forma: Conta[] contas = new Conta[2]; Contas[0] = new Conta( Manuel Silva,1000); Contas[1] = new Conta( Luís Silva,200); java.util.arrays.sort( contas, 0, contas.length, new ComparadorContaPorSaldo()); LEEC@IST Java 19/83

20 Interface Comparator (6) Dada uma lista de estudantes, o critério natural de ordenação seria por número de estudante. Para ordenar uma tal lista por nome: import java.util.comparator; public class ComparadorEstudantePorNome implements Comparator<Estudante> { public int compare(estudante o1, Estudante o2) { String nome1 = o1.primeironome(); String nome2 = o2.primeironome(); if (nome1.equals(nome2)) { nome1 = o1.últimonome(); nome2 = o2.últimonome(); return nome1.compareto(nome2); } else return nome1.compareto(nome2); } } LEEC@IST Java 20/83

21 Interface Comparator (7) public static void main(string[] args) { Estudante[] estudantes = new Estudante[args.length]; for(int i=args.length-1; i>=0; i--) estudantes[i] = new Estudante(args[i]); imprimirestudantes(estudantes); System.out.println("*** Ordenado por nome ***"); java.util.arrays.sort(estudantes, new ComparadorEstudantePorNome()); imprimirestudantes(estudantes); } LEEC@IST Java 21/83

22 Interface Comparator (8) Se se pretender ordenar a tabela de estudantes por outro critério, por exemplo, por nota, basta desenvolver outra implementação de Comparable e chamar o método java.util.arrays.sort. System.out.println("*** Ordenado por nota ***"); java.util.arrays.sort(estudantes, new ComparadorEstudantePorNota()); LEEC@IST Java 22/83

23 Interface Iterator public interface Iterator<E> { boolean hasnext(); E next(); void remove(); } A interface Iterator deve ser implementada por classes que pretendam iterar sobre os seus elementos, um por um. LEEC@IST Java 23/83

24 Interface Iterable public interface Iterable<E> { Iterator<E> iterator(); } Uma classe que implemente a interface Iterable oferece um Iterator que depois pode ser usado no ciclofor-each. LEEC@IST Java 24/83

25 Interface Collection (1) Uma colecção, ou contentor, é um objecto que agrupa diversos objectos (eventualmente repetidos) numa unidade. Protótipos de métodos agrupados por três tipos: Operações básicas. Operações de manipulação a todos os elementos de uma só vez (bulk). Operações que convertem elementos numa tabela. LEEC@IST Java 25/83

26 Interface Collection (2) public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isempty(); boolean contains(object elem); boolean add(e elem); boolean remove(object elem); Iterator<E> iterator(); // Bulk operations boolean containsall(collection<?> coll); boolean addall(collection<? extends E> coll); boolean removeall(collection<?> coll); boolean retainall(collection<?> coll); void clear(); // Array operations Object[] toarray(); <T> T[] toarray(t dest[]); } LEEC@IST Java 26/83

27 Interface Collection (3) Todos os métodos que necessitam de verificar igualdade entre objectos utilizam a igualdade por equivalência, baseada no equals (contains, add, remove, containsall, addall, removeall e retainall). A interface Collection não faz qualquer restrição a que elementos null sejam adicionados à colecção. LEEC@IST Java 27/83

28 Interface Collection (4) Pode usar-se um ciclo for e os métodos da interface Iterator para varrer os objectos de uma colecção: É possível adicionar e remover (add e remove) objectos à colecção durante o varrimento. É possível alterar os objectos da colecção durante o varrimento. É possível iterar sobre múltiplas colecções. public class RemoverStringsCurtas { public static void remover(collection<string> c){ // elimina strings unitárias ou nulas for (Iterator<String> i=c.iterator(); i.hasnext(); ) if (i.next().length()<2) i.remove(); } } LEEC@IST Java 28/83

29 Interface Collection (5) O varrimento pode ser facilitado com a instrução for-each: A vantagem do for-each é puramente sintática. Não é possível adicionar e remover (add e remove) objectos à colecção durante o varrimento. É possível alterar os objectos da colecção durante o varrimento. Não é possível iterar sobre múltiplas colecções. public class ImprimirStringsCurtas { public static void imprimir(collection<string> c){ for(string s:c) if (s.length()<2) System.out.println(s); } } LEEC@IST Java 29/83

30 Interface Collection (6) Da interface Collection são derivadas outras interfaces: Set : colecção sem duplicações List : lista de elementos Queue : fila de elementos LEEC@IST Java 30/83

31 Interface Collection (7) <<interface>> Iterable E <<interface>> Collection E <<abstract>> E AbstractCollection <<abstract>> AbstractSet E <<abstract>> AbstractList E <<abstract>> AbstractQueue E <<interface>> Set E <<interface>> List E <<interface>> Queue E LEEC@IST Java 31/83

32 Implementação de interfaces (1) Existem diversas estruturas subjacentes de dados para implementar interfaces: 1. Lineares: os objectos são ordenados por posições, cada objecto tem apenas um predecessor (excepto primeiro) e um sucessor (excepto último). 2. Hierárquicas: cada objecto tem um único predecessor (excepto a raíz) e pode ter um número fixo de sucessores. 3. Desordenadas: não existe uma relação entre dois objectos. LEEC@IST Java 32/83

33 Implementação de interfaces (2) O J2SE 5 implementa as interfaces Set/List/Map por intermédio de quatro estruturas de dados: Tabelas de dispersão (hash tables). Vectores de dimensão variável. Árvores balanceadas. Listas ligadas. Interfaces Set List Map Hash HashSet --- HashMap Estrutura de dados subjacente Vector dim. var. --- ArrayList --- Árv. bal. TreeSet --- TreeMap Lista Ligada --- LinkedList --- Hash + Lista Ligada LinkedHashSet --- LinkedHashMap LEEC@IST Java 33/83

34 Tabelas de dispersão (hash tables) Fazem o mapeamento de uma chave num valor. As chaves são utilizadas para calcular inteiros (hash) que devem ser diferentes para cada chave e estar uniformemente distribuídos (dispersos) pelo conjunto dos inteiros. Os pares chave valor são armazenados num conjunto de baldes. O balde correspondente a cada par chave tabela é determinado directamente do hash (por exemplo utilizando os bits menos significativos). O número de baldes é fixo no na construção da tabela. Cada balde pode conter zero ou N chaves. A tabela deve ser dimensionada para cada balde conter tipicamente zero ou um elemento, resultando em acessos muito rápidos. Bons para insert search e delete, mas maus para funções de select e sort. Versões mais lista evitam ordem de iteração aleatória. LEEC@IST Java 34/83

35 Arvores balanceadas F Implementação de uma árvore Red-Black. Relacionadas com arvores que garantem que a arvore se encontra exactamente balanceada em cada instante sem um aumento muito significativo do peso computacional. A B C D D E G Exemplo de uma rotação à esquerda em F para balancear uma árvore. B F A C E G LEEC@IST Java 35/83

36 Vectores de dimensão variável São re-alocados e copiados quando a sua capacidade excede determinado limite. LEEC@IST Java 36/83

37 Interface Set (1) <<abstract>> AbstractSet E TreeSet E HashSet E E LinkedHashSet <<interface>> Set E <<interface>> SortedSet E LEEC@IST Java 37/83

38 Interface Set (2) A interface Set não acrescenta nenhum método: Apenas define os mesmos métodos de Collection. São impostas restrições extra aos métodos add e equals, por forma a não haver elementos duplicados. LEEC@IST Java 38/83

39 Interface Set (3) Algumas concretizações da interface Set: HashSet: melhor, para a maioria das utilizações. LinkedHashSet: impõe ordem no Iterator (ordem de inserção). TreeSet: impõe ordem no Iterator (ordem natural ou ordem especificada por um objecto Comparator). É de evitar expor a implementação: Set s = new HashSet(); // preferível HashSet s = new HashSet(); // a evitar! LEEC@IST Java 39/83

40 Interface Set (4) Operações típicas sobre conjuntos: União: s1.addall(s2); // s1 passa a união de s1 e s2 Intersecção: s1.retainall(s2); // s1 passa a intersecção de s1 e s2 Diferença: s1.removeall(s2); // s1 passa a diferença de s1 e s2 Subconjunto: s1.containsall(s2); // testa se s2 é subconjunto de s1 LEEC@IST Java 40/83

41 Interface Set (5) Truque para remover elementos duplicados de uma colecção: Collection comduplicados; //... Collection semduplicados = new HashSet(); semduplicados.addall(comduplicados); Collection semduplicados = new HashSet(comDuplicados); LEEC@IST Java 41/83

42 Interface Set (6) Set<String> s1 = new HashSet<String>(); s1.add("ana"); s1.add("joao"); System.out.print("s1 = "); imprimir(s1); Set<String> s2 = new HashSet<String>(); s2.add("joao"); s2.add("luis"); System.out.print("s2 = "); imprimir(s2); Set<String> s3; s3 = new HashSet<String>(s1); s3.addall(s2); System.out.print("União(s1,s2) = "); imprimir(s3); s3 = new HashSet<String>(s1); s3.retainall(s2); System.out.print("Intersecção(s1,s2) = "); imprimir(s3); s3 = new HashSet<String>(s1); s3.removeall(s2); System.out.print("Diferença(s1,s2) = "); imprimir(s3); LEEC@IST Java 42/83

43 Interface Set (7) Relativamente ao exemplo anterior: O método estáticoimprimir imprime os elementos de um conjunto, por exemplo, com um iterador: static void imprimir(collection<string> s) {...} No terminal é impresso: s1 = Joao Ana s2 = Joao Luis União(s1,s2) = Joao Luis Ana Intersecção(s1,s2) = Joao Diferença(s1,s2) = Ana LEEC@IST Java 43/83

44 Interface List (1) <<abstract>> AbstractList E ArrayList E E <<abstract>> E Vector AbstractSequentialList <<interface>> List E Stack E LinkedList E <<interface>> Queue E LEEC@IST Java 44/83

45 Interface List (2) public interface List<E> extends Collection<E> { E get(int index); E set(int index, E elem); void add(int index, E elem); E remove(int index); int indexof(object elem); int lastindexof(object elem); List<E> sublist(int min, int max); ListIterator<E> listiterator(int index); ListIterator<E> listiterator(); } LEEC@IST Java 45/83

46 Classe ArrayList (1) É uma implementação de List que guarda os seus objectos numa tabela: A tabela tem uma capacidade inicial. Quando a capacidade inicial da tabela deixa de ser suficiente é afectada uma nova tabela e o seu conteúdo é copiado. Um valor correcto para a capacidade inicial daarraylist melhora o seu desempenho. Complexidade: Adicionar (na posição i) e remover (da posição i): O(n-i) onde n é o tamanho da lista e i<n. Adicionar (no fim) e remover (do fim): O(1) Aceder a um elemento (em qualquer posição): O(1) LEEC@IST Java 46/83

47 Classe ArrayList (2) public class ArrayList<E> extends AbstractList<E> implements List<E>,... { ArrayList() {...} ArrayList(int initialcapacity) {...} ArrayList(Collection<? extends E> coll) {...} void trimtosize() {...} void ensurecapacity(int mincapacity) {...} } Em caso de omissão, a capacidade inicial de um ArrayList é 10. LEEC@IST Java 47/83

48 Classe LinkedList (1) É uma implementação de List como uma lista duplamente ligada. A classe LinkedList implementa ainda a interface Queue. Complexidade: Adicionar (na posição i) e remover (da posição i): O(min{i,n-i}), onde n é o tamanho da lista. Adicionar (no princípio ou fim) e remover (do princípio ou fim): O(1). Aceder a um elemento na posição i: O(min{i,n-i}), onde n é o tamanho da lista. LEEC@IST Java 48/83

49 Classe LinkedList (2) Da análise da complexidade podemos concluir que: Deve ser usada uma LinkedList sempre que: Se tem uma lista cuja dimensão varia muito. É importante adicionar ou remover elementos numa posição arbitrária da lista. É preferível usar uma ArrayList sempre que: Se quer uma lista cujos elementos são sempre adicionais no fim. Se quer aceder aos seus elementos de uma forma muito eficiente. Java 49/83

50 Classe LinkedList (3) public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Queue<E>,... { LinkedList() {...} LinkedList(Collection<? Extends E> coll) {...} E getfirst() {...} E getlast {...} E removefirst() {...} E removelast() {...} void addfirst(e elem) {...} void addlast(e elem) {...} } LEEC@IST Java 50/83

51 Classes de legado As interfaces/classes relacionadas com colecções apresentadas até aqui são novas no pacote java.util. O java.util sempre conteve outras colecções, que mantém por razões de compatibilidade de versões. Destacam-se: Vector Stack Apesar de Vector e Stack serem classes de legado, implementam a interface List, logo funcionam como qualquer colecção. LEEC@IST Java 51/83

52 Classe Vector (1) public class Vector<E> extends AbstractList<E> implements List<E>,... { //Métodod novos, tal como em ArrayList Vector() {...}//ArrayList() Vector(int initialcapacity) {...}//ArrayList(initialCapacity) Vector(Collection<? Extends E> coll) {...}//ArrayList(coll) void trimtosize() {...} void ensurecapacity(int mincapacity) {...} //... Diferença para ArrayList (próximo slide) Em caso de omissão, a capacidade inicial de um Vector é 10. LEEC@IST Java 52/83

53 Classe Vector (2) } //Diferença para ArrayList Vector(int initialcapacity, int capacityincrement) {...} void copyinto(object[] anarray) {...} int indexof(object elem, int index) {...} int lastindexof(object elem, int index) {...} void setsize(int newsize) {...} int capacity() {...} //Métodos de legado com equivalência em ArrayList void addelement(e elem) {...}//add(elem) void insertelement(e elem, int index) {...}//add(index,elem) void setelement(e elem, int index) {...}//set(index,elem) void removeelement(int index) {...}//remove(index) boolean removeelement(object elem) {...}//remove(elem) void removeallelements() {...}//clear() E elementat(int index) {...}//get(index) E firstelement() {...} //get(0) E lastelement() {...} //get(size()-1) LEEC@IST Java 53/83

54 Classe Vector (3) Utilização de Vector como classe de legado: Vector vector = new Vector(20); Utilização de Vector como colecção genérica: Vector<?> vector = new Vector<String>(20); Vector<String> vector = new Vector<String>(20); LEEC@IST Java 54/83

55 Classe Vector (4) import java.util.vector; public class Main { private final int SIZE = 10; private Vector vector = new Vector(SIZE); //... public static void main(string[] args) { Integer iobj; for(int index=0;index<size;index++) vector.addelement(new Integer(index)); for(int index=2;index<size;index+=2){ iobj=(integer)vector.elementat(index-1); vector.setelementat(new Integer(2*iobj.intValue()),index); } for(int index=0;index<size;index++) System.out.println( Índice = +index+ +vec.elementat(index)); } } LEEC@IST Java 55/83

56 Classe Vector (5) import java.util.vector; public class Main { private final int SIZE = 10; private Vector<Integer> vector = new Vector<Integer>(SIZE); //... public static void main(string[] args) { Integer iobj; for(int index=0;index<size;index++) vector.add(new Integer(index)); for(int index=2;index<size;index+=2){ iobj=(integer)vector.get(index-1); vector.set(new Integer(2*iobj.intValue()),index); } for(int index=0;index<size;index++) System.out.println( Índice = +index+ +vec.get(index)); } } LEEC@IST Java 56/83

57 Classe Vector (6) A implementação genérica de Vector permite que chamar directamente os métodos da classe tipo. Exemplo: Considere ContaOrdem e ContaPrazo descendente da classe abstracta Conta. Na Conta é definido o método abstracto juro(), que é implementado nas classes concretas. LEEC@IST Java 57/83

58 Classe Vector (7) Vector<Conta> arquivo = new Vector<Conta>(); //... arquivo.add(new ContaOrdem()); arquivo.add(new ContaPrazo()); //... for(i=0;i<arquivo.size();i++) (arquivo.get(i)).juro(); O método juro() executa a implementação da classe concreta correspondente (ligação dinâmica). A criação de novas classes (de um subtipo de Conta) não requerem a alteração do código existente, facilitando a evolução das aplicações informáticas. LEEC@IST Java 58/83

59 Classe Stack A classe Stack é uma classe derivada de Vector que adiciona métodos para obter uma estrutura de dados FIFO. public class Stack<E> extends Vector<E> { Stack(); E push(e item); E pop(); E peek(); boolean empty(); int search(object o); } LEEC@IST Java 59/83

60 Implementações de List Vantagens Resolvem o inconveniente da dimensão das tabelas não poderem ser alteradas após a instanciação. Inconvenientes Apenas podem armezenar objectos (dados de tipo primitivo têm de ser armazenados como objectos de embrulho). Acesso às tabelas é mais eficiente. LEEC@IST Java 60/83

61 Classe Arrays (1) A classe estáticaarrays é criada pelo J2SE e disponibiliza métodos para manipulação de tabelas. A grande maioria dos métodos têm várias sobreposições: Uma para tabelas de cada tipo primitivo. Uma para tabelas de Object. Os métodos são ainda disponibilizados em duas variantes: Uma actuando em toda a tabela. Outra actuando numa subtabela especificada por dois índices. LEEC@IST Java 61/83

62 Classe Arrays (2) Os métodos da classearrays são: static void sort: Ordenação ascendente, com parâmetros: 1. Tabela a ordenar (obrigatório) 2. Dois índices, mínimo e máximo, que definem a subtabela (por omissão, é toda a tabela) 3. Um objectocomparator, que induz ordem nos elementos da tabela (por omissão, ordem natural definida pelocomparable) static int binarysearch: Procura binária (a tabela tem de estar ordenada em ordem ascendente), com parâmetros: 1. Tabela a procurar (obrigatório) 2. Valor a pesquisar (obrigatório) 3. Um objectocomparator, que induz ordem nos elementos da tabela (por omissão, ordem natural definida pelocomparable). LEEC@IST Java 62/83

63 Classe Arrays (3) Integer inteiros[] = new Integer[2]; inteiros[0]=1; inteiros[1]=2; System.out.println(Arrays.binarySearch(inteiros,1)); inteiros[0]=2; inteiros[1]=1; System.out.println(Arrays.binarySearch(inteiros,1)); No terminal é impresso 0-1 LEEC@IST Java 63/83

64 Classe Arrays (4) static void fill: Preenchimento de posições, com parâmetros: 1. Tabela a preencher (obrigatório) 2. Dois índices, mínimo e máximo, que definem a subtabela (por omissão, é toda a tabela) 3. Valor a inserir (obrigatório) static boolean equals: Verifica igualdade por equivalência de duas tabelas, com parâmetros: 1. Duas tabelas do mesmo tipo (obrigatório) static boolean deepequals: Verifica igualdade por equivalência de tabelas aninhadas de qualquer dimensão, com parâmetros: 1. Duas tabelas de tipo Object (obrigatório) LEEC@IST Java 64/83

65 Classe Arrays (5) static int hashcode: devolve o código de dispersão da tabela recebida como parâmetro (baseada no seu conteúdo). static int deephashcode: devolve o código de dispersão da tabela de tipo Object recebida como parâmetro (baseada no seu conteúdo, e tendo em consideração aninhamento). static String tostring: devolve uma string que representa o conteúdo da tabela recebida como parâmetro. static String deeptostring: devolve uma string que representa o conteúdo, tendo em consideração aninhamento, da tabela de tipo Object recebida como parâmetro. static <T> List<T> aslist(t t): devolve uma List com os elementos recebido como parâmetro. Este método actua como uma ponte entre tabelas e colecções (para complementar o método toarray das colecções). LEEC@IST Java 65/83

66 Classe Arrays (6) Integer inteiros[][] = new Integer[2][5]; Arrays.fill(inteiros[0],0); Arrays.fill(inteiros[1],1); System.out.println("inteiros="+Arrays.deepToString(inteiros)); Integer outro[][] = new Integer[2][5]; Arrays.fill(outro[0],0); Arrays.fill(outro[1],1); System.out.println("outro="+Arrays.deepToString(outro)); System.out.println(inteiros.hashCode()+"\t"+ Arrays.hashCode(inteiros)+"\t"+ Arrays.hashCode(inteiros[0])+"\t"+Arrays.hashCode(inteiros[1])+"\t"+ Arrays.deepHashCode(inteiros)); System.out.println(outro.hashCode()+"\t"+ Arrays.hashCode(outro)+"\t"+ Arrays.hashCode(outro[0])+"\t"+Arrays.hashCode(outro[1])+"\t"+ Arrays.deepHashCode(outro)); No terminal é impresso inteiros=[[0, 0, 0, 0, 0], [1, 1, 1, 1, 1]] outro=[[0, 0, 0, 0, 0], [1, 1, 1, 1, 1]] LEEC@IST Java 66/83

67 Classe Arrays (7) List lista = new ArrayList(); lista.add(1); lista.add("hello"); Object[] objectos = new Object[2]; objectos = lista.toarray(); System.out.println(lista.equals(Arrays.asList(objectos))); System.out.println(objectos.equals(lista.toArray())); System.out.println(Arrays.equals(objectos,lista.toArray())); No terminal é impresso true false true LEEC@IST Java 67/83

68 Interface Queue (1) <<interface>> Collection E <<interface>> Queue E <<abstract>> E AbstractCollection <<abstract>> AbstractQueue E PriorityQueue E LEEC@IST Java 68/83

69 Interface Queue (2) public interface Queue<E> extends Collection<E> { E element(); // mostra a cabeça E peek(); // mostra a cabeça ou null E remove(); // mostre e remove a cabeça E pool(); // mostra e remove a cabeça ou null boolean offer(e elem); // insere elemento } LEEC@IST Java 69/83

70 Interface Queue (3) Apesar de as colecções aceitarem elementos nulos, uma Queue não deve ter elementos null, pois o null é usado no retorno dos métodos peek e poll para indicar que a Queue está vazia. A classlinkedlist é a implementação mais simples da interface Queue. Por razões históricas são permitidos elementos null numa LinkedList. Deve evitar-se inserir elementos null numa LinkedList sempre que esta for usada como uma Queue. LEEC@IST Java 70/83

71 Classe PriorityQueue (1) A PriorityQueue é uma outra implementação de Queue. A implementação da PriorityQueue é baseada num acervo (heap). A cabeça da fila prioritária é o elemento menor que a fila contém. O menor elemento é determinado pela ordem natural dos elementos, ou indicado por um comparador entre dois elementos. Se o menor elemento representa o elemento com menor ou maior prioridade depende de como a ordem natural ou o comparador fornecido estão definidos. LEEC@IST Java 71/83

72 Classe PriorityQueue (2) O iterador da PriorityQueue não varre necessariamente os elementos da fila por ordem de prioridade. Na realidade, o iterator segue a ordem de armazenamento no acervo. Apenas é garantido que remover elementos da fila prioritária ocorre por ordem de prioridade. LEEC@IST Java 72/83

73 Classe PriorityQueue (3) Construtores de PriorityQueue: public PriorityQueue() public PriorityQueue(int initialcapacity) public PriorityQueue(int initialcapacity, Comparator<? super E> comp) public PriorityQueue(Collection<? extends E> coll) public PriorityQueue(SortedSet<? extends E> coll) public PriorityQueue(PriorityQueue<? extends E> coll) A capacidade é ilimitada, mas o ajustamento é computacionalmente pesado. LEEC@IST Java 73/83

74 Classe PriorityQueue (4) public class Task { String name; // identificador int level; // prioridade } public int level() { return level; } public void newlevel(int value) { level = value; } public Task(String name, int l) { this.name=name; level = l; } LEEC@IST Java 74/83

75 Classe PriorityQueue (5) private static class TaskComparator implements Comparator<Task> { public int compare(task l, Task r) { return l.level() r.level(); } } LEEC@IST Java 75/83

76 Classe PriorityQueue (6) PriorityQueue<Task> pq = new PriorityQueue<Task>(10,new TaskComparator()); Task t; for (char letter='a';letter<='g';letter++) pq.add(new Task("Task "+letter,((letter-'a')%4)); while (!pq.isempty()){ t=pq.poll(); System.out.println(t.toString()+" priority= +t.level()); } No terminal é impresso: Tarefa A prioridade=0 Tarefa E prioridade=0 Tarefa B prioridade=1 Tarefa F prioridade=1 Tarefa C prioridade=2 Tarefa G prioridade=2 Tarefa D prioridade=3 LEEC@IST Java 76/83

77 Interface Map (1) A interface Map<K,V> não estende a interface Collection. Principais caracteristicas dum Map<K,V>: Não são adicionados elementos a um mapa, mas sim um par chave/elemento. Um mapa permite aceder a um valor dada uma chave. Uma chave mapeia zero ou um valor. Um valor pode ser mapeado por várias chaves. Um mapa estabelece uma função parcial de chaves para valores. LEEC@IST Java 77/83

78 Interface Map (2) Métodos básicos da interface Map<K,V>: int size(); boolean isempty(); boolean containskey(object key); boolean containsvalue(object value); V get(object key); V put(k key, V value); V remove(object key); void putall(map<? extends K,? extends V> othermap) void clear(); LEEC@IST Java 78/83

79 Interface Map (3) Alguns métodos para vermap<k,v> como Collection: Set<K> keyset(); Collection<V> values(); Da interface Map são derivadas outras interfaces: SortedMap: chaves encontram-se ordenadas ConcurrentMap Java 79/83

80 Classe HashMap (1) A classehashmap é uma implementação da interface Map por uma tabela de dispersão. O desempenho é muito bom. Construtores da classe HashMap: public HashMap(int initialcapacity, float loadfactor) public HashMap(int initialcapacity) public HashMap() public HashMap(Map<? extends K,? extends V> map) LEEC@IST Java 80/83

81 Classe HashMap (2) import java.util.*; String str; Long l; Map store = new HashMap(); // nome usado como chave str = Miguel ; l = new Long(1327); store.put(str,l); l = (Long) store.get(str); if (l!=null) System.out.println( Codigo de +str+ = +l.longvalue()); str = Luisa ; l = new Long(9261); store.put(str,l); l = (Long) store.get(str); if (l!=null) System.out.println( Codigo de +str+ = +l.longvalue()); LEEC@IST Java 81/83

82 Interface SortedMap interface SortedMap<K,V> extends Map<K,V> { Comparator<? super K> comparator(); K firstkey(); K lastkey(); SortedMap<K,V> submap(k minkey, K maxkey); SortedMap<K,V> headmap(k maxkey); SortedMap<K,V> tailmap(k minkey); } LEEC@IST Java 82/83

83 ClassTreeMap A classetreemap é uma implementação da interface SortedMap por uma árvore binária balanceada. O acesso é menos eficiente. Mas os elementos estão sempre ordenados. No programa exemplo de HashMap apenas se substitui a declaração: Map store = new TreeMap(); LEEC@IST Java 83/83