O documento discute programação com arrays em Java, abordando tópicos como: 1) declarar e criar arrays unidimensionais e multidimensionais; 2) acessar elementos de arrays; e 3) determinar o número de elementos em um array.

1. Grupo de Estudos Tecnológicos – NTI UVA
Programando com Arrays
Felizardo Charles

2. 
Declarar e criar arrays

3. 

Declarar e criar arrays
Acessar elementos de um array

4. 


Declarar e criar arrays
Acessar elementos de um array
Determinar o número de elementos em um
array

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. 




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. 
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. 

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

10. 
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[];

11. 

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];

12. 
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)

13. 
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

14. 


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.

15. 
Dica: A forma mais comum é utilizar os colchetes
depois do tipo do array.
Clock[] clocks = {new Clock(1100), new Clock(2250)};

16. 
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.

17. class ArrayInteger{
public static void main(String[] args){
Integer[] meuArray = new Integer[4];
System.out.println(meuArray[0]);
}
}

RESULTADO: null

18. 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.

19. 
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.

20. 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
}

21. 
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)


22. 
int meuArray[] = new int[100];

meuArray[0] = 10;

System.out.println(meuArray[99]);

23. 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] );
}
}
}

24. 

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

25. 



É 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)

26. 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);
}

27. 
Resultado:
Wrist Watch
Desk Clock
Wall Clock
-----Desk Clock
Wall Clock

28. 

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;

29. 


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

30. 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] );
}
}
}

31. 


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"}
};

32. 



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];

33. 

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];

34. 











É 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.

35. 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>();


36. 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

37. 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.

38. 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]

39. 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

40. 
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

41. 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

42. 
Mutant Godzilla Tribbles Ewoks Alien Zombie Zombie
Collections.sort(creatures);
System.out.println(creatures);

Resultado: Alien, Ewoks, Godzilla, Mutant, Tribbles, Zombie, Zombie]

43. 
Mutant Godzilla Tribbles Ewoks Alien Zombie
System.out.println(creatures.contains(“Wolverine”));

Resultado: false

44. 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);

45. 
Resultado:

[Mutant, Godzilla, Tribbles, Ewoks, Alien, Zombie, Zombie]

[Godzilla, Tribbles, Ewoks, Alien, Zombie, Zombie]

[Godzilla, Tribbles, Ewoks, Zombie, Zombie]

[Godzilla, Zombie, Zombie]

[]

46. 





- 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

47. 

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

48. 
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