Capítulo 6

281 views

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
281
On SlideShare
0
From Embeds
0
Number of Embeds
5
Actions
Shares
0
Downloads
1
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Capítulo 6

  1. 1. Grupo de Estudos Tecnológicos – NTI UVA Programando com Arrays Felizardo Charles
  2. 2.  Declarar e criar arrays
  3. 3.   Declarar e criar arrays Acessar elementos de um array
  4. 4.    Declarar e criar arrays Acessar elementos de um array Determinar o número de elementos em um array
  5. 5.     Declarar e criar arrays Acessar elementos de um array Determinar o número de elementos em um array Declarar e criar arrays multidimensionais
  6. 6.      Declarar e criar arrays Acessar elementos de um array Determinar o número de elementos em um array Declarar e criar arrays multidimensionais ArrayList ????? 
  7. 7.  Podemos utilizar uma variável para armazenar e manipular uma lista de dados de forma mais eficiente. Este tipo de variável é chamada de array
  8. 8.   Podemos utilizar uma variável para armazenar e manipular uma lista de dados de forma mais eficiente. Este tipo de variável é chamada de array Um array armazena múltiplos itens de dados do mesmo tipo em um bloco contínuo de memória, dividindo-o em certa quantidade de casas
  9. 9.  Escreve-se o tipo de dado seguido por colchetes (square brackets) e por um identificador. Ainda não precisa informar o tamanho. int [] meuArray; ou int meuArray[];
  10. 10.   Criar/instanciar o array é especificar seu tamanho com um parâmetro no construtor Escrever a palavra-chave new, definir o tipo de dado seguido por colchetes contendo a quantidade de elementos do array: // declaração int meuArray[]; // instanciando um objeto meuArray = new int[100]; ou // declarando e construindo um objeto int meuArray[] = new int[100];
  11. 11.  Pode-se, também, construir um array ao iniciá-lo diretamente com dados int meuArray[] = {1, 2, 3, 4, 5};  Este código declara e inicializa um array de inteiros com cinco elementos (inicializados com os valores 1, 2, 3, 4, e 5)
  12. 12.  boolean valores[] = { true, false, true, false };  double [] notas = {100, 90, 80, 75};  String dias[] = {“Seg", "Ter", “Qua", “Qui", “Sex", "Sab", “Dom"};  String[] clockTypes; //array de objetos  int[] alarms; //array de primitivos
  13. 13.    Clock[] clocks = {new Clock(1100), new Clock(2250)}; O array acima instancia a classe Clock que, em seu construtor, exige que seja informado um argumento. Os dois objetos criados são armazenados no array.
  14. 14.  Dica: A forma mais comum é utilizar os colchetes depois do tipo do array. Clock[] clocks = {new Clock(1100), new Clock(2250)};
  15. 15.  Um array de objetos, na verdade, não armazena objetos. Apenas armazena uma referência a ele.  A referência a objetos sem atribuição sempre sera nula implicitamente.  Não é permitido valor negativo para o índice.  Erros de array causam exceções de tempo de excução, e não erros de compilador.
  16. 16. class ArrayInteger{ public static void main(String[] args){ Integer[] meuArray = new Integer[4]; System.out.println(meuArray[0]); } }  RESULTADO: null
  17. 17. class ArrayInteger{ public static void main(String[] args){ Integer[] meuArray = new Integer[4]; meuArray[1] = 1; System.out.println(meuArray[0]+2); } }  RESULTADO: Lança uma exceção NullPointerException por tentar manipular um valor null.
  18. 18.  Em um array anônimo não pode especificar o tamanho, pois o mesmo está entre vírgula. ◦ Int[] meuArray = new int[]{4,7,2}  A vantagem é que pode ser usado para um array just-in-time.
  19. 19. class foo{ void meuArray(int[] arrayQualquer){ } } public static void main(String[] args){ foo f = new foo(); f.meuArray(new int[] {7,8,6}); //chamo o método e passo por parâmetro os valores do meu array anônimo }
  20. 20.  Utiliza um número chamado de índice Índice numérico - Atribuído a cada elemento do array - Permite o acesso individual a seus elementos - Iniciado com zero e progride sequencialmente até o fim do array - Índices dentro de um array vão de 0 até (tamanhoDoArray - 1) 
  21. 21.  int meuArray[] = new int[100];  meuArray[0] = 10;  System.out.println(meuArray[99]);
  22. 22. public class ArraySimples{ public static void main( String[] args ){ int[] meuArray = new int[100]; for( int i=0; i<100; i++ ){ System.out.println( meuArray[i] ); } } }
  23. 23.   O valor armazenado de cada elemento do array será inicializado com zero para arrays com o tipo de dado numérico Para referenciar os elementos em arrays de objetos, como as Strings, estes NÃO serão inicializados com brancos ou strings vazias "". Em vez disso, deve-se preencher explicitamente cada elemento deste array
  24. 24.     É um método estático nativo do Java, mais especificamente da classe System. Esse método copia os dados e cria dois arrays independentes após a conclusão. Requer cinco parâmetros. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
  25. 25. String[] clockTypes = {"Wrist Watch","Desk Clock","Wall Clock"}; String[] newClockTypes = new String[2]; System.arraycopy(clockTypes, 1, newClockTypes, 0, 2); for(String s : clockTypes){ System.out.println(s); } System.out.println("------"); //só para separar na impressão for(String s : newClockTypes){ System.out.println(s); }
  26. 26.  Resultado: Wrist Watch Desk Clock Wall Clock -----Desk Clock Wall Clock
  27. 27.   A classe Arrays no java fornece recursos para: -ordenação; -busca; -comparação. Sem falar nos métodos estáticos que ela oferece: -asList; -binarySearch; -copyOf; -copyOfRange; -equals; -fill; -sort;
  28. 28.    Utilizar o atributo length para se obter o número de elementos de um array O atributo length de um array retorna seu tamanho nomeArray.length
  29. 29. public class ArraySimples { public static void main( String[] args ){ int[] meuArray = new int[100]; for( int i=0; i < meuArray.length; i++ ){ System.out.println( meuArray[i] ); } } }
  30. 30.    São implementados como arrays dentro de arrays Possuem mais de um índice São criados adicionando-se mais um conjunto de colchetes após o nome do array declarado // array inteiro de 512 x 128 elementos int[][] twoD = new int[512][128]; // array de caracteres de 8 x 16 x 24 char[][][] threeD = new char[8][16][24]; // array de String de 4 linhas x 2 colunas String[][] dogs = { { "terry", "brown" }, { "Kristin", "white" }, { "toby", "gray"}, { "fido", "black"} };
  31. 31.     O Java não especifica um limite de número de dimensões que um array deve ter. Entretanto, na especificação da JVM existe um limite de 256 dimensões. String[][] square = {{"1","2"},{"3","4"}}; String[][] square = new String[2][2]; int[][][] cube = new int[3][3][2];
  32. 32.   Acessar um elemento em um array multidimensional é idêntico a acessar elementos de um array unidimensional Acessando o primeiro elemento na primeira linha do array: nomeArray[0][0];
  33. 33.             É uma representação O.O. do array discutido anteriormente. Faz parte do pacote java.util ; Implementa a interface Collection ; É flexível; Dinâmico, cresce automaticamente; Possui métodos próprios que facilitam sua manipulação e iteração; Acesso realizado em tempo constante; Inclusão/Exclusão realizado em tempo linear; Pode ser tratado com índices, loops ou iterators; Pode ser usado para criar um objeto que pode armazenar outros objetos, incluindo tipos enum. Armazena arrays. Não armazena tipos primitivos, caso seja passado um primitivo para ser armazenado o autoboxing entra em ação e o substitui para o primeiro objeto wrapper.
  34. 34. ArrayList list1 = new ArrayList(); ArrayList list2 = new ArrayList(20);  Quando a capacidade “estourar” o tamanho do ArrayList é automaticamente incrementado; Declaração com Generics (Generics não são cobrados no exame): ArrayList<String> list3 = new ArrayList<String>(); 
  35. 35. Integer integer1 = new Integer(1300); Integer integer2 = new Integer(2000); ArrayList<Integer> basicArrayList = new ArrayList<Integer>(); basicArrayList.add(integer1); basicArrayList.add(integer2); System.out.println(basicArrayList.get(0)+" - "+basicArrayList.get(1)); Resultado: 1300 – 2000 System.out.println("Size: " + basicArrayList.size()); Resultado: Size: 2
  36. 36. Integer interger3 = new Integer(900); basicArrayList.add(1,interger3); System.out.println(basicArrayList.get(0) + " - " + basicArrayList.get(1) + " - " + basicArrayList.get(2)); Resultado: 1300 - 900 - 2000 System.out.println("Size: " + basicArrayList.size()); Resultado: Size: 3  Length não funciona em ArrayList.
  37. 37. ArrayList<String> creatures = new ArrayList<String>(); creatures.add("Mutant"); creatures.add("Godzilla"); creatures.add("Alien"); creatures.add("Zombie"); creatures.add("Zombie"); System.out.println(creatures); Resultado: [Mutant, Godzilla, Alien , Zombie , Zombie] ArrayList<String> cuddles = new ArrayList<String>(); cuddles.add("Tribbles"); cuddles.add("Ewoks"); creatures.addAll(2, cuddles); System.out.println(creatures); Resultado: [Mutant, Godzilla, Tribbles, Ewoks, Alien, Zombie, Zombie]
  38. 38. System.out.println(creatures.indexOf("Tribbles")); Resultado: 2 System.out.println(creatures.indexOf("King Kong")); Resultado: -1 System.out.println(creatures.lastIndexOf("Zombie")); Resultado: 6
  39. 39.  Retorna um array de objetos da lista; String[] complete = new String[0]; complete = creatures.toArray(complete); for(String item : complete) { System.out.print(item + " "); }  Resultado: Mutant Godzilla Tribbles Ewoks Alien Zombie Zombie
  40. 40. O método iterator retorna um objeto Iterator: Iterator<String> iterator = creatures.iterator(); while(iterator.hasNext()) { System.out.print(iterator.next() + " "); }  O método listIterator retorna um objeo ListIterator: ListIterator<String> listIterator = creatures.listIterator(); while(listIterator.hasNext()) { System.out.print(listIterator.next() + " "); }   Resultado para ambos: Mutant Godzilla Tribbles Ewoks Alien Zombie Zombie
  41. 41.  Mutant Godzilla Tribbles Ewoks Alien Zombie Zombie Collections.sort(creatures); System.out.println(creatures);  Resultado: Alien, Ewoks, Godzilla, Mutant, Tribbles, Zombie, Zombie]
  42. 42.  Mutant Godzilla Tribbles Ewoks Alien Zombie System.out.println(creatures.contains(“Wolverine”));  Resultado: false
  43. 43. System.out.println(creatures); creatures.remove(0); System.out.println(creatures); creatures.remove("Alien"); System.out.println(creatures); creatures.removeAll(cuddles); System.out.println(creatures); creatures.clear(); System.out.println(creatures);
  44. 44.  Resultado:  [Mutant, Godzilla, Tribbles, Ewoks, Alien, Zombie, Zombie]  [Godzilla, Tribbles, Ewoks, Alien, Zombie, Zombie]  [Godzilla, Tribbles, Ewoks, Zombie, Zombie]  [Godzilla, Zombie, Zombie]  []
  45. 45.       - Não confundir [] com () na declaração de vetores - Cuidado! Vetor pode ter índice acessado apenas com variáveis promovíveis para int ou constantes - Atribuir valores entre chaves em vetores é permitido apenas na inicialização int vetor[] = new int[3]; vetor = {1, 2, 3}; // java.lang.RuntimeException vetor = new int[] {1, 2, 3, 4, 5}; //isso poderia, redefinir o vetor
  46. 46.   Ao igualar vetores, sempre verificar se as dimensões se completam: int v1[][] = new int [2][3]; int v2 [][][][] = new int[2][2][2][2]; v2[0][1][1] = v1; // java.lang.RuntimeException!! v2[0][1][1] = v1[0]; //OK! v2[0][1] = v1; //OK! Cuidado! String [][]x = new String [2][]; System.out.println( x[1][0] ); //NullPointerException
  47. 47.  Cuidado! Sempre que chamar o vetor args [] do método main com seus índices explícitos, ver se o número de argumentos digitados não gera um ArrayIndexOutOfBoundsException: String s1 = args[0]; String s2 = args[1]; String s3 = args[2]; //Se tivesse só 2 argumentos, aqui geraria ERRO DE EXECUÇÃO  Cuidado! String x[][] = new String[2][2]; String y[] = new String[15]; x[0] = y; System.out.println(x[0].length); //IMPRIME 15

×