Coleções - continuação. Profa. Thienne Johnson EACH/USP
|
|
|
- Rafaela Antunes Corte-Real
- 9 Há anos
- Visualizações:
Transcrição
1 Coleções - continuação Profa. Thienne Johnson EACH/USP
2 Java, como programar, 6ª edição Deitel & Deitel Capítulo 19
3 A estrutura de coleções fornece vários algoritmos para operações em coleções Esses algoritmos estão implementados como métodos static da classe Collections 3
4 Algoritmos que operam em objetos da classe List: sort: classifica os elementos da lista binarysearch: localiza um elemento da lista reverse: inverte os elementos da lista shuffle: embaralha os elementos da lista fill: preenche uma lista copy: copia referências de uma lista em outra lista 4
5 Algoritmos que operam em objetos da classe Collection: min: retorna o menor elemento em uma coleção max: retorna o maior elemento em uma coleção frequency: calcula quantos elementos em uma coleção são iguais a um elemento especificado disjoint: determina se duas coleções não têm nenhum elemento em comum 5
6 O algoritmo sort classifica (ordena) os elementos de uma lista List os tipos dos elementos da lista devem implementar a interface Comparable A ordem entre os elementos da lista é determinada pela ordem natural do tipo dos elementos esquema implementado pela classe no método compareto 6
7 import java.util.list; import java.util.arrays; import java.util.collections; Classifica os elementos de uma lista em ordem crescente public class Sort1 private static final String suits[] = "Hearts", "Diamonds", "Clubs", "Spades" }; public void printelements() // exibe elementos do array List< String > list = Arrays.asList( suits ); // cria List // gera saída da lista System.out.printf( "Unsorted array elements:\n%s\n", list); Collections.sort( list ); // classifica ArrayList // gera saída da lista System.out.printf( "Sorted array elements:\n%s\n", list); } // fim do método printelements 7
8 Chama o método aslist da classe Arrays import java.util.list; import java.util.arrays; import java.util.collections; para permitir que o conteúdo do array seja manipulado como uma lista public class Sort1 private static final String suits[] = "Hearts", "Diamonds", "Clubs", "Spades" }; public void printelements() // exibe elementos do array List< String > list = Arrays.asList( suits ); // cria List // gera saída da lista System.out.printf( "Unsorted array elements:\n%s\n", list); Collections.sort( list ); // classifica ArrayList // gera saída da lista System.out.printf( "Sorted array elements:\n%s\n", list); } // fim do método printelements 8
9 import java.util.list; import java.util.arrays; import java.util.collections; Chamada implícita ao método tostring public class Sort1 private static final String suits[] = "Hearts", "Diamonds", "Clubs", "Spades" }; da classe List para gerar a saída do conteúdo da lista public void printelements() // exibe elementos do array List< String > list = Arrays.asList( suits ); // cria List // gera saída da lista System.out.printf( "Unsorted array elements:\n%s\n", list); Collections.sort( list ); // classifica ArrayList // gera saída da lista System.out.printf( "Sorted array elements:\n%s\n", list); } // fim do método printelements 9
10 import java.util.list; import java.util.arrays; import java.util.collections; public class Sort1 private static final String suits[] = "Hearts", "Diamonds", "Clubs", "Spades" }; Classifica a lista list public void printelements() // exibe elementos do array List< String > list = Arrays.asList( suits ); // cria List em ordem crescente // gera saída da lista System.out.printf( "Unsorted array elements:\n%s\n", list); Collections.sort( list ); // classifica ArrayList // gera saída da lista System.out.printf( "Sorted array elements:\n%s\n", list); } // fim do método printelements 10
11 O algoritmo BinarySearch tenta localizar um elemento em uma lista List se o elemento for encontrado, seu índice é retornado se o elemento não for encontrado, o algoritmo retorna um valor negativo 11
12 Algoritmo BinarySearch Observação: o algoritmo BinarySearch espera que os elementos da lista estejam classificados em ordem crescente 12
13 Utiliza o algoritmo BinarySearch para procurar uma série de strings em uma ArrayList import java.util.list; import java.util.arrays; import java.util.collections; import java.util.arraylist; public class BinarySearchTest private static final String colors[] = "red", "white", "blue", "black", "yellow", "purple", "tan", "pink" }; private List< String > list; // ArrayList reference // cria, classifica e gera a saída da lista public BinarySearchTest() list = new ArrayList< String >( Arrays.asList( colors ) ); Collections.sort( list ); // sort the ArrayList System.out.printf( "Sorted ArrayList: %s\n", list ); } // end BinarySearchTest constructor 13
14 import java.util.list; import java.util.arrays; import java.util.collections; import java.util.arraylist; public class BinarySearchTest private static final String colors[] = "red", "white", "blue", "black", "yellow", "purple", "tan", "pink" }; private List< String > list; // ArrayList reference Classifica a lista com o método sort da interface Collection // cria, classifica e gera a saída da lista public BinarySearchTest() list = new ArrayList< String >( Arrays.asList( colors ) ); Collections.sort( list ); // sort the ArrayList System.out.printf( "Sorted ArrayList: %s\n", list ); } // end BinarySearchTest constructor 14
15 import java.util.list; import java.util.arrays; import java.util.collections; import java.util.arraylist; public class BinarySearchTest private static final String colors[] = "red", "white", "blue", "black", "yellow", "purple", "tan", "pink" }; private List< String > list; // ArrayList reference // cria, classifica e gera a saída da lista public BinarySearchTest() Gera a saída da lista classificada list = new ArrayList< String >( Arrays.asList( colors ) ); Collections.sort( list ); // sort the ArrayList System.out.printf( "Sorted ArrayList: %s\n", list ); } // end BinarySearchTest constructor 15
16 Realiza a pesquisa e envia o resultado para a saída private void printsearchresults( String key ) int result = 0; System.out.printf( "\n Buscando o elemento: %s\n", key ); result = Collections.binarySearch( list, key ); if ( result >= 0 ) System.out.printf( Elemento encontrado no índice %d\n", result ); else System.out.printf( Elemento não encontrado! (%d)\n",result ); } // fim do método printsearchresults 16
17 Chama o método binarysearch da interface Collection para buscar um elemento (key) em uma lista (list) private void printsearchresults( String key ) int result = 0; System.out.printf( "\n Buscando o elemento: %s\n", key ); result = Collections.binarySearch( list, key ); if ( result >= 0 ) System.out.printf( Elemento encontrado no índice %d\n", result ); else System.out.printf( Elemento não encontrado! (%d)\n",result ); } // fim do método printsearchresults 17
18 Um conjunto (Set) é uma coleção que contém elementos únicos não duplicados A classe HashSet implementa a interface Set 18
19 Exemplo de um método que aceita um argumento Collection e constrói uma coleção HashSet a partir desse argumento private void printnonduplicates( Collection< String > collection ) // create a HashSet Set< String > set = new HashSet< String >( collection ); System.out.println( "\n A coleção sem duplicatas: " ); for ( String s : set ) System.out.printf( "%s ", s ); System.out.println(); } // end method printnonduplicates 19
20 Por definição, coleções da classe Set não contêm duplicatas, então quando a coleção HashSet é construída, ela remove quaisquer duplicatas passadas pelo argumento Collection private void printnonduplicates( Collection< String > collection ) // create a HashSet Set< String > set = new HashSet< String >( collection ); System.out.println( "\n A coleção sem duplicatas: " ); for ( String s : set ) System.out.printf( "%s ", s ); System.out.println(); } // end method printnonduplicates 20
21 import java.util.list; import java.util.arrays; import java.util.hashset; import java.util.set; import java.util.collection; public class SetTest private static final String colors[] = vermelho", branco", azul", verde", cinza", laranja", amarelo", branco", rosa", violeta", cinza", laranja" }; public SetTest() List< String > list = Arrays.asList( colors ); System.out.printf( "ArrayList: %s\n", list ); printnonduplicates( list ); } // end SetTest constructor public static void main( String args[] ) new SetTest(); } // end main } // end class SetTest Qual é a saída desse programa? 21
22 Saída do programa: ArrayList: [vermelho, branco, azul, verde, cinza, laranja, amarelo, branco, rosa, violeta, cinza, laranja] A coleção sem duplicatas: vermelho branco azul verde cinza laranja amarelo rosa violeta 22
23 A estrutura de coleções também inclui a interface SortedSet: estende a interface Set representa conjuntos que mantêm seus elementos ordenados A classe TreeSet implementa a interface SortedSet 23
24 HashSet is much faster than TreeSet but offers no ordering guarantees. If you need to use the operations in the SortedSet interface, or if value-ordered iteration is required, use TreeSet; otherwise, use HashSet. It's a fair bet that you'll end up using HashSet most of the time.
25 Insere strings em uma coleção TreeSet import java.util.arrays; import java.util.sortedset; import java.util.treeset; public class SortedSetTest private static final String names[] = amarelo", verde", preto", marrom", cinza", branco", laranja", vermelho", verde" }; // create a sorted set with TreeSet, then manipulate it public SortedSetTest() // create TreeSet SortedSet< String > tree = new TreeSet< String >( Arrays.asList( names ) ); 25
26 Coleção TreeSet import java.util.arrays; import java.util.sortedset; import java.util.treeset; public class SortedSetTest private static final String names[] = "yellow", "green", "black", "tan", "grey", "white", "orange", "red", "green" }; As strings são classificadas à medida em que são adicionadas à coleção TreeSet // create a sorted set with TreeSet, then manipulate it public SortedSetTest() // create TreeSet SortedSet< String > tree = new TreeSet< String >( Arrays.asList( names ) ); 26
27 Coleção TreeSet System.out.println( conjunto ordenado: " ); printset( tree ); Gera a saída do conjunto inicial de strings utilizando o método printset 27
28 Coleção TreeSet Aceita uma coleção SortedSet como argumento e a imprime private void printset( SortedSet< String > set ) for ( String s : set ) System.out.print( s + " " ); } System.out.println(); 28
29 Coleção TreeSet System.out.println( conjunto ordenado: " ); printset( tree ); Saída: conjunto ordenado: amarelo branco cinza laranja marrom preto verde vermelho 29
30 Coleção TreeSet System.out.print( "\n headset (\ laranja\"): " ); printset( tree.headset( laranja" ) ); Chama o método headset da classe TreeSet para obter um subconjunto em que cada elemento é menor do que laranja 30
31 Coleção TreeSet System.out.print( "\n headset (\ laranja\"): " ); printset( tree.headset( laranja" ) ); Saída: conjunto ordenado: amarelo branco cinza laranja marrom preto verde vermelho headset( laranja ): amarelo branco cinza 31
32 Coleção TreeSet System.out.print( "\n tailset (\ laranja\"): " ); printset( tree.tailset( laranja" ) ); Chama o método tailset da classe TreeSet para obter um subconjunto em que cada elemento é maior ou igual a laranja 32
33 Coleção TreeSet System.out.print( "\n tailset (\ laranja\"): " ); printset( tree.tailset( laranja" ) ); Saída: conjunto ordenado: amarelo branco cinza laranja marrom preto verde vermelho headset( laranja ): amarelo branco cinza tailset( laranja ): laranja marrom preto verde vermelho 33
34 Coleção TreeSet System.out.printf( "first: %s\n", tree.first() ); System.out.printf( "last : %s\n", tree.last() ); Chama os métodos first e last da classe TreeSet para obter o menor e o maior elementos do conjunto 34
35 Coleção TreeSet System.out.printf( "first: %s\n", tree.first() ); System.out.printf( "last : %s\n", tree.last() ); Saída: conjunto ordenado: amarelo branco cinza laranja marrom preto verde vermelho headset( laranja ): amarelo branco cinza tailset( laranja ): laranja marrom preto verde vermelho first: amarelo last: vermelho 35
36 Um mapa (Map) associa chaves a valores e não pode conter chaves duplicatas cada chave pode mapear somente um valor (mapeamento um para um) Classes que implementam a interface Map HashMap TreeMap 36
37 If you need key-ordered Collection-view iteration, use TreeMap; If you want maximum speed and don't care about iteration order, use HashMap;
38 A interface (SortedMap) estende a interface Map e mantém as suas chaves ordenadas A classe TreeMap implementa a interface SortedMap 38
39 Coleção HashMap Utiliza uma coleção HashMap para contar o número de ocorrências de cada palavra em uma string import java.util.stringtokenizer; import java.util.map; import java.util.hashmap; import java.util.set; import java.util.treeset; import java.util.scanner; public class WordTypeCount private Map< String, Integer > map; private Scanner scanner; public WordTypeCount() map = new HashMap< String, Integer >(); // cria HashMap scanner = new Scanner( System.in ); // cria scanner createmap(); // cria mapa baseado na entrada do usuário displaymap(); // apresenta conteúdo do mapa }//fim do construtor de WordTypeCount 39
40 Coleção HashMap 1. import java.util.stringtokenizer; 2. import java.util.map; 3. import java.util.hashmap; 4. import java.util.set; 5. import java.util.treeset; 6. import java.util.scanner; Cria uma coleção HashMap vazia com chaves do tipo 1. public class WordTypeCount 2. Stringprivate e valores Map< do String, tipo Integer > map; 3. private Scanner scanner; 4. public WordTypeCount() 5. map = new HashMap< String, Integer >(); // cria HashMap 6. scanner = new Scanner( System.in ); // cria scanner 7. createmap(); // cria mapa baseado na entrada do usuário 8. displaymap(); // apresenta conteúdo do mapa 9. }//fim do construtor de WordTypeCount 40
41 Coleção HashMap 1. import java.util.stringtokenizer; 2. import java.util.map; 3. import java.util.hashmap; 4. import java.util.set; 5. import java.util.treeset; 6. import java.util.scanner; Cria uma objeto Scanner que lê a entrada do usuário 1. public class WordTypeCount 2. private Map< String, Integer > map; 3. private Scanner scanner; 4. public WordTypeCount() 5. map = new HashMap< String, Integer >(); // cria HashMap 6. scanner = new Scanner( System.in ); // cria scanner 7. createmap(); // cria mapa baseado na entrada do usuário 8. displaymap(); // apresenta conteúdo do mapa 9. }//fim do construtor de WordTypeCount a partir do fluxo de entrada padrão 41
42 Coleção HashMap 1. import java.util.stringtokenizer; 2. import java.util.map; 3. import java.util.hashmap; 4. import java.util.set; 5. import java.util.treeset; 6. import java.util.scanner; 1. public class WordTypeCount 2. private Map< String, Integer > map; 3. private Scanner scanner; 4. public WordTypeCount() 5. map = new HashMap< String, Integer >(); // cria HashMap 6. scanner = new Scanner( System.in ); // cria scanner 7. createmap(); // cria mapa baseado na entrada do usuário 8. displaymap(); // apresenta conteúdo do mapa 9. }//fim do construtor de WordTypeCount Chama o método createmap para armazenar no mapa o número de ocorrências de cada palavra na frase 42
43 Coleção HashMap Método createmap: armazena em um mapa o número de ocorrências de cada palavra na frase do usuário private void createmap() System.out.println( "Entre com uma string:" ); // prompt para entrada do String input = scanner.nextline(); // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 43
44 Invoca o método nextline da classe Scanner para ler a entrada do usuário private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 44
45 Cria um objeto StringTokenizer para dividir a private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); string de entrada em suas palavras componentes individuais // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 45
46 private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); Utiliza o método hasmoretokens para determinar se há mais tokens na string sendo separada em tokens // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 46
47 private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); Se houver mais tokens, o próximo é convertido em letras minúsculas // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 47
48 private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); O próximo token é obtido com uma chamada ao método nexttoken da classe StringTokenizer, // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); que retorna uma string // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 48
49 private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); Chama o método containskey da classe Map // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra para determinar se a palavra já está no mapa // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 49
50 private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); Se a palavra estiver no mapa, utiliza o método get da classe Map para obter o valor associado // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra (a contagem) da chave no mapa // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 50
51 private void createmap() System.out.println( "Entre com uma frase:" ); // prompt para entrada do usuário String input = scanner.nextline(); // cria um objeto StringTokenizer para a entrada StringTokenizer tokenizer = new StringTokenizer( input ); // processando o texto de entrada while ( tokenizer.hasmoretokens() ) // enquanto tiver mais entrada String word = tokenizer.nexttoken().tolowercase(); // captura palavra Incrementa esse valor e utiliza o método put da classe Map para substituir o valor associado à chave no mapa // se o mapa contiver a palavra if ( map.containskey( word ) ) // a palavra está no mapa? int count = map.get( word ); // obtém contagem atual map.put( word, count + 1 ); // incrementa a contagem } // fim if else map.put( word, 1 ); // adiciona a nova palavra com contagem 1 ao mapa } // end while } // end method createmap 51
52 1. import java.util.stringtokenizer; 2. import java.util.map; 3. import java.util.hashmap; 4. import java.util.set; 5. import java.util.treeset; 6. import java.util.scanner; 1. public class WordTypeCount 2. private Map< String, Integer > map; 3. private Scanner scanner; 4. public WordTypeCount() 5. map = new HashMap< String, Integer >(); // cria HashMap 6. scanner = new Scanner( System.in ); // cria scanner 7. createmap(); // cria mapa baseado na entrada do usuário 8. displaymap(); // apresenta conteúdo do mapa 9. }//fim do construtor de WordTypeCount Chama o método displaymap para exibir todas as entradas do mapa 52
53 Método displaymap: exibe todas as entradas armazenadas em um mapa private void displaymap() Set< String > keys = map.keyset(); // obtém as chaves // ordena as chaves TreeSet< String > sortedkeys = new TreeSet< String >( keys ); System.out.println( O mapa contém:\nkey\t\tvalue" ); // gera a saída para cada chave no mapa for ( String key : sortedkeys ) System.out.printf( "%s\t\t%s \n", key, map.get( key ) ); } // end method displaymap 53
54 Utiliza o método keyset da classe HashMap para obter um conjunto das chaves private void displaymap() Set< String > keys = map.keyset(); // obtém as chaves // ordena as chaves TreeSet< String > sortedkeys = new TreeSet< String >( keys ); System.out.println( O mapa contém:\nkey\t\tvalue" ); // gera a saída para cada chave no mapa for ( String key : sortedkeys ) System.out.printf( "%s\t\t%s \n", key, map.get( key ) ); } // end method displaymap 54
55 Cria um objeto TreeSet com as chaves, private void displaymap() em que as chaves são ordenadas Set< String > keys = map.keyset(); // obtém as chaves // ordena as chaves TreeSet< String > sortedkeys = new TreeSet< String >( keys ); System.out.println( O mapa contém:\nkey\t\tvalue" ); // gera a saída para cada chave no mapa for ( String key : sortedkeys ) System.out.printf("%s\t\t%s \n", key, map.get( key ) ); } // end method displaymap 55
56 private void displaymap() Set< String > keys = map.keyset(); // obtém as chaves // ordena as chaves TreeSet< String > sortedkeys = new TreeSet< String >( keys ); Imprime cada chave e seu valor no mapa System.out.println( O mapa contém:\nkey\t\tvalue" ); // gera a saída para cada chave no mapa for ( String key : sortedkeys ) System.out.printf("%s\t\t%s \n", key, map.get( key ) ); } // end method displaymap 56
57 Saída: Entre com uma frase: To be or not to be: that is the question O mapa contém: Key Value be 1 be: 1 is 1 not 1 or 1 question 1 that 1 the 1 to 2 57
58
JAVA COLLECTIONS API: LISTAS
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,
Programação Orientada a Objectos - P. Prata, P. Fazendeiro
Java Collections Framework (JCF) Uma coleção (collection) é um objeto que agrupa vários elementos. A JCF consiste numa arquitetura para representação e manipulação de coleções. Contém: - Um conjunto de
Coleções. Prof. Marcelo Roberto Zorzan
Coleções Prof. Marcelo Roberto Zorzan Coleções Aula de Hoje Introdução Coleções podem representar estruturas de dados complexas de forma transparente para o programador. Exemplos: Músicas favoritas armazenadas
Programação Orientada a Objetos. Collections - Java
1 Programação Orientada a Objetos Collections - Java Coleções Conceito Geral Uma coleção é uma estrutura de dados que permite armazenar vários objetos. Em Java, a coleção também é um objeto. As operações
Programação Orientada a Objetos
Programação Orientada a Objetos Prof. Kléber de Oliveira Andrade [email protected] Coleções, Propriedades, Resources e Strings (Parte 2) Coleções É comum usarmos um objeto que armazena vários outros
Coleções by Pearson Education do Brasil
1 19 Coleções 2 OBJETIVOS Neste capítulo, você aprenderá: O que são coleções. Como utilizar a classe Arrays para manipulações de array. Como utilizar implementações de estrutura de coleções (estrutura
Collections Framework
Collections Framework 1 Arrays p Manipular array é bastante trabalhoso. p Dificuldades aparecem em diversos momentos: n não podemos redimensionar um array em Java; n é impossível buscar diretamente por
Lista encadeada class No { Coleções. Enumeration. Lista encadeada (continuação) Enumeration Exemplo usando a classe Lista anterior
Coleções Retirado do Tutorial Java class Lista { No inicio = null; Lista encadeada class No { void insereinicio(object obj) { No n = new No(obj, inicio); inicio = n; Object obj; No prox; No(Object obj,
Java Util Collections - Interfaces Interfaces definidas
Java Util Collections - Interfaces Interfaces definidas 245 Collection Raiz da hierarquia Grupo mais genérico de elementos Não garante nas implementações Duplicatas Ordenação Não possui nenhuma implementação
Instituto Federal de Educação, Ciência e Tecnologia da Bahia Campus Irecê Disciplina: Linguagem Técnica II Prof o Jonatas Bastos
Instituto Federal de Educação, Ciência e Tecnologia da Bahia Campus Irecê Disciplina: Linguagem Técnica II Prof o Jonatas Bastos Nome: LISTA DE EXERCÍCIO 1 Collections Framework 1. Criem um projeto que
Laboratório de Programação. Aula 13 Java 5COP088. Aula 13 Genéricos e Conjuntos Java Prof. Dr. Sylvio Barbon Junior. Sylvio Barbon Jr barbon@uel.
5COP088 Laboratório de Programação Aula 13 Genéricos e Conjuntos Java Prof. Dr. Sylvio Barbon Junior 1 Sumário: 1) Métodos hashcode(), equals() e tostring(); 2) Conjuntos; 3) Genéricos; 4) Resumo. 2 1)
API e Coleções Java. Sérgio Luiz Ruivace Cerqueira
API e Coleções Java Sérgio Luiz Ruivace Cerqueira [email protected] Java API Introdução API Endereço http://download.oracle.com/javase/6/docs/api/ API - Descrição API - Resumo API - Detalhes Coleções
Interface Collection. Coleções em Java Collections Genéricos em Java - Generics. Interface Collection
1 Interface Collection 2 Coleções em Java Collections Genéricos em Java - Generics O trecho seguinte mostra a interface Collection. public interface Collection extends Iterable { // operações básicas
Alberto Costa Neto DComp - UFS. Coleções
Alberto Costa Neto DComp - UFS Coleções [ Conteúdo ] Introdução Interfaces e Classes para Coleções Coleções Especiais Classes de Coleções Históricas Suporte Algorítmico Questões de Utilização Novas coleções
Collections. Programação Orientada por Objetos (POO) Centro de Cálculo Instituto Superior de Engenharia de Lisboa
Collections Programação Orientada por Objetos (POO) Centro de Cálculo Instituto Superior de Engenharia de Lisboa Pedro Alexandre Pereira ([email protected]) Coleções em Java As coleções agrupam vários
I.1 Introdução BitSet I.2 Manipulação de bits e os operadores de bits E sobre bits & OU inclusivo sobre bits OU exclusivo sobre bits
I Manipulação de bits I.1 Introdução Este apêndice apresenta uma extensa discussão sobre os operadores de manipulação de bits e também sobre a classe BitSet que permite a criação de objetos do tipo array
Orientação a Objetos AULA 09
Orientação a Objetos AULA 09 Prof. Fabrício Martins Mendonça Conteúdo da Aula ü Coleções ü Coleções lista de objetos ü Coleções conjuntos 2 Coleções Podemos armazenar vários objetos em um array e este
Coleções. Page 1. Coleções. Prof. Anderson Augustinho Uniandrade
Page 1 podem ser comparadas com arrays, visto que também apresentam a capacidade de armazenar referências para vários objetos. Entretanto, as coleções apresentam uma gama de funcionalidades bem maior do
Java Standard Edition (JSE)
Java Standard Edition (JSE) 13. Collections framework Esp. Márcio Palheta Gtalk: [email protected] 1 Agenda Revisão de dificuldades com Arrays; Trabalhando com Listas - List; Uso de Generics; Interfaces
Tratamento de Exceções. Profa. Thienne Johnson EACH/USP
Tratamento de Exceções Profa. Thienne Johnson EACH/USP Java, como programar Deitel & Deitel Capítulo 14 Uma exceção é uma indicação de um problema que ocorre durante a execução de um programa O tratamento
Vetores Unimensionais
Vetores Unimensionais Objetivos Entender a importância e a necessidade do uso de Vetores Definição de Manipulação de Vetores Inserir elementos em um vetor (usando laços ou não) Imprimir elementos de um
Coleções em Java. Prof. Gustavo Willam Pereira ENG10082 Programação II. Créditos: Prof. Clayton Vieira Fraga Filho
Coleções em Java Prof. Gustavo Willam Pereira ENG10082 Programação II Créditos: Prof. Clayton Vieira Fraga Filho Introdução O que é uma coleção? Um objeto que agrupa múltiplos elementos em uma única unidade
Classes, instâncias e métodos de acesso. prática
Classes, instâncias e métodos de acesso prática Exercício 01 Crie a classe Ponto que possui duas dimensões (int x, int y). Crie os métodos get e set. Faça o main para instanciar e testar a classe. Adicione
MODEL-VIEW-CONTROLER. Prof. Fellipe Aleixo
MODEL-VIEW-CONTROLER Prof. Fellipe Aleixo ([email protected]) O Que é MVC? Modelo de arquitetura de software Separar dados ou lógica de negócios (Model) da interface do usuário (View) e do fluxo
Introdução. Coleção HashMap Classe Java. Interesse
Coleção Classe Java Introdução Interesse Modelar correspondências unívocas (1 para 1) entre objetos, do tipo chave-valor. Associações entre: um elemento de um conjunto de chaves um elemento de uma coleção
Classes o Objetos. Classes, objetos, métodos e variáveis de instância
Classes o Objetos Um recurso comum de cada aplicativo feito até agora é que todas as instruções que realizavam tarefas localizavam-se no método main. Se você tornar parte de uma equipe de desenvolvimento
Paradigmas da Programação PPROG. Tipos de Dados. Enumerados Genéricos Coleções. Nelson Freire (ISEP DEI-PPROG 2012/13) 1/64
PPROG Paradigmas da Programação Tipos de Dados Enumerados Genéricos Coleções Nelson Freire (ISEP DEI-PPROG 2012/13) 1/64 PPROG Sumário Geral Tipos Enumerados Tipos Genéricos Tipos Coleção Nelson Freire
Métodos Genéricos. Prof.: Michele Nasu Tomiyama Bucci
Métodos Genéricos Prof.: Michele Nasu Tomiyama Bucci Introdução Métodos genéricos e classes genéricas (e interfaces) permitem especificar, com uma única declaração de método, um conjunto de métodos relacionados
Exercícios Resolvidos. Java Básico
Exercícios Resolvidos Java Básico 1. Escrever um programa java que receba dois números e exiba o resultado da sua soma. // Programa de adição que permite a soma de dois números // Programa utiliza a classe
Paradigmas da Programação PPROG. Tipos Enumerados. Nelson Freire (ISEP DEI-PPROG 2013/14) 1/20
PPROG Paradigmas da Programação Tipos Nelson Freire (ISEP DEI-PPROG 2013/14) 1/20 Sumário Interesse Definição Implementação Declaração Valor de um Tipo Enumerado Variável de Tipo Enumerado Métodos Automáticos
Introdução a classes e objetos by Pearson Education do Brasil
1 3 Introdução a classes e objetos 2 OBJETIVOS Apresentação do Ambiente de Trabalho Como declarar uma classe e utilizá-la para criar um objeto. Como declarar métodos em uma classe para implementar os comportamentos
LÓGICA DE PROGRAMAÇÃO (JAVA) ESTRUTURAS REPETIÇÃO. Professor Carlos Muniz
LÓGICA DE PROGRAMAÇÃO (JAVA) ESTRUTURAS REPETIÇÃO Estruturas de repetição Estrutura de repetição nada mais é que laços de repetições. Laços de repetições permitem que um conjunto de instruções seja repetido
Programação Java. em Ambiente Distribuído. Ênfase no Mapeamento Objeto-Relacional com JPA, EJB e Hibernate. Douglas Rocha Mendes.
Programação Java em Ambiente Distribuído Ênfase no Mapeamento Objeto-Relacional com JPA, EJB e Hibernate Douglas Rocha Mendes Novatec Copyright 2011 da Novatec Editora Ltda. Todos os direitos reservados
private static Ascii ascii = new Ascii(); static List<Character> asciinumber = ascii.getasciitable(); Scanner input = new Scanner(System.
import java.util.arraylist; import java.util.list; import java.util.scanner; import cifravalida.ascii; public class Main { private static Ascii ascii = new Ascii(); static List asciinumber =
O JUnit permite a realização de testes de unidades, conhecidos como "caixa branca", facilitando assim a correção de métodos e objetos.
JUnit O JUnit é um framework open-source, criado por Erich Gamma e Kent Beck, com suporte à criação de testes automatizados na linguagem de programação Java. Esse framework facilita a criação de código
Vetores Unimensionais
Vetores Unimensionais Objetivos Entender a importância e a necessidade do uso de Vetores Definição de Manipulação de Vetores Inserir elementos em um vetor (usando laços ou não) Imprimir elementos de um
Programação Orientada a Objetos. Desenvolvimento. Desenvolvimento. Desenvolvimento. Alexandre César Muniz de Oliveira. Parte II
Programação Orientada a Objetos Alexandre César Muniz de Oliveira Parte II The sooner you begin to type code, the longer the program will take to finish,...... because careful design of the program must
Aula 4. TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS 2014 Marcelo Henrique dos Santos -
Programação Orientada a Objetos Aula 4 Programação Orientada a Objetos Entrada e Saída de Dados 1 O exemplo abaixo emprega o pacote Swing (javax.swing), que emprega componentes gráficos Java. //AloMundo
LÓGICA DE PROGRAMAÇÃO (JAVA) VARIÁVEIS. Professor Carlos Muniz
LÓGICA DE PROGRAMAÇÃO (JAVA) String String é uma classe contida no pacote java.lang e que descende da classe java.lang.object. De forma conceitual podemos dizer que é uma sequência de caracteres usada
4 TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
Programação Orientada a Objetos Aula 4 Programação Orientada a Objetos Entrada e Saída de Dados GUI em Java: pacote Swing O exemplo abaixo emprega o pacote Swing (javax.swing), que emprega componentes
JAVA. Professor: Bruno Toledo
JAVA Professor: Bruno Toledo Funcionamento de uma LP Em uma Linguagem de Programação (LP) como C e Pascal, temos o seguinte quadro quando vamos compilar um programa. Código fonte em c Teste.c Gera código
BSI UFRPE Prof. Gustavo Callou [email protected]
BSI UFRPE Prof. Gustavo Callou [email protected] Coleções List Set Map Classes e interfaces do pacote java.util que representam listas, conjuntos e mapas. Solução flexível para armazenar objetos. Quantidade
UNIP - Ciência da Computação e Sistemas de Informação. Estrutura de Dados. AULA 5 Pilhas
UNIP - Ciência da Computação e Sistemas de Informação Estrutura de Dados AULA Pilhas Estrutura de Dados A Estrutura de Dados Pilha Pilha é uma estrutura de dados usada em programação, que tem uma regra
UNIP - Ciência da Computação e Sistemas de Informação. Estrutura de Dados. AULA 6 Filas
UNIP - Ciência da Computação e Sistemas de Informação Estrutura de Dados AULA 6 Filas Estrutura de Dados A Estrutura de Dados Fila Fila é uma estrutura de dados usada em programação, que tem regras para
Recursividade. Prof. Jesus José de Oliveira Neto
Recursividade Prof. Jesus José de Oliveira Neto Algoritmos podem ser definidos de duas formas: Forma iterativa ou não recursiva: utiliza laços de repetição (while, for, do/while) Forma recursiva: métodos
AULA 6 - ARRAYS. Array de 10 elementos
1 AULA 6 - ARRAYS Arrays são objetos que armazenam diversas variáveis do mesmo tipo. Eles podem conter variáveis de referência primitivas ou de objeto, mas o array propriamente dito sempre será um objeto
Coleções POO. Prof. Marcio Delamaro
Coleções POO Prof. Marcio Delamaro Programação Orientada a Objetos Prof Marcio Delamaro ICMC/USP 1/54 Definição Interface Collection E - the type of elements in this collection The root interface in
Aula 08 Estruturas de Condição. Disciplina: Fundamentos de Lógica e Algoritmos Prof. Bruno Gomes
Aula 08 Estruturas de Condição Disciplina: Fundamentos de Lógica e Algoritmos Prof. Bruno Gomes http://www.profbrunogomes.com.br/ Agenda da Aula Entrada de Dados; Estruturas de Controle: Estrutura de Sequência;
Programação Orientada a Objetos
Programação Orientada a Objetos Engenharia da Computação Professor: Rosalvo Ferreira de Oliveira Neto Dados Pessoais Rosalvo Ferreira de Oliveira Neto MSc. em ciência da computação (UFPE) [email protected]
Introdução a classes e objetos. Prof. Marcelo Roberto Zorzan Prof a. Rachel Reis
Introdução a classes e objetos Prof. Marcelo Roberto Zorzan Prof a. Rachel Reis Estruturas de Seleção if... else Operador condicional (? : ) switch Aula de Hoje Estruturas de Repetição: while/do... while/for
Técnicas de Programação Avançada TCC- 00.174 Prof.: Anselmo Montenegro www.ic.uff.br/~anselmo [email protected]
Técnicas de Programação Avançada TCC- 00.174 Prof.: Anselmo Montenegro www.ic.uff.br/~anselmo [email protected] Conteúdo: Coleções Material elaborado com contribuição do Professor Luiz André Coleções Uma
PROGRAMAÇÃO ORIENTADA A OBJETOS: OCULTAR INFORMAÇÕES E ENCAPSULAMENTO
COLÉGIO ESTADUAL ULYSSES GUIMARÃES CURSO TÉCNICO PROFISSIONALIZANTE EM INFORMÁTICA ERINALDO SANCHES NASCIMENTO PROGRAMAÇÃO ORIENTADA A OBJETOS: OCULTAR INFORMAÇÕES E ENCAPSULAMENTO FOZ DO IGUAÇU 2013 LISTA
Introdução a classes e objetos. Prof. Marcelo Roberto Zorzan
Introdução a classes e objetos Prof. Marcelo Roberto Zorzan Aula de Hoje Abstração de Dados Classes e Objetos Definição de Métodos Métodos com parâmetro Abstração de Dados Processo mental através do qual
Coleções. Programação Orientada a Objetos Java. Prof. Geraldo Braz Junior
Coleções Programação Orientada a Objetos Java Prof. Geraldo Braz Junior Coleções de tamanho fixo Às vezes, o tamanho máximo de uma coleção pode ser pré-determinado. Vetores são um caso especial de coleção.
Algoritmos e Programação II. Coleções. Coleções. Baseado no material do Prof. Julio
Algoritmos e Programação II Baseado no material do Prof. Julio Coleções Java disponibiliza classes que facilitam o agrupamento e processamento de objetos em conjuntos: Coleções (Java Collections Framework).
Java Coleções. Rodrigo C. de Azevedo
Java Coleções Rodrigo C. de Azevedo OMG Certified UML Professional Fundamental OMG Certified UML Professional Intermediate CompTIA Project+ Sun Certified Associate for Java Platform Sun Certified Programmer
Coleções Avançadas. Programação Orientada a Objetos Java. Prof. Anselmo Cardoso Paiva Prof. Geraldo Braz Junior
Coleções Avançadas Programação Orientada a Objetos Java Prof. Anselmo Cardoso Paiva Prof. Geraldo Braz Junior Objetivos Aprender como o conceito de coleção pode ser expresso de forma genérica Examinar
Aula 5 POO 1 Encapsulamento. Profa. Elaine Faria UFU
Aula 5 POO 1 Encapsulamento Profa. Elaine Faria UFU - 2019 Sobre o Material Agradecimentos Aos professores José Gustavo e Fabiano, por gentilmente terem cedido seus materiais. Os slides consistem de adaptações
Técnicas de Programação II
Técnicas de Programação II Aula 04 Arrays Edirlei Soares de Lima Arrays Array é um mecanismo que nos permite armazenar um conjunto de valores na memória do computador. Em Java,
Capítulo 21. Rui Rossi dos Santos Programação de Computadores em Java Editora NovaTerra
Capítulo 21 Coleções Objetivos do Capítulo Analisar o conceito de coleção e sua relação com as estruturas de dados. Apresentar a arquitetura do framework de coleções do Java. Indicar as classes e interfaces
Vetores Unimensionais
Vetores Unimensionais Objetivos Entender a importância e a necessidade do uso de Vetores Definição de Manipulação de Vetores Inserir elementos em um vetor (usando laços ou não) Acessar elementos de um
Programação Orientada a Objetos II
Programação Orientada a Objetos II Introdução Prof. Rodrigo Rocha [email protected] www.bolinhabolinha.com Apresentação Prof. Rodrigo Rocha [email protected] Ementa Introdução ao Desenvolvimento
Árvores e Mapas. Luís Lopes. Estruturas de Dados DCC-FCUP
Árvores e Mapas Luís Lopes DCC-FCUP Estruturas de Dados Estruturas não lineares Os arrays e as listas são exemplos de estruturas de dados lineares, cada elemento tem: um predecessor único (excepto o primeiro
AULA TEÓRICA 7 Tema 7. Colecções (cont.) Vector Ø Criação Ø Manipulação
AULA TEÓRICA 7 Tema 7. Colecções (cont.) Vector Ø Criação Ø Manipulação 1 Vector Os vectores são semelhantes aos arrays, pois também podem conter um conjunto de objectos aos quais é atribuído um índice.
Prova 2 PMR3201 1o. semestre 2015 Prof. Thiago Martins
Prova PMR0 o semestre 0 Prof Thiago Martins Instruções: Escreva o nome e o número USP na folha de papel almaço ( pontos) Uma árvore binária de busca é uma árvore binária na qual para qualquer sub-árvore
Interfaces POO. Prof. Marcio Delamaro
Interfaces POO Prof. Marcio Delamaro Programação Orientada a Objetos Prof Marcio Delamaro ICMC/USP 1/41 O que é interface É um template de classe Outras classes podem seguir esse template Chamamos isso