Apêndice A Classe Vector A classe Vector permite a representação de um vetor de dados de maneira similar à de um array, visto na disciplina Programação Orientada a Objetos I, mas com maior flexibilidade. A tabela abaixo mostra as diferenças entre arrays e a classe Vector. Array Vector O tamanho precisa ser definido quando o array é criado e não pode ser modificado posteriormente.

O tamanho inicial é definido quando a instância é criada e pode ser modificado depois, manual ou automaticamente. Quando o tamanho de uma instância da classe Vector tem sua capacidade excedida, mais espaço para elementos é criado automaticamente, e o valor que representa a capacidade é aumentado.

Todos os elementos tem o mesmo tipo. Cada elemento pode ser de um tipo (classe) diferente. Pode ser composto de dados nativos ou instâncias da mesma classe.

Somente pode conter instâncias de qualquer classe.

Procura feita somente pelo índice. Procura feita tanto pelo índice quanto pelo conteúdo. Alguns construtores e métodos importantes e úteis da classe Vector são: * Vector(): construtor que constrói uma instância da classe sem elementos mas com capacidade inicial para 10 elementos. * Vector(int capacidade): construtor que constrói uma instância da classe sem elementos mas com capacidade inicial para o número de elementos especificados por capacidade. * addElement(Object elem): adiciona qualquer instância de qualquer classe ao final do Vector, aumentando seu tamanho em 1. * insertElementAt(Object elem,int índice): adiciona qualquer instância de qualquer classe na posição índice do Vector, aumentando seu tamanho em 1. O valor índice deve estar entre 0 e o tamanho do Vector. * setElementAt(Object elem,int índice): coloca o objeto elem na posição índice do Vector, apagando o objeto que estiver lá anteriormente. * removeElement(Object elem): remove a primeira ocorência do objeto elem do Vector, retornando o booleano true caso tenha sido possível a remoção. * removeElementAt(int índice): remove o objeto na posição índice do Vector. * contains(Object elem): retorna o valor booleano true se o Vector contém uma instância do objeto ou false se não. * elementAt(int índice): recupera o objeto na posição índice do Vector. * firstElement(): recupera o objeto na primeira posição do Vector. * lastElement(): recupera o objeto na última posição do Vector. * indexOf(Object elem): retorna o índice da primeira ocorrência do objeto elem no Vector ou -1 se o objeto não existir no Vector. * indexOf(Object elem,int índice): retorna o índice da primeira ocorrência do objeto elem no Vector a partir da posição índice ou -1 se o objeto não existir no Vector. * lastIndexOf(Object elem): retorna o índice da última ocorrência do objeto elem no Vector ou -1 se o objeto não existir no Vector. * lastIndexOf(Object elem,int índice): retorna o índice da última ocorrência do objeto elem no Vector a partir da posição índice ou -1 se o objeto não existir no Vector. * size(): retorna o tamanho do Vector (o número de objetos que ele contém) como um valor inteiro. Um programa em Java que demonstra alguns dos métodos usados em instâncias da classe Vector é mostrado abaixo: Exemplo 1. Programa que demonstra a classe Vector 1 // Sempre devemos incluir a linha abaixo quando usarmos a classe Vector 2 import java.util.*; 3 4 class demoVector // a nossa classe 5 { 6 public static void main(String args[]) 7 { 8 // Criamos uma instância da classe Vector 9 Vector meuvec = new Vector(); 10 // Vamos adicionar umas Strings 11 meuvec.addElement("Um");

12 meuvec.addElement("Dois"); 13 meuvec.addElement("Um valor que não tem nada a ver"); 14 meuvec.addElement("Outro valor que não tem nada a ver"); 15 meuvec.addElement("Três"); 16 // qual é o tamanho do nosso vetor ? 17 System.out.println("O tamanho é "+meuvec.size()); // 5 18 // o vetor contém a String "Três" ? 19 System.out.println(meuvec.contains("Três")); 20 // e a String "três" (com 't' minúsculo) ? 21 System.out.println(meuvec.contains("três")); 22 // vamos inserir alguns elementos no início do vetor 23 meuvec.insertElementAt("Quatro",0); 24 meuvec.insertElementAt("Cinco",0); 25 // e modificar o quarto deles - veja que o índice é 3 26 meuvec.setElementAt("Zwei",3); 27 // vamos remover um valor que não tem nada a ver 28 boolean conseguiu; 29 conseguiu = meuvec.removeElement("Um valor que não tem nada a ver"); 30 if (conseguiu) System.out.println("Remoção feita com sucesso."); 31 // e se tentarmos remover um elemento que não existe ? 32 conseguiu = meuvec.removeElement("Este não existe no Vector"); 33 if (conseguiu) System.out.println("Remoção feita com sucesso."); 34 // podemos remover um elemento em uma posição qualquer... 35 meuvec.removeElementAt(4); 36 // qual é a posição do elemento "Um" ? 37 System.out.println(meuvec.indexOf("Um")); 38 // qual é a posição do elemento "Cem" ? 39 System.out.println(meuvec.indexOf("Cem")); 40 // vamos imprimir todos os elementos do Vector agora. Precisamos de uma String 41 // temporária para armazenar o elemento que queremos imprimir. 42 String elemento; 43 for(int elem=0;elem<meuvec.size();elem++) // pesquisa todos os elementos do Vector 44 { 45 elemento = (String)meuvec.elementAt(elem); // obtém e converte o elemento 46 System.out.println(elemento); // imprime a String 47 } 48 } // fim do método main 49 } // fim da classe demoVector O programa acima somente inclui instâncias da classe String no Vector. Como os valores retornados pelos métodos elementAt, firstElement e lastElement somente retornam instâncias da classe Object , devemos fazer a conversão da classe Object para a classe que esperamos que esteja no Vector (veja a linha 45 do programa acima). Determinando a que classe uma instância pertence Podemos incluir nos Vectors qualquer instância de qualquer classe, uma vez que todas as classes de Java descendem da classe Object , como mostrado no programa abaixo: Exemplo 2. Outro programa que demonstra a classe Vector 1 // Sempre devemos incluir a linha abaixo quando usarmos a classe Vector 2 import java.util.*; 3 4 class demoVector // demonstra como podemos colocar diversos objetos no Vector 5 { 6 public static void main(String args[]) 7 { 8 // Criamos uma instância da classe Vector 9 Vector umvec = new Vector(); 10 // Adicionamos várias instâncias de diversas Classes. 11 // Somente podemos adicionar instâncias de classes, não podemos 12 // adicionar tipos nativos como int, boolean, etc. 13 umvec.addElement("Uma String"); // String 14 Integer I = new Integer("-123"); 15 umvec.addElement(I); // Integer

16 Boolean B = new Boolean(false); 17 umvec.addElement(B); // Boolean 18 Double D = new Double(6.02E23); 19 umvec.addElement(D); // Double 20 Character C = new Character('Ü'); 21 umvec.addElement(C); // Character 22 umvec.addElement(new Integer(0)); // Outro Integer 23 umvec.addElement(new Float(0)); // Um Float 24 umvec.addElement(new Long(0)); // Um Long 25 // Aqui temos um problema: o que acontece quanto não soubermos com 26 // certeza a classe dos objetos sendo retirados do Vector ? 27 // Se tentarmos String erro = (String)umvec.elementAt(2); 28 // teremos uma exceção chamada java.lang.ClassCastException 29 // porque não é possível converter de Boolean para String. 30 } // fim do método main 31 } // fim da classe demoVector É possível incluir, excluir e acessar instâncias de qualquer classe em Vectors, como mostrado acima, mas a extração de elementos dos Vectors com os métodos elementAt, firstElement e lastElement deve ser feito de maneira seletiva em muitos casos, especialmente quando tratamento diferenciado deve ser dado à cada classe incluida no Vector. Este tratamento diferenciado resume-se a criar instâncias de classes adequadas para cada elemento do Vector. Para efetuar um tratamento diferenciado das instâncias podemos usar instâncias da classe Object (que é a superclasse de todas as classes de Java) para recuperar elementos de Vectors com os métodos elementAt, firstElement e lastElement. Depois de recuperados os elementos, podemos usar a palavra-chave instanceof para verificar a que classe o objeto recuperado pertence. Isto é exemplificado no programa abaixo: Exemplo 3. Programa que demonstra a classe Vector com instância da classe Object e uso de instanceof 1 // Sempre devemos incluir a linha abaixo quando usarmos a classe Vector 2 import java.util.*; 3 4 // Esta classe demonstra como podemos colocar diversos objetos no Vector 5 // e depois retirá-los seguramente usando a palavra-chave instanceof 6 // e uma instância da classe Object. 7 class demoVector 8 { 9 public static void main(String args[]) 10 { 11 // Criamos uma instância da classe Vector 12 Vector umvec = new Vector(); 13 // Adicionamos várias instâncias de diversas Classes. 14 umvec.addElement("Uma String"); // String 15 Integer I1 = new Integer("999"); 16 umvec.addElement(I1); // Integer 17 Boolean B1 = new Boolean(false); 18 umvec.addElement(B1); // Boolean 19 Double D1 = new Double(3.1416); 20 umvec.addElement(D1); // Double 21 Integer I2 = new Integer("-100"); 22 umvec.addElement(I2); // Outro integer 23 Double D2 = new Double(2.78); 24 umvec.addElement(D2); // Outro Double 25 umvec.addElement("Outra String"); // Outra String 26 Boolean B2 = new Boolean(true); 27 umvec.addElement(B2); // Boolean 28 // Vamos recuperar os elementos e efetuar ações especiais para cada 29 // tipo (classe). 30 for(int contador=0;contador<umvec.size();contador++) 31 { 32 Object objeto = umvec.elementAt(contador); // elemento na posição "contador" 33 if (objeto instanceof String) // se for uma String 34 System.out.println("Uma String:"+(String)objeto); // muda para String 35 else if (objeto instanceof Boolean) // se for um Boolean 36 System.out.println("Um Boolean:"+(Boolean)objeto); // muda para Boolean

37 else if (objeto instanceof Integer) // se for um Integer 38 System.out.println("Um Integer:"+(Integer)objeto);// muda para Integer 39 else if (objeto instanceof Double) // se for um Double 40 System.out.println("Um Double:"+(Double)objeto);// muda para Double 41 } // fim do for para todos os elementos do Vector 42 } // fim do método main 43 } // fim da classe demoVector Com este exemplo vimos que é possível recuperar praticamente qualquer tipo (classe) de elemento colocado no Vector. Procedimentos e funções em Programas em Java Como o processo de checar a que classe pertence o objeto recuperado dos Vectors com os métodos elementAt, firstElement e lastElement (e considerando que os programas em Java podem ficar mais complexos daqui em diante), devemos considerar a quebra ou divisão dos programas em Java em procedimentos e/ou funções. Considerando que cada main (ponto de entrada dos programas em Java) é um método da classe que representa o programa, outros métodos poderiam ser escritos na classe e chamados de dentro do método main. A única restrição é que um método main só pode chamar métodos que sejam declarados com a palavra-chave static . Métodos que não retornam valores são comparáveis a procedimentos em Pascal, e declarados como retornando void. Métodos que retornam valores são comparáveis a funções em Pascal, e declarados como retornando um tipo não-void de dado. Exemplo 4. Programa que demonstra chamada de métodos a partir de um método main. 1 // Esta classe demonstra o uso de subrotinas em programas em Java 2 class demoSub 3 { 4 public static void main(String args[]) 5 { 6 for(int contador=0;contador<10;contador++) 7 { 8 procedimento(); // chama o método procedimento na classe demoSub 9 // chama o método incrementa na classe demoSub e imprime o seu resultado 10 System.out.println(incrementa(contador)); 11 } 12 } // fim do método main 13 static void procedimento() // note que o método é declarado com static 14 { 15 System.out.println("Estou no procedimento !"); 16 } // fim do método procedimento 17 static int incrementa(int i) // note que o método é declarado com static 18 { 19 return i+1; // retorna o argumento mais um 20 } // fim do método incrementa 21 } Usando subrotinas podemos fazer programas mais flexíveis em Java, como o mostrado abaixo: Exemplo 5. Programa que demonstra chamada de métodos a partir de um método main (passando uma instância da classe Vector para um método). 1 // Sempre devemos incluir a linha abaixo quando usarmos a classe Vector 2 import java.util.*; 3 4 // Esta classe demonstra o uso da classe Vector com subrotinas 5 // em um programa para aumentar a flexibilidade. 6 class demoVector 7 { 8 public static void main(String args[]) 9 { 10 // Criamos uma instância da classe Vector

11 Vector soma = new Vector(); 12 // Adicionamos várias instâncias de Double 13 Double D1 = new Double("100"); // podemos criar a partir de Strings 14 Double D2 = new Double(-100); // e a partir de valores diretamente 15 Double D3 = new Double(25000); 16 soma.addElement(D1); 17 soma.addElement(D2); 18 soma.addElement(D3); 19 soma.addElement(new Double(-12000)); // podemos adicionar diretamente também 20 // qual é a soma até agora ? 21 System.out.println("A soma até agora é "+somaVector(soma)); 22 // adicionamos outro Double... 23 soma.addElement(new Double(-22000)); 24 // qual é a soma até agora ? 25 System.out.println("A soma até agora é "+somaVector(soma)); 26 // adicionamos outro Double... 27 soma.addElement(new Double(9000)); 28 // qual é a soma até agora ? 29 System.out.println("A soma até agora é "+somaVector(soma)); 30 } // fim do método main 31 32 // Este método pega todos os elementos do Vector, converte-os para Double 33 // e soma os valores, retornando a soma 34 static double somaVector(Vector vetor) 35 { 36 double total = 0; 37 for(int contador=0;contador<vetor.size();contador++) 38 { 39 // pega o elemento na posição "contador" e converte-o para a classe Double 40 Double temp = (Double)vetor.elementAt(contador); 41 total = total+temp.doubleValue(); 42 } // fim do for para todos os elementos do Vector 43 return total; // retorna o valor calculado no método 44 } // fim do método somaVector 45 } // fim da classe demoVector 46 No programa acima, podemos executar subrotinas com a instância de Vector que fazem o programa ficar menor e mais flexível. Exercícios Exercício 1. Compare a classe Vector com a estrutura de arrays de Java. Cite ao menos três diferenças básicas entre a classe Vector e arrays. Teórico Exercício 2. Considere a listagem 12. Quais são os elementos do Vector meuvec e em que ordem estão ao final do programa ? Teórico Exercício 3. Escreva um programa em Java que preencha um Vector com instâncias de Strings e localize a String mais longa (com mais caracteres) no Vector. Tente usar uma subrotina para isto. Fácil Exercício 4. Na listagem 16, no método somaVector, assumimos que todos os elementos do Vector são instâncias de Double, o que depende de como o Vector é criado. Como poderíamos evitar a ocorrência de uma exceção java.lang.ClassCastException, que ocorreria se houvesse uma instância de uma classe diferente (por exemplo, String) no Vector ? Intermediário Exercício 5. Considerando a classe Aluno, crie um Vector de instâncias da classe Aluno (simulando uma turma). Procure neste vetor a idade do aluno mais velho e a imprima. Use uma subrotina para isto. Intermediário Exercício 6. Considerando a classe Aluno, crie um Vector de instâncias da classe Aluno (simulando uma turma). Usando este vetor, calcule a média da idade da turma. Use uma subrotina para isto. Intermediário

Exercício 7. Uma fila é uma estrutura de dados na qual os primeiros dados a "entrar" serão os primeiros a "sair", conforme a figura abaixo. Crie um programa em Java que implemente uma fila, usando uma subrotina para incluir e recuperar dados da fila. Intermediário

Exercício 8. Uma pilha é uma estrutura de dados na qual os primeiros dados a "entrar" serão os últimos a "sair", conforme a figura abaixo. Crie um programa em Java que implemente uma pilha, usando uma subrotina para incluir e recuperar dados da pilha. Intermediário

Exercício 9. Escreva um programa em Java que leia um arquivo de texto, linha por linha, guardando as linhas em uma instância da classe Vector, e escreva estas linhas, na ordem inversa em que foram lidas, em um arquivo de saída. Os nomes dos arquivos podem ser passados via linha de comando ou lidos do teclado. Difícil Exercício 10. Se podemos incluir instâncias de qualquer classe em um Vector, então podemos incluir instâncias de Vectors em Vectors, criando estruturas de dados chamadas árvores. Um organograma é um exemplo de aplicação de árvores, como mostrado abaixo:

O Tronco da árvore é de onde todos os outros elementos da árvore saem. Se um elemento não tem mais elementos ligados à ele, é chamado folha, caso contrário é chamado galho. Escreva um programa em Java que crie e imprima uma árvore como a mostrada acima. Dica: se a instância do objeto no Vector é outro Vector, este objeto é um galho, e você precisará percorrer os elementos deste. Caso a instância sendo pesquisada não seja um Vector, basta imprimir porque é uma folha. Um método recursivo pode ser necessário para a solução deste problema. Desafio!