doc - Paulo Roberto Gomes Luzzardi
Propaganda
Algoritmos e Programação por Prof. Dr. Paulo Roberto Gomes Luzzardi facebook: Paulo Roberto Gomes Luzzardi WhatsApp: 91648037 e-mail: [email protected] e [email protected] e-mail (Senac): [email protected] DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page) OS X Server (Apple): http://pluzzardi.no-ip.info:8080 (Home Page) Versão 2.12 26-10-2015 Bibliografia recomendada DEITEL, H. M. and DEITEL, P. J. Java: como programar, 8. ed.: São Paulo: Pearson, 2010 (ISBN 85-3630123-6). Pelotas, segunda-feira, 26 de outubro de 2015 (10:37:21 am) Sumário 1. Projeto de Classes ........................................................................................................................................... 6 1.1 Escrevendo uma classe em Java (Conceitos básicos) ............................................................................... 6 1.2 Tipos de Atributos .................................................................................................................................... 6 1.3 Sobrecarga de Métodos .......................................................................................................................... 21 1.4 Referência this ........................................................................................................................................ 22 1.5 Lista de exercícios: Classes .................................................................................................................... 25 2. Interface e Polimorfismo .............................................................................................................................. 38 2.1 Interface .................................................................................................................................................. 38 2.2 Polimorfismo .......................................................................................................................................... 41 2.3 Lista de Exercícios: Interface e Polimorfismo ........................................................................................ 43 3. Herança em Java ........................................................................................................................................... 45 3.1 Herança simples...................................................................................................................................... 45 3.2 Controle de acesso na definição de uma classe derivada ........................................................................ 46 3.3 Tipos de acessos (especificadores de acesso) ......................................................................................... 48 3.4 Lista de exercícios: Herança ................................................................................................................... 50 4. Métodos de entrada e saída de dados ........................................................................................................... 55 4.1 Entrada de dados via teclado .................................................................................................................. 55 4.2 Saída de dados via tela ........................................................................................................................... 58 4.3 Saída formatada (System.out.printf) ....................................................................................................... 59 4.4 Lista de Exercícios: Métodos de Entrada e Saída ................................................................................... 61 5. Interfaces e Containers (Classes existentes em Java) ................................................................................... 62 5.1 Coleções (Collection FrameWork) ......................................................................................................... 62 5.2 Interfaces ................................................................................................................................................ 62 5.3 Vector (Vetor) (Classe Obsoleta) ........................................................................................................... 63 5.4 LinkedList (Lista Encadeada Simples) .................................................................................................... 67 5.5 Arrays (array)......................................................................................................................................... 72 5.6 ArrayList (lista de array) ........................................................................................................................ 77 5.6.1 Lista de exercícios: Vector, ArrayList e LinkedList ............................................................................. 79 5.7 ArrayList bidimensional ......................................................................................................................... 85 5.8 Strings (Cadeia de Caracteres) ............................................................................................................... 90 5.8.1 Métodos para manipular Strings .......................................................................................................... 92 5.8.2 Lista de exercícios: Strings .................................................................................................................. 95 5.9 Classe Object .......................................................................................................................................... 97 5.10 Classe Iterator ...................................................................................................................................... 99 5.11 Classe LinkedHashSet ........................................................................................................................ 100 5.12 Classe Genérica em Java .................................................................................................................... 101 5.13 Fila Prioritária (PriorityQueue) .......................................................................................................... 103 6. Listas Lineares: Pilhas, Filas e Deques ....................................................................................................... 107 6.1 Implementação de uma Pilha (Stack).................................................................................................... 107 6.2 Implementação de uma Fila (Queue) .................................................................................................... 113 6.3 Implementação de um Deque (ArrayDeque) ........................................................................................ 117 6.4 Lista de Exercícios: Listas Lineares (Pilhas, Filas e Deques) ............................................................... 123 7. Mapas (Maps) ............................................................................................................................................. 128 7.1 Conceitos básicos sobre Mapas ............................................................................................................ 128 7.2 Lista de Exercícios: Mapas ................................................................................................................... 132 8. Processamento de fluxos de dados, caracteres e objetos (Arquivos) .......................................................... 134 8.1 Métodos para manipular arquivos em Java ........................................................................................... 136 8.2 Abertura de um arquivo texto ............................................................................................................... 138 8.3 Listar um diretório ................................................................................................................................ 139 8.4 Manipulação de um arquivo de palavras .............................................................................................. 140 8.5 Arquivo Texto ...................................................................................................................................... 143 8.6 Lista de exercícios: Arquivos (Files) .................................................................................................... 152 8.7 Acesso randômico em arquivos texto ................................................................................................... 155 8.8 Arquivo binário de objetos em Java ..................................................................................................... 156 8.9 Leitura e gravação de objetos (registro) em Arquivos .......................................................................... 157 8.9.1 Gravação de objetos em um arquivo binário de objetos .................................................................... 158 8.9.2 Leitura objetos em um arquivo binário de objetos ............................................................................. 161 9. Noções de desenvolvimento de aplicações em camadas (MVC) ................................................................ 164 9.1 Conceitos .............................................................................................................................................. 164 9.2 Primeiro exemplo da utilização do MVC (ProgMVCPessoa) .............................................................. 164 9.3 Segundo exemplo da utilização do MVC (ProgMVCPessoa2) ............................................................ 168 2 10. Conceitos gerais........................................................................................................................................ 174 10.1 Como é calculado o hashcode no Java ............................................................................................... 174 11. Lista Encadeada Simples em Java ............................................................................................................ 175 11.1 Lista Encadeada de Inteiros ................................................................................................................ 175 11.2 Lista Encadeada Genérica (String, Integer ou Double) ...................................................................... 180 12. Lista Duplamente Encadeada em Java ...................................................................................................... 184 13. Classe entrada de inteiros e reais em Java sem erro na digitação ............................................................. 192 14. Alguns programas exemplos em Java ....................................................................................................... 197 14.1 Torre de Hanoi (Pilha - Stack) ............................................................................................................ 197 14.2 Analisador de Expressões usando Stack ............................................................................................. 202 14.3 Calculadora Polonesa Reversa ............................................................................................................ 205 14.4 Jogo Quebra-Cabeças ......................................................................................................................... 207 Anexos: Solução dos problemas propostos no Livro ...................................................................................... 211 Anexo 1.4 Solução da Lista: Classes .......................................................................................................... 211 1.4.1 ProgCirculo ................................................................................................................................... 211 1.4.2 ProgPeso ........................................................................................................................................ 211 1.4.3 ProgValidaCPF .............................................................................................................................. 212 1.4.4 ProgDiaSemana ............................................................................................................................. 213 1.4.5 ProgTestData ................................................................................................................................. 214 1.4.6 ProgVetorSort ................................................................................................................................ 215 1.4.7 ProgPessoa .................................................................................................................................... 218 1.4.8 ProgPessoa2 .................................................................................................................................. 219 1.4.9 ProgPessoas ................................................................................................................................... 220 1.4.10 ProgAgenda ................................................................................................................................. 221 Anexo 2.3 Solução da Lista: Interface e Polimorfismo .............................................................................. 223 2.3.1 ProgInterface_1 ............................................................................................................................. 223 2.3.2 ProgInterface_2 ............................................................................................................................. 224 2.3.2 ProgInterface_3 ............................................................................................................................. 225 Anexo 3.4 Solução da Lista: Herança ......................................................................................................... 226 3.4.1 Herança (Primeiro) ........................................................................................................................ 226 3.4.2 Herança (Segundo) ........................................................................................................................ 227 3.4.3 Herança (Terceiro) ........................................................................................................................ 229 Anexo 4.4 Solução da Lista: Entrada e Saída Bufferizada ......................................................................... 230 4.4.1 ProgBuffer_1 ................................................................................................................................. 230 4.4.2 ProgBuffer_2 ................................................................................................................................. 231 Anexo 5.6.1 Solução da Lista: Vector, ArrayList e LinkedList ................................................................... 232 5.6.1.1 ProgVector_1 ............................................................................................................................. 232 5.6.1.2 ProgVector_2 ............................................................................................................................. 232 5.6.1.3 ProgVector_3 ............................................................................................................................. 233 5.6.1.4 ProgVector_4 ............................................................................................................................. 234 5.6.1.5 ProgVector_5 ............................................................................................................................. 235 5.6.1.6 ProgVector_6 ............................................................................................................................. 235 5.6.1.7 ProgVector_7 ............................................................................................................................. 236 5.6.1.8 ProgVector_8 ............................................................................................................................. 237 5.6.1.9 ProgVector_9 ............................................................................................................................. 237 5.6.1.10 ProgVector_10 ......................................................................................................................... 238 5.6.1.11 ProgVector_11 ......................................................................................................................... 239 5.6.1.12 ProgVector_12 ......................................................................................................................... 240 5.6.1.13 ProgVector_13 ......................................................................................................................... 242 5.6.1.14 ProgVector_14 ......................................................................................................................... 244 5.6.1.15 ProgVector_15 ......................................................................................................................... 246 5.6.1.16 ProgVector_16 ......................................................................................................................... 247 Anexo 5.8.2 Solução da Lista: Strings........................................................................................................ 249 5.8.2.1 ProgString_1 ............................................................................................................................... 249 5.8.2.2 ProgString_2 ............................................................................................................................... 249 3 5.8.2.3 ProgString_3 ............................................................................................................................... 250 5.8.2.4 ProgString_4 ............................................................................................................................... 250 5.8.2.5 ProgString_5 ............................................................................................................................... 251 5.8.2.6 ProgString_6 ............................................................................................................................... 251 5.8.2.7 ProgString_7 ............................................................................................................................... 252 5.8.2.8 ProgString_8 ............................................................................................................................... 252 Anexo 6.4 Solução da Lista: Listas Lineares .............................................................................................. 253 6.4.1 ProgLista_1 ................................................................................................................................... 253 6.4.2 ProgLista_2 ................................................................................................................................... 254 6.4.3 ProgLista_3 ................................................................................................................................... 254 6.4.4 ProgLista_4 ................................................................................................................................... 255 6.4.5 ProgLista_5 ................................................................................................................................... 255 6.4.6 ProgLista_6 ................................................................................................................................... 256 6.4.7 ProgLista_7 ................................................................................................................................... 257 6.4.8 ProgLista_8 ................................................................................................................................... 257 6.4.9 ProgLista_9 ................................................................................................................................... 258 6.4.10 ProgLista_10 ............................................................................................................................... 259 6.4.11 ProgLista_11 ............................................................................................................................... 259 6.4.12 ProgLista_12 ............................................................................................................................... 260 6.4.13 ProgLista_13 ............................................................................................................................... 260 6.4.14 ProgLista_14 ............................................................................................................................... 261 6.4.15 ProgLista_15 ............................................................................................................................... 262 Anexo 7.2 Solução da Lista: Mapas ........................................................................................................... 262 7.2.1 ProgMap_1 .................................................................................................................................... 262 7.2.2 ProgMap_2 .................................................................................................................................... 263 7.2.3 ProgMap_3 .................................................................................................................................... 263 7.2.4 ProgMap_4 .................................................................................................................................... 264 7.2.5 ProgMap_5 .................................................................................................................................... 264 Anexo 8.6 Solução da Lista: Arquivos (File) ............................................................................................. 264 8.6.1 ProgFile_1 ..................................................................................................................................... 264 8.6.2 ProgFile_2 ..................................................................................................................................... 265 8.6.3 ProgFile_3 ..................................................................................................................................... 266 8.6.4 ProgFile_4 ..................................................................................................................................... 266 8.6.5 ProgFile_5 ..................................................................................................................................... 267 8.6.6 ProgFile_6 ..................................................................................................................................... 268 8.6.7 ProgFile_7 ..................................................................................................................................... 269 8.6.8 ProgFile_8 ..................................................................................................................................... 269 8.6.9 ProgFile_9 ..................................................................................................................................... 270 8.6.10 ProgFile_10 ................................................................................................................................. 271 8.6.11 ProgFile_11 ................................................................................................................................. 271 8.6.12 ProgFile_12 ................................................................................................................................. 272 Lista de Figuras Figura 1: Estrutura de dados da classe Vetor .................................................................................... 8 Figura 2: Exemplo de Herança em java .............................................................................................. 40 Figura 3: Objetos gráficos: Linha e Retângulo ................................................................................. 50 Figura 4: LinkedList - Lista Encadeada Simples ................................................................................. 65 Figura 5: Representação gráfica de uma String ................................................................................ 90 Figura 6: Representação de uma Fila e uma Pilha .......................................................................... 108 Figura 7: Representação visual de um Deque ................................................................................. 118 Figura 8: Representação gráfica de uma Tabela Hash (Hashtable) .............................................. 131 Figura 9: Exemplo de um arquivo texto ........................................................................................... 138 Figura 10: Editor hexadecimal mostrando o arquivo texto ........................................................... 139 Figura 11: Editor hexadecimal mostrando o arquivo binário ........................................................ 139 4 Figura 12: Exemplo de MVC .............................................................................................................. 172 Figura 13: Exemplo de MVC .............................................................................................................. 176 Figura 14: Lista Encadeada Simples ................................................................................................. 182 Figura 15: Alocação de elementos na Memória RAM .................................................................... 183 Figura 16: Lista Duplamente Encadeada ......................................................................................... 193 Figura 17: Jogo Torre de Hanoi ....................................................................................................... 208 Figura 18: Jogo Quebra-Cabeças ..................................................................................................... 220 Lista de Tabelas Tabela 1: Tipos de Ícones .................................................................................................................... 53 Tabela 2: Comandos de formatação .................................................................................................. 53 Tabela 3: Especificadores de largura do campo .............................................................................. 54 Tabela 4: Lista de Container ................................................................................................................ 55 Tabela 5: Tipos de dados do Java ..................................................................................................... 172 Legenda de Cores Vermelho <enter>: Entrada de dados do programa Azul: Saída do programa (Resultado do teste do Programa) Verde: Texto em destaque Marinho: Código em Java Preto: Texto normal Preto: Método em destaque Itálico: Palavra em Inglês Negrito: Texto em destaque Sublinado: Observações 5 1. Projeto de Classes A seguir são descritas algumas características da orientação a objetos em Java. 1.1 Escrevendo uma classe em Java (Conceitos básicos) O paradigma orientado à objetos possui cinco componentes básicos: objetos (possuem atributos e métodos), mensagens (chamadas aos métodos), classes (tipo de dado), instâncias (criação de objetos de uma classe específica – new – alocação de memória) e métodos (funções definidas pelo programador que manipulam os atributos). Objetos, mensagens, classes, instâncias e métodos Objetos são entidades lógicas que contém atributos (dados armazenados em variáveis) e métodos (funções) que manipulam estes dados. Um objeto pode ser definido através de um tipo de dado chamado classe (class). Resumindo: a) Atributos: São as variáveis definidas/declaradas para cada objeto. b) Métodos: São as funções definidas pelo programador que servirão para manipular os atributos. c) Mensagens: São as chamadas dos métodos. d) Classe: É um tipo de dado definido por class. Uma classe não é um objeto, é sim uma descrição do objeto. e) Instância: Os objetos são instâncias de uma classe, ou seja, é criado um objeto pertencente a uma classe específica. O objeto pode responder chamadas dos métodos e armazenar informações nos atributos. Resumidamente, objetos são instâncias de classes que respondem as mensagens através dos métodos escritos pelo programador. Uma linguagem de programação orientada à objetos pode suportar ou implementar seis propriedades: abstração, encapsulamento, polimorfismo, herança, associação (quando uma classe possui atributos do tipo de outra classe - agregação e composição) e classes abstratas e concretas. 1.2 Tipos de Atributos São variáveis definidas e declaradas nas classes. Existem três tipos de atributos: Atributo do objeto: É individual para cada objeto, ou seja, cada objeto pode possuir um valor diferente; 6 Atributo da classe: É estático (static), ou seja, coletivo, igual para todos os objetos da classe; Atributo constante: Idêntico aos atributos da classe, somente não podem ser alterados por serem constantes (final). // --------------------------------------------------------------------------------------------------------------------------------------- Classe: Atributos.java package progatributos; public class Atributos { private int x; private static int y; private final int z = 3; // atributo do objeto (cada objeto tem o seu) // atributo da classe (todos tem igual, mas pode ser alterado) // atributo constante (todos os objetos tem o mesmo valor, não pode ser alterado Atributos(int x) { this.x = x; } public void setAtributoY(int y) { Atributos.y = y; // this.y = y; } public void exibeAtributos() { System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("z = " + z); System.out.println(); } // ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgAtributos.java package progatributos; public class ProgAtributos { public static void main(String[] args) { Atributos atrib1 = new Atributos(1); Atributos atrib2 = new Atributos(3); Atributos atrib3 = new Atributos(5); atrib1.setAtributoY(7); // altera atributo Y e esta mudança vale para todos os objetos atrib1.exibeAtributos(); atrib2.exibeAtributos(); atrib3.exibeAtributos(); } } Resultado do Programa: x=1 y=7 z=3 x=3 y=7 z=3 x=5 y=7 z=3 Considere a seguinte estrutura de dados da Figura 1, onde há um vetor de “max” elementos e um atributo “n” que controla a quantidade de elementos presentes no vetor num dado momento. Esta estrutura é utilizada na classe Vetor definida a seguir. 7 Figura 1: Estrutura de dados da classe Vetor Programa Exemplo: Classe “Vetor”, que possui a estrutura de dados exibida na Figura 1, e que possui os seguintes atributos: private int n; private final int[] vetor; private final int max; // número de elementos no vetor // vetor que armazena os elementos // máximo número de elementos no vetor // -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java package progvetor; public class Vetor { // ------------------------------------- atributos da classe private int n; private final int[] vetor; private final int max; // ----------------------------------------- construtor Vetor(int numeroElementos) { max = numeroElementos; vetor = new int[max]; // alocação de max número de elementos n = 0; } // ----------------------------------------- add public void add(int valor) { if (n < max) { vetor[n] = valor; n++; } else { System.out.println("Erro: Excedeu Limite do Vetor"); } } // --------------------------------------- exibe public void exibe() { System.out.print("Vetor: ["); for (int i = 0; i < n; i++) { System.out.print(vetor[i] + ", "); } System.out.println("\b\b]"); // apaga o último espaço em branco e a última vírgula } // ‘\b’ retrocesso ou BackSpace // ---------------------------------------------------- numeroElementosVetor public int numeroElementosVetor() { return(n); } 8 } // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor.java package progvetor; public class ProgVetor { public static void main(String[] args) { Vetor vetor = new Vetor(5); // 5 é o número de elementos no vetor estático da classe vetor.add(10); vetor.add(20); vetor.add(30); vetor.add(40); vetor.add(50); vetor.exibe(); vetor.add(60); vetor.exibe(); System.out.println("Total de Elementos: " + vetor.numeroElementosVetor()); } } Resultado do Programa: Vetor: [10, 20, 30, 40, 50] Erro: Excedeu Limite do Vetor Vetor: [10, 20, 30, 40, 50] Total de Elementos: 5 Tente implementar os seguintes métodos para a classe “Vetor”: int valor = vetor.del(); if (valor != -999) { System.out.println("Valor Excluído: " + valor); } else { System.out.println("ERRO: Vetor Vazio"); } vetor.exibe(); System.out.println("Total de Elementos: " + vetor.length()); int pri = vetor.primeiro(); System.out.println("Primeiro: " + pri); int ult = vetor.ultimo(); System.out.println("Último: " + ult); int elemento = 20; boolean flag = vetor.existe(elemento); if (flag) { System.out.println("Existe elemento: " + elemento); } else { System.out.println("Não Existe elemento 20"); } Resultado do Programa: Vetor: [10, 20, 30, 40, 50] Erro: Excedeu Limite do Vetor Vetor: [10, 20, 30, 40, 50] Total de Elementos: 5 Valor Excluído: 50 Vetor: [10, 20, 30, 40] Total de Elementos: 4 Primeiro: 10 Último: 40 Existe elemento: 20 9 Exemplo de classe (Lista) aonde os elementos são inseridos a partir da posição “zero” do vetor e há uma variável “n” que controla o número de elementos da lista. // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgLista.java package testalista; import java.util.Scanner; public class TestaLista { public static void main(String[] args) { final int SUCESSO = 0; final int CHEIA = -1; final int VAZIA = -2; final int EXCEDEU = -3; final int POSICAO = - 4; final int VALOR = -5; Scanner input = new Scanner(System.in); Lista lista = new Lista(7); String s; char op; do { do { int[] valores = lista.exibeLista(); int n = lista.numeroElementosLista(); exibeLista(n, valores); do { System.out.print("[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: "); s = input.nextLine(); } while (s.isEmpty()); op = s.charAt(0); if (op == 'Q' || op == 'q') { System.exit(1); } } while (!"IiRrAaPpOoSsVv".contains(s)); //} while (!"IRAPOSV".equalsIgnoreCase(s)); switch (op) { case 'I': case 'i': System.out.print("Valor: "); s = input.nextLine(); Integer valor = Integer.parseInt(s); int erro = lista.insereLista(valor); ImprimeErro(erro); break; case 'R': case 'r': erro = lista.removeLista(); if (erro != 0) { System.out.println("Valor Removido: " + erro); } else { ImprimeErro(VAZIA); } break; case 'A': case 'a': lista.removeallLista(); break; case 'O': case 'o': System.out.print("Valor: "); s = input.nextLine(); valor = Integer.parseInt(s); int posicao = lista.procuraLista(valor); if (posicao != -5) { System.out.println("Posição: " + posicao); 10 } else { ImprimeErro(POSICAO); } break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); valor = lista.pesquisaLista(posicao); if (valor != -4) { System.out.println("Valor Pesquisado: " + valor); } else { ImprimeErro(VALOR); } break; case 'S': case 's': lista.sort(); break; case 'V': case 'v': lista.inverteLista(); break; } } while (true); } // -------------------------------------------------------- método estático static void exibeLista(int n, int[] valores) { System.out.print("Lista: "); if (n == 0) { System.out.print("Vazia"); } else { System.out.print("(" + n + ") "); for (int i = 0; i < n; i++) { System.out.print(valores[i] + " "); } } System.out.println(""); } static void ImprimeErro(int erro) { final String SUCESSO = "Okay, operação realizada com sucesso"; // 0 final String CHEIA = "ERRO: Lista Cheia"; // -1 final String VAZIA = "ERRO: Lista Vazia"; // -2 final String EXCEDEU = "Erro: Excedeu o Limite Máximo"; // -3 final String POSICAO = "Erro: Posição Inválida"; // -4 final String VALOR = "Erro: Valor não Encontrado"; // -5 switch (erro) { case 0: System.out.println(SUCESSO); break; case -1: System.out.println(CHEIA); break; case -2: System.out.println(VAZIA); break; case -3: System.out.println(EXCEDEU); break; case -4: System.out.println(POSICAO); break; case -5: System.out.println(VALOR); 11 break; default: System.out.println("Atenção: Erro Desconhecido"); break; } } } // Pesquisa -> Posição: 3 ----> Resultado: Valor: 30 ou ERRO: Não Encontrado // Procura -> Valor: 30 ---> Resultado: Posição: ?? ou ERRO: Não Encontrado // removeAll ---> Eliminar todos os valores // ---------------------------------------------------------------------------------------------------------- Classe: Lista.java package testalista; import java.util.Arrays; public class Lista { // ----------------------- atributos da classe private int n; private final int[] vetor; private final int max; // ----------------------- construtor Lista(int numeroMaxElementos) { n = 0; max = numeroMaxElementos; vetor = new int[max + 1]; } // ----------------------- métodos public int [] exibeLista() { return(vetor); } public int insereLista(int valor) { if (n < max) { vetor[n] = valor; n++; return(0); // SUCESSO } else { return(-3); // EXCEDEU } } public int removeLista() { int valor = vetor[n]; if (n > 0) { n--; return(valor); } else { return(-2); // VAZIA } } public void removeallLista() { n = 0; } public int procuraLista(int valor) { if (n != 0) { for (int i = 1; i < n; i++) { if (vetor[i] == valor) { return (i); } } } return (-5); // Valor não encontrado 12 } public int pesquisaLista(int posicao) { if (posicao >= 0 && posicao < n) { return (vetor[posicao]); } else { return (-4); // Posição Inválida } } public void sort() { Arrays.sort(vetor, 0, n); // início e fim } public void inverteLista() { int i = 0; for (int j = n-1; j >= n / 2; j--) { int temp = vetor[i]; vetor[i] = vetor[j]; i++; vetor[j] = temp; } } public int numeroElementosLista() { return(n); } } Resultado do Programa: Lista: Vazia [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> Valor: 100 <enter> Okay, operação realizada com sucesso Lista: (1) 100 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> Valor: 200 <enter> Okay, operação realizada com sucesso Lista: (2) 100 200 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> Valor: 300 <enter> Okay, operação realizada com sucesso Lista: (3) 100 200 300 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: Exemplo de classe (Lista) aonde os elementos são inseridos a partir da metade do vetor, podendo ser inserido pela esquerda ou direita. Note que a lista é centralizada sempre que necessário. // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgListaMetade.java package testalistametade; import java.util.Scanner; public class TestaListaMetade { public static void main(String[] args) { final int SUCESSO = 0; final int CHEIA = -1; final int VAZIA = -2; final int EXCEDEU = -3; final int POSICAO = -4; final int VALOR = -5; Scanner input = new Scanner(System.in); System.out.print("Número de Elementos: "); String s = input.nextLine(); 13 String r; int numeroElementos = Integer.parseInt(s); Lista lista = new Lista(numeroElementos); char op, ch = 'T'; do { do { int[] valores = lista.exibeLista(); int n = lista.numeroElementosLista(); int inic = lista.inicioLista(); int fim = lista.fimLista(); ExibeLista(n, inic, fim, valores); do { System.out.print("[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: "); s = input.nextLine(); } while (s.isEmpty()); op = s.charAt(0); if (op == 'Q' || op == 'q') { System.exit(1); } if ("IiRr".contains(s)) { do { System.out.print("[E]squerda ou [D]ireita: "); r = input.nextLine(); ch = r.charAt(0); } while (!"EeDd".contains(r)); } } while (!"IiRrAaPpOoSsVv".contains(s)); //} while (!"IRAPOSV".equalsIgnoreCase(s)); switch (op) { case 'I': case 'i': System.out.print("Valor: "); s = input.nextLine(); Integer valor = Integer.parseInt(s); switch (ch) { case 'E': case 'e': lista.insereListaEsquerda(valor); break; case 'D': case 'd': lista.insereListaDireita(valor); break; } break; case 'R': case 'r': switch (ch) { case 'E': case 'e': valor = lista.removeListaEsquerda(); if (valor != VAZIA) { System.out.println("Valor Removido: " + valor); } else { ImprimeErro(VAZIA); } break; case 'D': case 'd': valor = lista.removeListaDireita(); if (valor != VAZIA) { System.out.println("Valor Removido: " + valor); } else { ImprimeErro(VAZIA); } break; } break; 14 case 'A': case 'a': lista.removeallLista(); break; case 'O': case 'o': System.out.print("Valor: "); s = input.nextLine(); valor = Integer.parseInt(s); int posicao = lista.procuraLista(valor); if (posicao != -1) { System.out.println("Posição: " + posicao); } else { ImprimeErro(POSICAO); } break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); valor = lista.pesquisaLista(posicao); if (valor != -1) { System.out.println("Valor Pesquisado: " + valor); } else { ImprimeErro(VALOR); } break; case 'S': case 's': lista.sort(); break; case 'V': case 'v': lista.inverteLista(); break; } } while (true); } // -------------------------------------------------------- método estático static void ExibeLista(int n, int inic, int fim, int[] valores) { System.out.print("Lista: "); if (n == 0) { System.out.print("Vazia"); } else { System.out.print("(" + n + ") "); for (int i = inic; i <= fim; i++) { System.out.print(valores[i] + " "); } } System.out.println(""); } static void ImprimeErro(int erro) { final String SUCESSO = "Okay, operação realizada com sucesso"; // 0 final String CHEIA = "ERRO: Lista Cheia"; // -1 final String VAZIA = "ERRO: Lista Vazia"; // -2 final String EXCEDEU = "Erro: Excedeu o Limite Máximo"; // -3 final String POSICAO = "Erro: Posição Inválida"; // -4 final String VALOR = "Erro: Valor não Encontrado"; // -5 switch (erro) { case 0: System.out.println(SUCESSO); break; case -1: System.out.println(CHEIA); 15 break; case -2: System.out.println(VAZIA); break; case -3: System.out.println(EXCEDEU); break; case -4: System.out.println(POSICAO); break; case -5: System.out.println(VALOR); break; default: System.out.println("Atenção: Erro Desconhecido"); break; } } } // Pesquisa -> Posição: 3 ----> Resultado: Valor: 30 ou ERRO: Não Encontrado // Procura -> Valor: 30 ---> Resultado: Posição: ?? ou ERRO: Não Encontrado // removeAll ---> Eliminar todos os valores // ---------------------------------------------------------------------------------------------------------- Classe: Lista.java package testalistametade; import java.util.Arrays; public class Lista { // ----------------------- atributos da classe private int n = 0; private int inic; private int fim; private final int[] vetor; private final int max; // ----------------------- construtor Lista(int numeroMaxElementos) { n = 0; max = numeroMaxElementos; inic = max / 2; fim = max / 2; vetor = new int[max]; } // ----------------------- métodos public int[] exibeLista() { //-------------------------- retirar depois System.out.print("Lista: "); if (n == 0) { System.out.print("Vazia"); } else { System.out.print("(" + inic + " | " + fim + ") "); for (int i = 0; i < max; i++) { System.out.print(vetor[i] + " "); } } System.out.println(""); // ---------------------------------------------------return (vetor); } public int insereListaDireita(int valor) { if (fim < max - 1) { if (n > 0) { fim++; 16 } vetor[fim] = valor; n++; return (0); // SUCESSO } else { if (centralizaLista()) { fim++; vetor[fim] = valor; n++; return (0); } return (-3); // EXCEDEU } } public int insereListaEsquerda(int valor) { if (inic > 0) { if (n > 0) { inic--; } vetor[inic] = valor; n++; return (0); // SUCESSO } else { if (centralizaLista()) { inic--; vetor[inic] = valor; n++; return (0); } return (-3); // EXCEDEU } } public int removeListaDireita() { if (n > 0) { int valor = vetor[fim]; fim--; n--; return(valor); } else { return(-2); } } public int removeListaEsquerda() { if (n > 0) { int valor = vetor[inic]; inic++; n--; return(valor); } else { return(-2); } } public void removeallLista() { n = 0; inic = max / 2; fim = max / 2; } public int procuraLista(int valor) { if (n != 0) { for (int i = inic; i <= fim; i++) { if (vetor[i] == valor) { return (i); } 17 } } return (-5); } public int pesquisaLista(int posicao) { if (posicao >= inic && posicao <= fim) { return (vetor[posicao]); } else { return (-4); } } public void sort() { Arrays.sort(vetor, inic, fim+1); // início e fim } public void inverteLista() { int i = inic; for (int j = fim; j >= inic + (fim - inic) / 2; j--) { int temp = vetor[i]; vetor[i] = vetor[j]; i++; vetor[j] = temp; } } public int numeroElementosLista() { return (n); } public int inicioLista() { return (inic); } public int fimLista() { return (fim); } private boolean centralizaLista() { int brancos = max - n; int deslocamentos = brancos / 2; if (deslocamentos < 1) { return (false); } if (fim == max - 1) { // desloca para esquerda int j = deslocamentos; for (int i = inic; i <= fim; i++) { vetor[j] = vetor[i]; j++; } inic = inic - deslocamentos - 1; fim = inic + n - 1; } else { // desloca para direita deslocamentos++; int j = fim + deslocamentos; for (int i = fim; i >= inic; i--) { vetor[j] = vetor[i]; j--; } fim = fim + deslocamentos; inic = inic + deslocamentos; } return (true); } } 18 Resultado do Programa: Lista: (5 | 6) 0 0 0 0 0 100 200 0 0 0 0 Lista: (2) 100 200 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> [E]squerda ou [D]ireita: d <enter> Valor: 300 <enter> Lista: (5 | 7) 0 0 0 0 0 100 200 300 0 0 0 Lista: (3) 100 200 300 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> [E]squerda ou [D]ireita: d <enter> Valor: 400 <enter> Lista: (5 | 8) 0 0 0 0 0 100 200 300 400 0 0 Lista: (4) 100 200 300 400 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> [E]squerda ou [D]ireita: d <enter> Valor: 500 <enter> Lista: (5 | 9) 0 0 0 0 0 100 200 300 400 500 0 Lista: (5) 100 200 300 400 500 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> [E]squerda ou [D]ireita: d <enter> Valor: 600 <enter> Lista: (5 | 10) 0 0 0 0 0 100 200 300 400 500 600 Lista: (6) 100 200 300 400 500 600 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter> [E]squerda ou [D]ireita: d <enter> Valor: 700 <enter> Lista: (2 | 8) 0 0 100 200 300 400 500 600 700 500 600 // Note, lista centralizada + lixo (verde claro) Lista: (7) 100 200 300 400 500 600 700 [I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: Uma linguagem de programação orientada à objetos pode suportar e/ou implementar seis (6) propriedades: abstração, encapsulamento, polimorfismo, herança, associação (agregação e composição) e classes abstratas e concretas. Abstração Objetos devem representar dados do mundo real. Encapsulamento (“encapsulação”) Os objetos possuem internamente atributos e métodos agrupados no mesmo local, onde os métodos manipulam os atributos. Esta característica protege os dados (atributos) de alterações indevidas, somente os membros da classe podem acessar os atributos, desde que eles sejam privados (private) ou protegidos (protected) (caso das classes derivadas, que herdam o direito de acesso aos atributos). Polimorfismo (grego: “muitas formas”) É a capacidade de objetos diferentes reagirem segundo a sua função a uma ordem padrão. Significa que o nome de um objeto pode ser utilizado para vários propósitos ligeiramente diferentes, ou seja, “ ... uma interface, vários métodos ... ”. A característica de polimorfismo é utilizada principalmente em sobrecarga de métodos e operadores e classes abstratas, onde os métodos são declarados mas não definidos. Como tipos de polimorfismo tem-se: (a) Universal (inclusão [como em Java, por exemplo, List lista = new LinkedList();] 19 e paramétrico [templates como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores). Java não possui sobrecarga de operadores. Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes tipos de operações; Sobrecarga de Método: Permite que um método retorne diferentes tipos de informações e aceite argumentos de vários tipos, inclusive com quantidade diferentes de argumentos; Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser instanciada, a classe abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma implementação incompleta que é herdada pelas classes derivadas. Cada classe derivada implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir métodos abstratos, mas os métodos são escritos nas classes derivadas concretas. Métodos abstratos definem apenas a forma do método não contendo nenhum tipo de código. Classes concretas implementam todos os métodos e podem ser instanciadas. Herança É o processo pelo qual uma classe de objetos pode adquirir as propriedades de outra classe de objetos, em outras palavras, um objeto herda as características de outro (herança simples) ou vários objetos (herança múltipla). A classe base é chamada de superclasse, enquanto a classe derivada pode ser chamada de subclasse. Associação É um vínculo que permite que objetos de uma ou mais classes se relacionem entre si. Esta associação pode ser: unária (o vínculo é entre objetos da mesma classe), binária (vínculo ocorre entre dois objetos de classes diferentes) ou múltipla (vínculo ocorre entre mais de 2 objetos de classes diferentes). Cada associação pode possuir características de (a) cardinalidade ou multiplicidade (indica quantos objetos são possíveis em cada associação) e (b) navegação (existe a possibilidade dos objetos acessarem outros objetos da mesma associação). Uma associação pode ser de duas formas: agregação (relacionamento com características onde existe um grau menos intenso de coesão entre os elementos, pode haver um certo grau de independência) ou composição (relacionamento com características onde existe um alto grau de coesão e total grau de dependência entre os elementos). Classes Abstratas e Concretas 20 É criada para representar entidades e conceitos abstratos. Uma classe abstrata é sempre uma superclasse ou classe base que não possui instâncias. Ela define apenas o modelo (como um template em C++) para uma funcionalidade e fornece uma implementação incompleta chamada de parte genérica sendo compartilhada por um conjunto de classes derivadas ou subclasses. Classes derivadas completam as funcionalida-des da classe abstrata anexando um comportamento específico. Classes abstratas possuem métodos abstratos. Esses métodos são implementados nas suas classes derivadas concretas com o objetivo de definir o comportamento específico. O método abstrato define apenas a assinatura do método não contendo nenhum código. Classes concretas implementam seus métodos e permitem instanciar objetos. Classes concretas não possuem métodos abstratos quando são classes derivadas de uma classe abstrata. Vantagens da Orientação à Objetos: (a) reutilização de código, (b) proteção aos dados; (c) organização ou estruturação dos dados em forma de classes e objetos; (d) sobrecarga de métodos e de operadores; (e) criação de pacotes de classes; (f) ter um conjunto de pacotes pré-definidos (api’s: java2d, java3d, swing, awt, etc) e (g) permitir ao desenvolvedor criar seus próprios pacotes. API: Application Programming Interface ou Interface de Programação de Aplicativos. É um conjunto de padrões de programação que permitem a construção de aplicativos. Em Java, o programador pode criar suas próprias classes. Uma classe possui duas partes distintas: atributos (variáveis) e métodos (funções ou procedimentos) que manipulam estes atributos. 1.3 Sobrecarga de Métodos Java permite que métodos estáticos (e construtores) sejam sobrecarregados, desta forma, o retorno, número de argumentos ou mesmo o tipo de dados dos argumentos podem ser diferentes. Dependendo da chamada do método, o Java identifica qual método (ou construtor) sobrecarregado deve ser executado. Teoricamente, é uma especificação que pode ter várias implementações com características diferentes. // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgSobreCarga.java package progsobrecarga; public class ProgSobreCarga { public static void main(String[] args) { imprime("Pelotas-RS"); imprime(123.45); imprime(123.45f); imprime(123); imprime('A'); } static void imprime(String s) { System.out.println("String: " + s); } static void imprime(Double d) { System.out.println("Double: " + d); 21 } static void imprime(Float f) { System.out.println("Float: " + f); } static void imprime(Integer i) { System.out.println("Inteiro: " + i); } static void imprime(Character ch) { System.out.println("Caracter: " + ch); } } Resultado do Programa: String: Senac-RS Double: 123.45 Float: 123.45 Inteiro: 123 Caracter: A // -------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java package progpolimorfismo; public class ProgPolimorfismo { public static void main(String[] args) { pixel(1, 2); pixel(1, 2, 3); pixel(1.0, 2.0, 3.0); pixel('A', 'B', 'C'); } public static void pixel(int x, int y) { System.out.printf("x = %d | y = %d\n", x, y); } public static void pixel(int x, int y, int z) { System.out.printf("x = %d | y = %d | z = %d\n", x, y, z); } public static void pixel(double x, double y, double z) { System.out.printf("x = %.2f | y = %.2f | z = %.2f\n", x, y, z); } public static void pixel(char x, char y, char z) { System.out.printf("x = %c | y = %c | z = %c\n", x, y, z); } } Resultado do Programa: x=1|y=2 x=1|y=2|z=3 x = 1,00 | y = 2,00 | z = 3,00 x=A|y=B|z=C 1.4 Referência this 22 Em Java, quando um método de uma classe é chamado, é passado automaticamente um argumento que é uma referência para o objeto que gerou a chamada. Esta referência é chamada this, ou seja, a referência this referencia o objeto que chamou o método. Cada objeto tem acesso a uma referência a ele próprio, chamada this. Esta referência faz referências aos atributos e métodos de um objeto. Programa exemplo: Utilização da referência this em uma classe. // ------------------------------------------------------------------------------------------------------------------------------------- Classe: Data.java package progdata; import java.text.DecimalFormat; public class Data { // ------------------------------------- atributos da classe private int dia, mes, ano; // ------------------------------------------------ construtor Data(int dia, int mes, int ano) { this.dia = dia; this.mes = mes; this.ano = ano; } // ------------------------------------------- sobrecarga do método toString public String toString() { DecimalFormat form = new DecimalFormat("00"); String data = "Data: " + form.format(dia) + "/" + form.format(mes) + "/" + ano; return (data); } } // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgData.java package progdata; public class ProgData { public static void main(String[] args) { Data data = new Data(5, 8, 2014); System.out.println(data); } } Resultado do Programa: Data: 05/08/2014 Solução do programa proposto acima: Classe “Vetor” e seus métodos. // -------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java package progvetor1; public class Vetor { // --------------------------------------------- atributos da classe private final int[] vetor; private int n; private final int max; 23 // ---------------------------------------------- construtor Vetor(int numeroElementos) { max = numeroElementos; vetor = new int[max]; n = 0; } // ----------------------------------------------- add public void add(int valor) { if (n < max) { vetor[n] = valor; n++; } else { System.out.println("Erro: Excedeu Limite do Vetor"); } } // ------------------------------------------------ del public int del() { if (n != 0) { int valor = vetor[n - 1]; n--; return (valor); } else { System.out.println("Erro: Vetor Vazio"); return (-999); } } // ------------------------------------------------- length public int length() { return (n); } // ------------------------------------------------- primeiro public int primeiro() { if (n != 0) { return (vetor[0]); } else { return (-999); } } // -------------------------------------------------- ultimo public int ultimo() { int ultimo = n - 1; if (n != 0) { return (vetor[ultimo]); } else { return (-999); } } // ----------------------------------------------------- existe public boolean existe(int elemento) { for (int i = 0; i < n; i++) { if (elemento == vetor[i]) { return (true); } } return (false); } // ----------------------------------------------------- exibe public void exibe() { System.out.print("Vetor: ["); for (int i = 0; i < n; i++) { 24 System.out.print(vetor[i] + ", "); } System.out.println("\b\b]"); } // ------------------------------------------------------ numeroElementosVetor public int numeroElementosVetor() { return (n); } } // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor1.java package progvetor1; public class ProgVetor1 { public static void main(String[] args) { Vetor vetor = new Vetor(5); // 5 é o número de elementos do vetor estático da classe vetor.add(10); vetor.add(20); vetor.add(30); vetor.add(40); vetor.add(50); vetor.exibe(); vetor.add(60); vetor.exibe(); System.out.println("Total de Elementos: " + vetor.numeroElementosVetor()); int valor = vetor.del(); if (valor != -999) { System.out.println("Valor Excluído: " + valor); } else { System.out.println("ERRO: Vetor Vazio"); } vetor.exibe(); System.out.println("Total de Elementos: " + vetor.length()); int primeiro = vetor.primeiro(); System.out.println("Primeiro: " + primeiro); int ultimo = vetor.ultimo(); System.out.println("Último: " + ultimo); int elemento = 20; boolean flag = vetor.existe(elemento); if (flag) { System.out.println("Existe elemento: " + elemento); } else { System.out.println("Não Existe elemento 20"); } } } 1.5 Lista de exercícios: Classes 1.5.1 Dado o seguinte programa principal, implemente a classe “Circulo” e seus métodos: // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgCirculo.java package progcirculo; public class ProgCirculo { public static void main(String[] args) { Circulo circ = new Circulo(); circ.setRaio(3); circ.calculaArea(); double area = circ.getArea(); 25 System.out.printf("Área: %.2f\n", area); } } Observação: area = pi . raio2 onde pi é 3.1416 Círculo double area, raio setRaio calculaArea getArea Diagrama de classe Resultado do Programa: Área: 28,27 1.5.2 Dado o seguinte programa principal, implemente a classe “PesoIdeal” e seus métodos: // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgPeso.java package progpeso; public class ProgPeso { public static void main(String[] args) { PesoIdeal piHomem = new PesoIdeal('H', 1.67); PesoIdeal piMulher = new PesoIdeal('m', 1.65); piHomem.calculaPesoIdeal(); System.out.printf("Peso Ideal Homem: %.2f\n", piHomem.getPesoIdeal()); piMulher.calculaPesoIdeal(); System.out.printf("Peso Ideal Mulher: %.2f\n", piMulher.getPesoIdeal()); } } Resultado do Programa: Peso Ideal Homem: 63,41 Peso Ideal Mulher: 57,77 Cálculo do Peso Ideal: PIH = 72,7 x altura – 58 e PIM = 62,1 x altura – 44,7 PesoIdeal double altura, pesoIdeal char sexo calculaPesoIdeal getPesoIdeal Diagrama de classe 1.5.3 Dado o seguinte programa principal, implemente a classe “CPF” e seus métodos: // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java package progvalidacpf; public class ProgValidaCPF { public static void main(String[] args) { String s = "123456789"; CPF cpf = new CPF(s); int digitoVerificador = cpf.verificaCPF(); System.out.printf("Digito verificador: %02d\n", digitoVerificador); System.out.printf("CPF: %s-%02d\n", s , digitoVerificador); } } 26 Resultado do Programa: Digito verificador: 09 CPF: 123456789-09 CPF String cpf int digito verificaCPF Diagrama de classe Como calcular os Dígitos do CPF: Entrada: CPF: 123456789 1) Primeiramente pega-se os dígitos da base do CPF e se faz a soma da multiplicação individual dos dígitos, iniciando por 10 e indo até 2 como exemplificado abaixo: 1 2 3 4 5 6 7 8 9 x x x x x x x x x 10 9 8 7 6 5 4 3 2 -- -- -- -- -- -- -- -- -10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18 = 210 2) O valor do primeiro dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por 11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em questão o dígito encontrado é calculado conforme vê-se a seguir: 11 - (210 % 11) = 10 3) O cálculo do segundo dígito é feito da mesma forma que o primeiro, porém com os 9 dígitos da base do CPF e o primeiro dígito verificador encontrado, iniciando por 11 e indo até 2. 1 2 3 4 5 6 7 8 9 0 x x x x x x x x x x 11 10 9 8 7 6 5 4 3 2 -- -- -- -- -- -- -- -- -- -11 + 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0 = 255 4) O valor do segundo dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por 11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em questão o dígito encontrado é calculado conforme vê-se a seguir: 11 - (255 % 11) = 9 Saída: CPF válido é 123.456.789-09 ou 123456789-09 1.5.4 Dado o seguinte programa, implemente a classe “DiaSemana” e seus métodos: // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgDiaSemana.java package progdiasemana; public class ProgDiaSemana { public static void main(String[] args) { DiaSemana dia = new DiaSemana(10, 2, 1962); dia.verificaDiaSemana(); dia.exibeDiaSemana(); } } Resultado do Programa: Dia da Semana: Sábado DiaSemana 27 int dia, mes, ano String semama verificaDiaSemana exibeDiaSemana Diagrama de classe Como calcular o Dia da Semana: Deve-se calcular o Dia do Século: Para qualquer cálculo com datas é essencial que se disponha do Dia do Século para a(s) data(s) em questão. O Dia do Século é o número de dias decorridos desde o início do século (1º de janeiro de 1901) até a data em questão. Se usa como referência 1901 porque a maioria das datas com as quais se trabalha ainda são do século passado. Lá por 2040 ou mais poderá se mudar para 2001. A fórmula (válida para datas entre 1901 e 2099) é a seguinte: numeroDias = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (mês - 1) * 31 - [(mês * 4 + 23) DIV 10] * [(mês + 12) DIV 15] + [(4 ano MOD 4) DIV 4] * [(mês + 12) DIV 15] Dados de Teste: Dia: 10 Mês: 2 Ano: 1962 numeroDias = 22321 (para a data acima) Onde: DIV é a divisão inteira e MOD é o resto inteiro da divisão Verificação do Dia da Semana: Para saber o diaSemana basta dividir o numeroDias por 7 e entrar com o resto inteiro da divisão na tabela abaixo: 0 Segunda 1 Terça 2 Quarta 3 Quinta 4 Sexta 5 Sábado 6 Domingo Resultado do Programa: (Saída) 10/02/1962 é um(a) Sábado Observação: DIV é divisão inteira de dois números e MOD é o resto inteiro da divisão de dois números. 1.5.5 Dado o seguinte programa principal, implemente a classe Data e seus métodos: // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestData.java package progtestdata; public class ProgTestData { public static void main(String[] args) { Data data = new Data(); data.setData(25, 8, 2014); data.extenso(); } } Resultado do Programa: Data: 25 de agosto de 2014 Data int dia, mes, ano setData extenso 28 Diagrama de classe 1.5.6 Implemente os métodos forcaBruta e bubleSort na classe “Vetor” vista anteriormente (Fonte: ProgVetor). // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java package progvetorsort; public class ProgVetorSort { public static void main(String[] args) { Vetor vetor = new Vetor(5); vetor.add(40); vetor.add(20); vetor.add(30); vetor.add(50); vetor.add(10); vetor.exibe(); vetor.add(60); vetor.exibe(); vetor.forcaBruta(); vetor.exibe(); vetor.bubbleSort(); vetor.exibe(); } } Resultado do Programa: Vetor: [40 20 30 50 10] ERRO: Excedeu o Limite do Vetor Vetor: [40 20 30 50 10] Vetor: [10 20 30 40 50] Vetor: [10 20 30 40 50] 1.5.7 Dado o seguinte programa principal, implemente a classe “Pessoa” e seus métodos. // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java package progpessoa; public class ProgPessoa { public static void main(String[] args) { Pessoa p1 = new Pessoa(); Pessoa p2 = new Pessoa(); Pessoa p3 = new Pessoa(); p1.setDados("Paulo Roberto", 1962, 'm'); p2.setDados("Renato Luis", 1965, 'm'); p3.setDados("Francisco Carlos", 1959, 'm'); p1.calculaIdade(); p2.calculaIdade(); p3.calculaIdade(); p1.exibePessoa(); p2.exibePessoa(); p3.exibePessoa(); } } Resultado do Programa: Nome: Paulo Roberto Idade: 52 ano(s) Sexo: Masculino 29 Nome: Renato Luis Idade: 49 ano(s) Sexo: Masculino Nome: Francisco Carlos Idade: 55 ano(s) Sexo: Masculino Pessoa String nome int ano int idade char sexo setDados calculaIdade exibePessoa Diagrama de classe 1.5.8 Dado o seguinte programa principal, implemente a classe “Pessoa” e seus métodos. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa2.java package progpessoa2; public class ProgPessoa2 { public static void main(String[] args) { Pessoa [] pessoa = new Pessoa[3]; pessoa[0] = new Pessoa(); pessoa[0].setDados("Paulo Roberto", 1962, 'm'); pessoa[0].calculaIdade(); pessoa[0].exibePessoa(); pessoa[1] = new Pessoa(); pessoa[1].setDados("Renato Luis", 1965, 'm'); pessoa[1].calculaIdade(); pessoa[1].exibePessoa(); pessoa[2] = new Pessoa(); pessoa[2].setDados("Francisco Carlos", 1959, 'm'); pessoa[2].calculaIdade(); pessoa[2].exibePessoa(); } } Resultado do Programa: Nome: Paulo Roberto Idade: 52 ano(s) Sexo: Masculino Nome: Renato Luis Idade: 49 ano(s) Sexo: Masculino Nome: Francisco Carlos Idade: 55 ano(s) Sexo: Masculino Pessoa String nome int ano int idade char sexo setDados calculaIdade exibePessoa Diagrama de classe 30 1.5.9 Dado o seguinte programa principal, implemente a classe “Pessoa” e seus métodos. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java package progpessoas; public class ProgPessoas { public static void main(String[] args) { Pessoa pessoa = new Pessoa(7); pessoa.insereDados("Beatriz", 11); pessoa.insereDados("Debora", 13); pessoa.insereDados("Fátima", 15); pessoa.insereDados("Geni", 16); pessoa.insereDados("Carla", 12); pessoa.insereDados("Eva", 14); pessoa.insereDados("Ana", 10); pessoa.exibeDados(); pessoa.sort(); pessoa.exibeDados(); } } Resultado do Programa: Lista de Pessoas Nome: Beatriz Nome: Debora Nome: Fátima Nome: Geni Nome: Carla Nome: Eva Nome: Ana Lista de Pessoas Nome: Ana Nome: Beatriz Nome: Carla Nome: Debora Nome: Eva Nome: Fátima Nome: Geni Idade: 11 Idade: 13 Idade: 15 Idade: 16 Idade: 12 Idade: 14 Idade: 10 Idade: 10 Idade: 11 Idade: 12 Idade: 13 Idade: 14 Idade: 15 Idade: 16 Pessoa String [] nome int [] idade int n int max insereDados exibeDados sort Diagrama de classe 1.5.10 Dado o seguinte programa principal, implemente a classe “Agenda” e seus métodos. // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgAgenda.java package progagenda; public class ProgAgenda { public static void main(String[] args) { Agenda agenda = new Agenda(5); agenda.insereTelefone("Ana", "99811234"); agenda.insereTelefone("Beatriz", "99812345"); agenda.insereTelefone("Carla", "99813456"); 31 agenda.insereTelefone("Debora", "99814567"); agenda.insereTelefone("Eva", "99815678"); agenda.insereTelefone("Fátima", "99816789"); String fone = "99815678"; String nome = agenda.consultaNome(fone); if (nome.compareTo("") != 0) { System.out.println("Nome: " + nome + " - Telefone: " + fone); } else { System.out.println("ERRO: Usuário não Encontrado"); } fone = "99810123"; nome = agenda.consultaNome(fone); if (nome.compareTo("") != 0) { System.out.println("Nome: " + nome + " - Telefone: " + fone); } else { System.out.println("ERRO: Usuário não Encontrado"); } } } Resultado do Programa: ERRO: Excedeu limite da Agenda Nome: Eva - Telefone: 99815678 ERRO: Usuário não Encontrado Agenda String [] nome String [] fone int n int max insereTelefone consultaNome Diagrama de classe 1.5.11 Dado o seguinte programa principal, implemente a classe “Calculadora” e seus métodos. // -------------------------------------------------------------------------------------------------- Programa Principal: ProgCalculadora.java package progcalculadora; public class ProgCalculadora { public static void main(String[] args) { Calculadora calc = new Calculadora(); calc.entradaDados(); calc.operaCalculadora(); calc.exibeResultadoCalculadora(); } } Observação: A calculadora deve ter as seguintes operações: [+] adição [-] subtração [*] multiplicação [/] divisão [R] Raiz Quadrada [P] Potência [S] Seno [C] Cosseno [T] Tangente Calculadora 32 double x double y char operador double resposta entradaDados operaCalculadora exibeResultadoCalculadora Diagrama de classe Exemplo para testar o programa: Digite um Valor: 3 <enter> Operação [+-*/RrPpSsCcTt]: + <enter> Digite outro Valor: 4 <enter> Primeiro Valor: 3.0 Operador: [Adição] Segundo Valor : 4.0 Resultado da Operação: 7.0 Exemplo da definição de uma classe “Data”: // -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Data.java package progtestadata; public class Data { // ------------------------------ atributos da classe private final int dia; private final int mes; private final int ano; // ----------------------------------------------------- construtor da classe public Data(int dia, int mes, int ano) { this.dia = dia; this.mes = mes; this.ano = ano; } // ------------------------------------------------------------------------------------------ sobrecarga do método toString @Override // método “toString” sobrecarregado public String toString() { return("Data: " + this.dia + "/" + this.mes + "/" + this.ano); } } Programa exemplo: Programa que utiliza a classe “Data” definida anteriormente: // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaData.java package progtestadata; public class ProgTestaData { public static void main(String[] args) { Data data = new Data(16, 3, 2010); // construtor irá receber 3 argumentos System.out.println(data); } } Resultado do Programa: Data: 16/3/2010 Exemplo da definição de uma classe “Calculadora”: 33 // -------------------------------------------------------------------------------------------------------------------- Classe: Calculadora.java package progcalculadora; import java.util.Scanner; public class Calculadora { // ------------------------ atributos da classe private double x; private double y; private double resultado; private char operador; // ------------------------ construtor // --------------------------------------- métodos públicos da classe public void entradaDados() { Scanner input = new Scanner(System.in); System.out.print("Digite um Valor: "); String s = input.nextLine(); s = s.replaceAll("[^0-9\\-.]", ""); // eliminação de letras digitadas de forma indevida x = Double.parseDouble(s); // que não podem ser convertidas para double do { System.out.print("Operação [+-*/RrPpSsCcTt]: "); s = input.nextLine(); operador = s.charAt(0); } while (!strChr("+-*/RrPpSsCcTt", operador)); if (strChr("+-*/Pp", operador)) { System.out.print("Digite outro Valor: "); s = input.nextLine(); s = s.replaceAll("[^0-9\\-.]", ""); // eliminação de letras digitadas de forma indevida y = Double.parseDouble(s); // que não podem ser convertidas para double } } public void operaCalculadora() { switch (operador) { case '+': resultado = add(); break; case '-': resultado = sub(); break; case '*': resultado = mul(); break; case '/': resultado = div(); break; case 'P': case 'p': resultado = pot(); break; case 'R': case 'r': resultado = raiz(); break; case 'S': case 's': resultado = sen(); break; case 'C': case 'c': resultado = cos(); break; case 'T': case 't': resultado = tan(); 34 break; } } public void exibeResultadoCalculadora() { String nomeOperador; System.out.println("Primeiro Valor: " + x); switch (operador) { case '+': nomeOperador = "Adição"; break; case '-': nomeOperador = "Subtração"; break; case '*': nomeOperador = "Multiplicação"; break; case '/': nomeOperador = ("Divisão"); break; case 'R': case 'r': nomeOperador = "Raiz Quadrada"; break; case 'P': case 'p': nomeOperador = "Potência"; break; case 'S': case 's': nomeOperador = "Seno"; break; case 'C': case 'c': nomeOperador = "Cosseno"; break; case 'T': case 't': nomeOperador = "Tangente"; break; default: nomeOperador = "Operador Inválido"; } System.out.printf("Operação realizada: [%s]\n", nomeOperador); System.out.println("Segundo Valor : " + y); System.out.println("Resultado da Operação: " + resultado); } // ------------------------------- métodos privados da classe private double add() { return (x + y); } private double sub() { return (x - y); } private double mul() { return (x * y); } private double div() { return (x / y); } private double pot() { return (Math.pow(x, y)); } private double raiz() { return (Math.sqrt(x)); } private double sen() { double rads = converteRadianos(x); return (Math.sin(rads)); } 35 private double cos() { double rads = converteRadianos(x); return (Math.cos(rads)); } private double tan() { double rads = converteRadianos(x); return (Math.tan(rads)); } // ----------------------------------------------------------------------- métodos estáticos da classe private static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } private static double converteRadianos(double graus) { double rads = Math.PI * graus / 180.0; return (rads); } } Programa exemplo: Utiliza a classe “Calculadora” e seus métodos definidos acima: // -------------------------------------------------------------------------------------------------- Programa Principal: ProgCalculadora.java package progcalculadora; public class ProgCalculadora { public static void main(String[] args) { Calculadora calc = new Calculadora(); // classe não recebe argumentos, não é necessário ela ter construtor calc.entradaDados(); calc.operaCalculadora(); calc.exibeCalculadora(); } } Programa exemplo: Mostra outra forma de utilizar a função “strChr” oriunda da linguagem de programação C e C++ utilizando o método “indexOf” do Java. // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgstrChr.java package progstrchr; import java.util.Scanner; public class ProgstrChr { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String nome, s; do { System.out.print("Nome: "); nome = entrada.nextLine(); int n = nome.length(); System.out.println(nome + " seu nome tem " + n + " caracteres"); do { 36 System.out.print("Continua [S/N]? " ); s = entrada.nextLine(); } while ("SsNn".indexOf(s) == -1); } while ("Nn".indexOf(s) == -1); // ou ... } while ("S".equalsIgnoreCase(s)); } } Exemplo para testar o programa: Nome: Paulo Roberto Gomes Luzzardi <enter> Paulo Roberto Gomes Luzzardi seu nome tem 28 caracteres Continua [S/N]? N <enter> Modificadores de Acesso: public: Os atributos e métodos tornam-se públicos, ou seja, qualquer outro método pode chamar ou utilizar estes atributos e/ou métodos. private: Somente os métodos da classe (membros) da classe podem chamar ou utilizar atributos ou métodos privados. protected: Utilizado em herança simples de classe (construção de subclasses), ou seja, uma subclasse herda todos os atributos e métodos da classe base (superclasse). Deixa acessível os atributos e/ou métodos para todas as outras classes (classe base) e subclasses (classe derivada). 37 2. Interface e Polimorfismo 2.1 Interface Uma interface é uma especificação que define um determinado conjunto de métodos que serão implementados nas classes desta interface. Para uma interface ser integralmente abstrata, seus métodos devem ser definidos como abstract e as variáveis por padrão são sempre constantes (static final). Uma interface é definida através da palavra reservada interface e uma classe para implementar uma interface usa a palavra reservada implements. Como Java não possui herança múltipla, a implementação de interfaces supram esta carência, como uma classe só pode herdar apenas uma vez, pode-se implementar inúmeras interfaces. As classes que implementam uma interface terão obrigatoriamente que ter todos os métodos da interface ou se transformar em uma classe abstrata. // ------------------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface.java package proginterface; public class ProgInterface { public static void main(String[] args) { Homem homem = new Homem("Paulo Roberto"); Mulher mulher = new Mulher("Adriane Maria"); homem.exibeNome(); homem.exibeSexo(); mulher.exibeNome(); mulher.exibeSexo(); } } // ------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package proginterface; public interface Pessoa { public abstract void exibeNome(); public abstract void exibeSexo(); } // ------------------------------------------------------------------------------------------------------------------------------ Classe: Homem.java package proginterface; public class Homem implements Pessoa { // --------------------------------------------- atributos da classe private final String nome; private static final char sexo = 'm'; Homem(String nome) { this.nome = nome; } @Override public void exibeNome() { // método “exibeNome” sobrecarregado 38 System.out.println("Homem: " + nome); } @Override // método “exibeSexo” sobrecarregado public void exibeSexo() { System.out.println("Sexo: Masculino -> " + sexo); } } // --------------------------------------------------------------------------------------------------------------------------------------- Classe: Mulher.java package proginterface; public class Mulher implements Pessoa{ // ------------------------------------------------- atributos da classe private final String nome; private static final char sexo = 'f'; Mulher(String nome) { this.nome = nome; } @Override // método “exibeNome” sobrecarregado public void exibeNome() { System.out.println("Mulher: " + nome); } @Override // método “exibeSexo” sobrecarregado public void exibeSexo() { System.out.println("Sexo: Feminino -> " + sexo); } } Resultado do Programa: Homem: Paulo Roberto Sexo: Masculino -> m Mulher: Adriane Maria Sexo: Feminino -> f // --------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPixel.java package progpixel; public class ProgPixel { public static void main(String[] args) { Pixel2D pixel2D = new Pixel2D(3, 4); Pixel3D pixel3D = new Pixel3D(5, 6, 7); pixel2D.exibe(); pixel2D.setX(7); pixel2D.setY(8); pixel2D.exibe(); pixel3D.exibe(); pixel3D.setX(1); pixel3D.setY(2); pixel3D.setZ(3); pixel3D.exibe(); } } // ---------------------------------------------------------------------------------------------------------------------------------------- Interface: Pixel.java package progpixel; public interface Pixel { 39 public abstract void setX(int x); public abstract void setY(int y); public abstract void setZ(int z); public abstract void exibe(); } // ---------------------------------------------------------------------------------------------------------------------------------------- Classe: Pixel2D.java package progpixel; public class Pixel2D implements Pixel { private int x; private int y; Pixel2D(int x, int y) { this.x = x; this.y = y; } @Override public void setX(int x) { this.x = x; } @Override public void setY(int y) { this.y = y; } @Override public void setZ(int z) { } @Override public void exibe() { System.out.printf("x = %d | y = %d\n", x, y); } } // ---------------------------------------------------------------------------------------------------------------------------------------- Classe: Pixel3D.java package progpixel; public class Pixel3D implements Pixel { private int x; private int y; private int z; Pixel3D(int x, int y, int z) { this.x = x; this.y = y; this.z = z; } @Override public void setX(int x) { this.x = x; } @Override public void setY(int y) { this.y = y; } @Override public void setZ(int z) { this.z = z; } 40 @Override public void exibe() { System.out.printf("x = %d | y = %d | z = %d\n", x, y, z); } } Resultado do Programa: x=3|y=4 x=7|y=8 x=5|y=6|z=7 x=1|y=2|z=3 2.2 Polimorfismo Conforme dito anteriormente, Polimorfismo, do grego: “muitas formas”, é a capacidade de objetos diferentes reagirem segundo a sua função a uma ordem padrão. Significa que o nome de um objeto pode ser utilizado para vários propósitos ligeiramente diferentes, ou seja, “ ... uma interface, vários métodos ... ”. A característica de polimorfismo é utilizada principalmente em sobrecarga de métodos e operadores e classes abstratas, onde os métodos são declarados abstratos mas não definidos. Como tipos de polimorfismo tem-se: (a) Universal (inclusão [como em Java, por exemplo, List lista = new LinkedList();] e paramétrico [templates como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores). Java não possui sobrecarga de operadores. Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes tipos de operações; Sobrecarga de Método: Permite que um método retorne diferentes tipos de informações e aceite argumentos de vários tipos, inclusive com quantidade diferentes de argumentos; Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser instanciada, a classe abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma implementação incompleta que é herdada pelas classes derivadas. Cada classe derivada implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir métodos abstratos, mas os métodos são escritos nas classes derivadas concretas. Métodos abstratos definem apenas a forma do método não contendo nenhum tipo de código. Classes concretas implementam todos os métodos e podem ser instanciadas. Polimorfismo é o princípio no qual duas ou mais classes derivadas de uma mesma classe base podem implementar métodos que têm a mesma especificação, mas tem comportamentos diferentes, especializadas para cada uma das classes derivadas, utilizando uma referência a cada um dos objetos da classe base. Polimorfismo significa várias formas, onde um objeto pode se comportar de formas ligeiramente diferentes ao receber uma mensagem. Através do mecanismo de sobrecarga, dois métodos de uma classe 41 podem ter o mesmo nome, desde que suas implementações sejam diferentes, entretanto isso não é considerado polimorfismo em Java. No polimorfismo é necessário que os métodos tenham exatamente a mesma especificação, sendo utilizado um mecanismo de redefinição de métodos nas classes derivadas. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java package progpolimorfismo; public class ProgPolimorfismo { public static void main(String[] args) { Pessoa homem = new Homem(1.64, 'm'); System.out.printf("Peso Ideal: %.2f (%s)\n", homem.calculaPesoIdeal(), homem.getSexo()); Pessoa mulher = new Mulher(1.64, 'f'); System.out.printf("Peso Ideal: %.2f (%s)\n", mulher.calculaPesoIdeal(), mulher.getSexo()); } } // ------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java package progpolimorfismo; abstract class Pessoa { protected Double altura; protected Character sexo; public abstract Double calculaPesoIdeal(); public abstract String getSexo(); } // ------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java package progpolimorfismo; class Homem extends Pessoa { Homem(Double altura, Character sexo) { this.altura = altura; this.sexo = sexo; } @Override public Double calculaPesoIdeal() { Double pesoIdeal = 72.7 * altura - 58.0; return (pesoIdeal); } @Override public String getSexo() { return("Masculino"); } } // ------------------------------------------------------------------------------------------------------- Classe Derivada: Mulher.java package progpolimorfismo; class Mulher extends Pessoa{ Mulher(Double altura, Character sexo) { this.altura = altura; this.sexo = sexo; } 42 @Override public Double calculaPesoIdeal() { Double pesoIdeal = 62.1 * altura - 44.7; return (pesoIdeal); } @Override public String getSexo() { return("Feminino"); } } Resultado do Programa: Peso Ideal: 61,23 (Masculino) Peso Ideal: 57,14 (Feminino) 2.3 Lista de Exercícios: Interface e Polimorfismo 2.3.1 Dado o seguinte programa principal: // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java package proginterface_1; public class ProgInterface_1 { public static void main(String[] args) { Cardeal cardeal = new Cardeal("Cardeal", "Vermelho", "Cinza"); CardealBanhado cardealBanhado = new CardealBanhado("Cardeal Banhado", "Vermelho", "preto"); cardeal.exibeNome(); cardeal.exibeCores(); cardealBanhado.exibeNome(); cardealBanhado.exibeCores(); } } e a seguinte interface (Passaro): // ---------------------------------------------------------------------------------------------------------------------------------- Interface: Passaro.java package proginterface_1; public interface Passaro { public final int patas = 2; public abstract void exibeNome(); public abstract void exibeCores(); } // não pode ser private Complemente o código do programa criando as classes “Cardeal” e “CardealBanhado” para que o programa tenha o seguinte resultado na sua execução: Resultado do Programa: Nome do Pássaro: Cardeal Número de Patas: 2 Cor do Topete: Vermelho Cor do Corpo: Cinza Nome do Pássaro: Cardeal Banhado Número de Patas: 2 Cor do Topete: Vermelho Cor do Corpo: preto 43 2.3.2 Dado o seguinte programa principal: // -------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_2.java package proginterface_2; public class ProgInterface_2 { public static void main(String[] args) { Homem homem = new Homem(); Mulher mulher = new Mulher(); homem.setDados("Paulo Roberto", 52, 'm'); mulher.setDados("Adriane Maria", 45, 'f'); System.out.println(homem); System.out.println(mulher); } } e a seguinte interface (Pessoa): // ---------------------------------------------------------------------------------------------------------------------- Interface: Pessoa.java package proginterface_2; public interface Pessoa { public abstract void setDados(String nome, int idade, char sexo); public abstract String toString(); } Resultado do Programa: | Homem: Paulo Roberto | Idade: 52 | Sexo: MASCULINO | | Mulher: Adriane Maria | Idade: 45 | Sexo: FEMININO | 44 3. Herança em Java A ideia básica da herança é que uma classe herde as características de outra classe. Java possui apenas herança simples, ou seja, não permite herança múltipla. 3.1 Herança simples A herança simples permite que uma classe incorpore os atributos e métodos (características) de outra classe, ou seja, permite a construção de uma hierarquia de classes. Lembre: Java não possui herança múltipla, ou seja, tipo de herança em que uma classe derivada herda características de várias classes Base. O primeiro passo envolve a definição de uma classe base (superclasse) que define as características comuns à todos os objetos derivados desta classe. As classes oriundas da classe base são chamadas classes derivadas ou extensão da classe (subclasse) (Figura 2). Figura 2: Exemplo de Herança em Java Uma classe derivada herda todas as características da classe base e pode ter novas características adicionadas a ela. Uma classe derivada segue a seguinte diretriz em relação a classe base: classe_derivada é um(a) classe_base; Como verificar um caso de Herança: um cardial é um pássaro 45 // classe base: pássaro // classe derivada: cardial Especificadores de acesso: public (público) private (privado) Quem tem acesso à classe tem acesso também a qualquer membro público. É raro ter atributos públicos, mas é comum ter métodos públicos. Qualquer método tem acesso. Um membro privado não é acessível fora da classe, somente pelos membros da classe. A intenção é permitir que apenas quem escreve a classe possa usar esse membro. protected (protegido) O membro protegido é acessível à classe e a suas sub-classes (classes derivadas). A intenção é dar acesso aos programadores que estenderão sua classe. 3.2 Controle de acesso na definição de uma classe derivada Quando uma classe derivada é definida, ou seja, na definição de herança simples, seus membros (atributos e métodos) são declarados internamente e o acesso a estes pode ser público (public), privativo (private) ou protegido (protected). O acesso a membros protegidos é igual ao acesso a membros privativos, exceto para o acesso das classes derivadas da classe. A forma geral de especificar herança simples é: Especificador_de_acesso class nome_classe_derivada extends nomeclasse_base { // atributos da classe derivada // métodos da classe derivada } Quando uma classe herda as características de outra classe, todos os membros da classe base tornamse membros da classe derivada. O tipo de acesso da classe base dentro da classe derivada é determinado pelo especificador de acesso. Qualquer que seja o especificador de acesso, membros privativos da classe base continuam sendo propriedade privada da classe base, e não podem ser acessados por classes derivadas. Quando o especificador de acesso é public, todos os membros públicos da classe base tornam-se membros públicos da classe derivada, e os membros protegidos da classe base tornam-se membros protegidos da classe derivada. Esta é a diferença que existe entre membros privativos e membros protegidos. Quando o especificador de acesso é private, todos os membros públicos e protegidos da classe base tornam-se membros privativos da classe derivada, ou seja, a classe derivada não pode transferir seus privilégios de acesso a outras classes. Quando o especificador de acesso é protected, todos os membros públicos e protegidos da classe base tornam-se membros protegidos da classe derivada. 46 Programa exemplo: O objetivo deste programa, a seguir, é demonstrar a utilização de herança simples onde os atributos da classe base são privados. // ------------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca.java package progheranca; public class ProgHeranca { public static void main(String[] args) { Derivada objeto = new Derivada(3); int resp; objeto.setAtributos(1, 2); resp = objeto.soma(); System.out.println("Somador (x + y + z): " + objeto.somador(resp)); } } // ---------------------------------------------------------------------------------------------------------------------------- Classe Base: Base.java package progheranca; public class Base { private int x, y; // atributos privados public void setAtributos(int a, int b) { x = a; y = b; System.out.println("x = " + x); System.out.println("y = " + y); } public int soma() { System.out.println("Soma (x + y): " + (x + y)); return(x + y); } } // -------------------------------------------------------------------------------------------------------------------- Classe Derivada: Derivada.java package progheranca; public class Derivada extends Base { private int z; Derivada(int x) { z = x; System.out.println("z = " + z); } public int somador(int soma) { // não é possível acessar x e y pois são privados da classe base return(soma + z); } } Resultado do Programa: z=3 x=1 y=2 Soma (x + y): 3 Somador (x + y + z): 6 Responda: Porque o atributo “z” é exibido primeiro? 47 Base int x int y setAtributos(int a, int b); soma(); Classe base (superclasse) Derivada int z int somador(int soma); Classe derivada (subclasse) 3.3 Tipos de acessos (especificadores de acesso) public (público): Todos os atributos da classe base são públicos na classe derivada. private (privado): Os atributos só podem ser acessados pelos métodos que fazem parte da classe. protected (protegido): Os atributos podem ser acessados pelos métodos de classes derivadas. Programa exemplo: O objetivo do próximo programa é demonstrar a utilização de herança simples tendo os atributos da classe base como protegidos. // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca2.java package progheranca2; public class ProgHeranca2 { public static void main(String[] args) { Derivada objeto = new Derivada(3); int resp; objeto.setAtributos(1, 2); resp = objeto.soma(); System.out.println("Somador (x + y + z): " + objeto.somador(resp)); } } // --------------------------------------------------------------------------------------------------------------------------- Classe Base: base.java package progheranca2; public class Base { protected int x, y; // atributos protegidos public void setAtributos(int a, int b) { x = a; y = b; System.out.println("x = " + x); System.out.println("y = " + y); } public int soma() { System.out.println("Soma (x + y): " + (x + y)); return(x + y); } } // -------------------------------------------------------------------------------------------------------------------- Classe Derivada: Derivada.java package progheranca2; 48 public class Derivada extends Base { private int z; Derivada(int x) { z = x; System.out.println("z = " + z); } public int somador(int soma) { return(x + y + z); } // é possível acessar x e y pois são protegidos na classe base } Resultado do Programa: z=3 x=1 y=2 Soma (x + y): 3 Somador (x + y + z): 6 O comando super faz uma chamada formal ao construtor padrão da classe-pai. A seguir, o programa exemplo mostra a utilização do comando super. // -------------------------------------------------------------------------------------------------------------------- Classe Derivada: Derivada.java package progheranca3; public class Derivada extends Base { private int z; Derivada(int x) { super(10, 20); // chamada formal ao construtor da classe pai //super(); z = x; System.out.println("z = " + z); } public int somador(int soma) { return(x + y + z); // é possível acessar x e y pois são privados a classe base } protected void finalize() { // chamada do destrutor formal da classe System.out.println("Derivada: Final"); } } // ---------------------------------------------------------------------------------------------------------------------------- Classe Base: Base.java /* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------A palavra-chave super permite acesso ao construtor da superclasse (base). Note que se não houver, no construtor da subclasse, nenhuma chamada explicita ao construtor da superclasse, o construtor sem argumento é chamado por default. Se for incluída uma chamada ao construtor da superclasse, ela deve ser o primeiro comando executado no construtor da subclasse. --------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ package progheranca3; public class Base { protected int x, y; Base() { this.x = 0; this.y = 0; // atributos protegidos // construtor default 49 System.out.println("x = " + this.x + " - y = " + this.y); } Base(int a, int b) { // construtor sobrecarregado this.x = a; this.y = b; System.out.println("x = " + this.x + " - y = " + this.y); } public void setAtributos(int a, int b) { x = a; y = b; System.out.println("x = " + x); System.out.println("y = " + y); } protected int soma() { System.out.println("Soma (x + y): " + (x + y)); return(x + y); } } // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca3.java package progheranca3; public class ProgHeranca3 { public static void main(String[] args) { Derivada objeto = new Derivada(3); int resp; objeto.setAtributos(1, 2); resp = objeto.soma(); System.out.println("Somador (x + y + z): " + objeto.somador(resp)); } } Resultado do Programa: x = 10 - y = 20 z=3 x=1 y=2 Soma (x + y): 3 Somador (x + y + z): 6 3.4 Lista de exercícios: Herança 3.4.1 Herança (primeiro) Dado os seguintes códigos em Java: // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaHeranca.java package progtestaheranca; public class ProgTestaHeranca { public static void main(String[] args) { Cliente cliente = new Cliente("Paulo Roberto", "123.456.789-09", 1234.56); cliente.imprimePessoa(); cliente.imprimeCliente(); } 50 } // -------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package progtestaheranca; public class Pessoa { protected String nome; protected String cpf; Pessoa() { this.nome = "xxxx"; this.cpf = "xxx.xxx.xxx-xx"; } Pessoa(String nome, String cpf) { this.nome = nome; this.cpf = cpf; } public void imprimePessoa() { System.out.println("Nome: " + nome); System.out.println("CPF: " + cpf); } } // ------------------------------------------------------------------------------------------------------------------------------- Classe: Cliente.java package progtestaheranca; public class Cliente extends Pessoa { private double conta; Cliente(String nome, String cpf, double conta) { this.conta = conta; } public void imprimeCliente() { System.out.println("Conta: " + conta); } } Resultado esperado do programa: Nome: Paulo Roberto CPF: 123.456.789-09 Conta: 1234.56 Resultado real do programa: Nome: xxxx CPF: xxx.xxx.xxx-xx Conta: 1234.56 Que modificações devem ser feitas no código fonte para que o resultado do programa seja o esperado? 3.4.2 Herança (segundo) 51 Dado a classe base “Pessoa” e o programa principal “TestaHomem” (nada deve ser alterado nestas duas classes), construa as classes derivadas “Homem” e “Mulher” que contenha os atributos e métodos abaixo descritos: // -------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package progtestahomem; public class Pessoa { protected double altura; protected char sexo; Pessoa() { this.altura = 0.0; this.sexo = 'g'; } Pessoa(double altura, char sexo) { this.altura = altura; this.sexo = sexo; } public void imprimePessoa() { System.out.println("Altura: " + altura); System.out.println("Sexo: " + sexo); } } Pessoa double altura char sexo imprimePessoa Classe base (superclasse) Homem double pesoIdealHomem calculaPesoIdealHomem imprimePesoIdealHomem Classe derivada (subclasse) Mulher double pesoIdealMulher calculaPesoIdealMulher imprimePesoIdealMulher Classe derivada (subclasse) // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestaHomem.java package progtestahomem; public class ProgTestaHomem { public static void main(String[] args) { Homem homem = new Homem(1.64, 'm'); Mulher mulher = new Mulher(1.59, 'f'); homem.calculaPesoIdealHomem(); homem.imprimePessoa(); homem.imprimePesoIdealHomem(); mulher.calculaPesoIdealMulher(); mulher.imprimePessoa(); mulher.imprimePesoIdealMulher(); } } Resultado do Programa: 52 Altura: 1.64 Sexo: m Peso Ideal (Homem): 61,23 Altura: 1.59 Sexo: f Peso Ideal (Mulher): 54,04 3.4.3 Herança (terceiro) Dados os seguintes códigos em Java (que não devem ser alterados de forma alguma): // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestaObjetos.java package progtestaobjetos; public class ProgTestaObjetos { public static void main(String[] args) { Linha linha = new Linha(1, 2, 3, 4); Retangulo retangulo = new Retangulo(1, 2, 3, 4); linha.imprimeLinha("Linha"); retangulo.imprimeRetangulo("Retângulo"); } } // -------------------------------------------------------------------------------------------------------------------------- Classe Base: Ponto.java package progtestaobjetos; public class Ponto { protected int x; protected int y; Ponto() { x = 0; y = 0; } Ponto(int x, int y) { this.x = x; this.y = y; } public void imprimePonto() { System.out.println("x = " + x + " - y = " + y); } } // ----------------------------------------------------------------------------------------------------------------------- Classe Derivada: Linha.java package progtestaobjetos; public class Linha extends Ponto { private final Ponto p1; private final Ponto p2; Linha (int xi, int yi, int xf, int yf) { p1 = new Ponto(xi, yi); p2 = new Ponto(xf, yf); } public void imprimeLinha() { p1.imprimePonto("p1"); p2.imprimePonto("p2"); } } 53 Implemente a classe derivada “Retangulo” (Figura 3) para que o programa funcione conforme o resultado do programa abaixo: Resultado do Programa: Linha: x=1-y=2 x=3-y=4 Retângulo: x=1-y=2 x=3-y=2 x=3-y=4 x=1-y=4 Figura 3: Objetos gráficos: Linha e Retângulo 54 4. Métodos de entrada e saída de dados A seguir, são mostrados basicamente três (3) métodos (maneiras/formas) que permitem fazer entrada de dados via teclado e saída de dados via monitor (tela) em Java. 4.1 Entrada de dados via teclado Scanner: A seguir é visto um programa exemplo onde a entrada de dados utilizando a classe Scanner e seus métodos. Programa exemplo: Mostra a entrada de dados, via teclado, em terminal de texto, utilizando a classe Scanner e alguns de seus métodos. // -------------------------------------------------------------------------------------------------------------- Programa Principal: ProgScanner.java package progscanner; import java.util.Scanner; public class ProgScanner { public static void main(String[] args) { Scanner input = new Scanner (System.in); System.out.print("Inteiro: "); String s = input.nextLine(); Integer x = Integer.parseInt(s); System.out.println("Valor: " + x); // lê uma string via teclado // converte a String para inteiro } } Exemplo para testar o programa: Inteiro: 7 <enter> Valor: 7 A seguir, o programa exemplo, mostra como fazer a leitura de int, float, double ou byte via teclado. // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgEntradaDados.java package progentradadados; import java.util.Scanner; public class ProgEntradaDados { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("Digite um Inteiro: "); Integer inteiro = input.nextInt(); System.out.println("INTEIRO: " + inteiro + " -> SizeOf: " + sizeOf(inteiro) + " Byte(s)"); System.out.print("Digite um Float: "); Float numFloat = input.nextFloat(); System.out.println("FLOAT: " + numFloat + " -> SizeOf: " + sizeOf(numFloat) + " Byte(s)"); System.out.print("Digite um Double: "); Double numDouble = input.nextDouble(); 55 System.out.println("DOUBLE: " + numDouble + " -> SizeOf: " + sizeOf(numDouble) + " Byte(s)"); System.out.print("Digite um Byte: "); Byte numByte = input.nextByte(); System.out.println("BYTE: " + numByte + " -> SizeOf: " + sizeOf(numByte) + " Byte(s)"); } // ------------------------------------------------ métodos estáticos sobrecarregados public static int sizeOf(Boolean b) { return(1); } public static int sizeOf(Byte b) { return(1); } public static int sizeOf(Character c) { return(2); } public static int sizeOf(Short s) { return(2); } public static int sizeOf(Integer i) { return(4); } public static int sizeOf(Long l) { return(8); } public static int sizeOf(Float f) { return(4); } public static int sizeOf(Double d) { return(8); } } Exemplo para testar o programa: Digite um Inteiro: 123 <enter> INTEIRO: 123 -> SizeOf: 4 Byte(s) Digite um Float: 123,45 <enter> FLOAT: 123.45 -> SizeOf: 4 Byte(s) Digite um Double: 123,45 <enter> DOUBLE: 123.45 -> SizeOf: 8 Byte(s) Digite um Byte: 123 <enter> BYTE: 123 -> SizeOf: 1 Byte(s) Swing: A seguir, é visto um programa exemplo de entrada de dados utilizando a classe swing e seus métodos. Programa exemplo: A entrada de dados, via teclado, é feita em caixa de diálogo gráfica sobreposta a interface utilizando a classe swing e alguns dos seus métodos. // -------------------------------------------------------------------------------------------------------------- Programa Principal: ProgSwing.java package progswing; import javax.swing.*; // carrega toda o pacote swing public class ProgSwing { public static void main(String[] args) { 56 String s = JOptionPane.showInputDialog("Digite um Número: "); int x = Integer.parseInt(s); JOptionPane.showMessageDialog(null, "Inteiro: " + x, "Resultado", JOptionPane.PLAIN_MESSAGE); // JOptionPane.showMessageDialog(null, "Inteiro: " + x); // funciona também, pois os dois últimos argumentos podem ser suprimidos } } BufferReader e InputStreamReader: A seguir é visto um programa exemplo de entrada de dados utilizando o pacote “java.io” com as classes BufferReader e InputStreamReader e seus métodos. Programa exemplo: Entrada de dados via teclado em terminal de texto utilizando as bibliotecas BufferedReader e InputStreamReader e alguns dos seus métodos mais importantes. // ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgBuffer.java package progbuffer; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class ProgBuffer { public static void main(String[] args) throws IOException { BufferedReader userInput = new BufferedReader (new InputStreamReader(System.in)); System.out.print("Nome: "); String nome = userInput.readLine(); Integer n = nome.length(); System.out.println("Nome: " + nome + " tem " + nome.length() + " caracteres"); } } Resultado do Programa: Nome: Paulo Roberto <enter> Nome: Paulo Roberto tem 13 caracteres Observação: O programa, a seguir, serve para o pessoal que vai para a Maratona de Programação e precisa ler vários dados em apenas uma linha. // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgBufferReader.java package progbufferreader; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; public class ProgBufferReader { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out)); String text = in.readLine(); String [] partes = text.split(" "); int n = partes.length; 57 for (int i = 0;i < n;i++) { int t = Integer.parseInt(partes[i]); out.write("Valor: " + t); out.newLine(); out.flush(); } } } Entrada: 10 20 30 <enter> Saída: Valor: 10 Valor: 20 Valor: 30 4.2 Saída de dados via tela A seguir é visto um programa exemplo de saída de dados na tela utilizando o método System.out.print. Programa exemplo: Mostrando a saída de dados, via tela, utilizando os métodos System.out.print, System.out.println ou System.out.printf. // ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPrint.java package progprint; import java.util.Scanner; public class ProgPrint { public static void main(String[] args) { Scanner entrada = new Scanner (System.in); String s; int x; System.out.print("Inteiro: "); s = entrada.nextLine(); x = Integer.parseInt(s); System.out.println("Valor: " + x); System.out.printf("Valor: %03d\n ", x); } } Entrada: Inteiro: 16 <enter> Saída: Valor: 16 Valor: 016 A seguir é visto um exemplo de saída de dados na tela utilizando a classe swing e seus principais métodos. Programa exemplo: Mostra a saída de dados, via tela, em caixa de diálogo gráfica sobreposta a interface usando a classe swing e alguns dos seus métodos. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgSwingSaida.java package progswingsaida; import javax.swing.*; // carrega toda a biblioteca swing 58 public class ProgSwingSaida { public static void main(String[] args) { String s; s = JOptionPane.showInputDialog("Digite um Número: "); int x = Integer.parseInt(s); JOptionPane.showMessageDialog(null, "Inteiro: " + x, "Resultado", JOptionPane.PLAIN_MESSAGE); } } Sintaxe: JOptionPane.showMessageDialog(null, “x = ” + x, “Título”, JOptionPane.PLAIN_MESSAGE); null significa que a mensagem será centralizada “x = “ + x significa que sairá na caixa de dialogo x = 5 (por exemplo) “Título” significa o título da caixa de diálogo JOptionPane.PLAIN_MESSAGE significa caixa sem ícone Tabela 1: Tipos de Ícones Tipo de Ícone Ícone de erro Ícone de informação “i” Ícone de advertência “!” Ícone de pergunta “?” Sem ícone Tipo de Mensagem JOptionPane.ERROR_MESSAGE JOptionPane.INFORMATION_MESSAGE JOptionPane.WARNING_MESSAGE JOptionPane.QUESTION_MESSAGE JOptionPane.PLAIN_MESSAGE 4.3 Saída formatada (System.out.printf) Como na linguagem de programação C, as saídas (impressões) na tela podem ser formatadas em Java utizando-se o método “System.out.printf”. Sintaxe: System.out.printf ("string de controle", lista de variáveis); String de controle: Formada pelos caracteres que o método imprime na tela, e pelos comandos de formatação (%c, %s, %d, %f) que definem a maneira como as variáveis serão impressas e caracteres especiais (\n, \t, ...). Tabela 2: Comandos de formatação Código %s %d %i %o %u %x %X %f %e %g %E %G %c %% Tipo String int int int int int int float float float float float char nada Formato String (vetor de caracteres) Inteiro decimal com sinal Inteiro decimal com sinal Inteiro octal sem sinal Inteiro decimal sem sinal Inteiro hexadecimal sem sinal (com a, b, c, d, e, f) Inteiro hexadecimal sem sinal (com A, B, C, D, E, F) Valor com sinal da forma [-]dddd.dddd Valor com sinal da forma [-]d.dddd e [+/-]ddd Valor com sinal na forma e ou f baseado na precisão do valor dado Mesmo que e, mas com E para expoente Mesmo que g, mas com E para expoente Um caracter O caracter % é impresso Flags (Bandeiras): (-) Alinha o resultado à esquerda. Preenche o restante do campo com brancos. Se não é colocado, alinha o resultado à direita e preenche o restante à esquerda com zeros ou brancos. 59 (+) O resultado sempre começa com o sinal + ou (#) Especifica que o argumento será impresso usando uma das formas alternativas Formas alternativas: 0 x ou X É colocado zeros (0) antes do argumento É colocado 0x (ou 0X) antes do argumento 60 Especificadores de largura do campo a ser impresso (exemplos): Tabela 3: Especificadores de largura do campo Prefixo %-+#0 %-+# %-+0 %-+ %-#0 %-# %-0 %%+#0 %+# %+0 %+ %#0 %# %0 % 6d +00555 +555 +00555 +555 000555 555 000555 555 +00555 +555 +00555 +555 000555 555 000555 555 6o 01053 01053 01053 1053 001053 01053 01053 1053 01053 01053 01053 1053 001053 01053 001053 1053 8x 0x0022b 0x22b 000022b 22b 0x00022b 0x22b 0000022b 22b 0x0022b 0x22b 000022b 22b 0x00022b 0x22b 0000022b 22b 10.2e +5.50e+000 +5.50e+000 +5.50e+000 +5.50e+000 05.50e+000 5.50e+000 05.50e+000 5.50e+000 +5.50e+000 +5.50e+000 +5.50e+000 +5.50e+000 05.50e+000 5.50e+000 05.50e+000 5.50e+000 10.2f +000005.50 +5.50 +000005.50 +5.50 0000005.50 5.50 0000005.50 5.50 +000005.50 +5.50 +000005.50 +5.50 0000005.50 5.50 0000005.50 5.50 4.4 Lista de Exercícios: Métodos de Entrada e Saída 4.4.1 Escreva um programa em Java que lê “n” valores inteiros (todos na mesma linha separados por um espaço em branco + <enter>). Imprima a quantidade de valores digitados, a média dos valores, o maior e o menor valor (conforme exemplo abaixo). Entrada: 10 20 30 40 50 60 70 80 90 <enter> Saída: Quantidade de Valores Digitados: 9 Média: 50.0 Maior: 90 Menor: 10 4.4.2 Escreva um programa em Java que recebe via teclado: número de elementos e os “n” elementos inteiros. O programa deve ordenar e imprimir na tela os valores em ordem crescente (conforme exemplos abaixo). Entrada: 7 <enter> 70 20 60 40 50 10 30 <enter> Saída: 10 20 30 40 50 60 70 Entrada: 7 <enter> 20 40 60 <enter> Saída: Erro na Entrada dos valores ou 61 5. Interfaces e Containers (Classes existentes em Java) Java possui diversas classes pré-existentes chamadas container. Um container ou coleção é simplesmente uma classe que agrupa múltiplos elementos em uma única unidade. As coleções são utilizadas para armazenar, recuperar e manipular dados agregados. A seguir pode-se ver algumas classes, coleções ou implementações existentes em Java (Tabela 4): Tabela 4: Lista de Container Container Descrição Array DList SList HashMap OrderedMap HashSet OrderedSet PriorityQueue Queue Stack Deque Array expansível Lista Duplamente Encadeada Lista Encadeada Simples fast associative container associative container fast set or multiset set or multiset array-based heap Fila (Interface) Pilha Fila Dupla (duas entradas e duas saídas) 5.1 Coleções (Collection FrameWork) Pacote: import java.util.*; Uma coleção é uma classe que representa um grupo de classes. Uma Collection Framework é uma arquitetura para representar e manipular coleções independentes dos detalhes de sua implementação. Uma coleção é composta de Interfaces e Implementações. 5.2 Interfaces Uma interface é uma especificação de uma classe, ou seja, é um modelo para classes desta interface. Cada classe de uma interface implementa os métodos de uma forma diferente do modelo da interface. 62 Interfaces e suas Implementações (apenas as principais implementações) Sets (Conjuntos): Não aceitam valores repetidos, ou seja, os valores armazenados no conjunto são únicos: o HashSet: É o mais rápido, usando uma HashTable, onde seus elementos não são ordenados; o LinkedHashSet: Os elementos continuam na ordem que são inseridos; o TreeSet: Implementa um algoritmo conhecido por red-black tree, ou seja, uma árvore rubronegra. Lists (Listas): o Vector: Classe obsoleta que implementa um vetor dinâmico, ou seja, não é necessário especificar o tamanho do vetor (usa uma lista encadeada simples); o Stack: Implementa uma pilha dinâmica; o LinkedList: Implementa uma lista encadeada simples, ou seja, uma lista dinâmica; o ArrayList: Implementa um vetor dinâmico, ou seja, não é necessário especificar o tamanho do vetor (usa uma lista encadeada simples). Queue (Filas): Implementa uma fila dinâmica através de uma lista encadeada simples. o LinkedList: Lista encadeada simples. Maps (Mapas): Contém chaves + valores, onde cada valor tem uma chave atrelada a ele. o HashTable: Mapa em ordem ascendente; o HashMap: Mapa em ordem ascendente; o LinkedHashMap: Mapa em ordem de inclusão; o TreeMap: Mapa em ordem ascendente. A seguir são descritos alguns destes elementos: 5.3 Vector (Vetor) (Classe Obsoleta) import java.util.Vector; A classe Vector é utilizada para armazenar elementos em uma estrutura similar a um vetor. Esta classe permite armazenar elementos dinamicamente, ou seja, uma lista de elementos sem limite de tamanho pré-definido. O único tamanho a ser respeitado é a área de memória livre na memória RAM. A seguir são descritos os principais métodos da classe Vector. Sintaxe: void add(int posição, Object objeto); Insere o objeto na posição do Vetor. Sintaxe: boolean add(Object objeto); Anexa o objeto no final do Vetor. Sintaxe: boolean addAll(Collection coleção); Anexa todos os elementos da coleção no final do Vetor, na ordem que eles são retornados pelo iterador da coleção. 63 Sintaxe: boolean addAll(int posição, Collection coleção); Insere todos os elementos na coleção no Vetor na posição. Sintaxe: void addElement(Object objeto); Adiciona o objeto no fim do Vetor, aumentando seu tamanho em um. Sintaxe: int capacity(); Retorna a capacidade corrente do Vetor. Sintaxe: void clear(); Remove todos os elementos do Vetor. Sintaxe: Object clone(); Retorna uma cópia do Vetor. Sintaxe: boolean contains(Object objeto); Testa se um objeto é um componente do Vetor. Sintaxe: boolean containsAll(Collection coleção); Retorna true se o Vetor contém todos os elementos da coleção. Sintaxe: void copyInto(Object[] array); Copia os componentes do Vetor para o array. Sintaxe: Object elementAt(int posição); Retorna o componente armazenado na posição. Sintaxe: Enumeration elements(); Retorna uma enumeração dos componentes do Vetor. Sintaxe: void ensureCapacity(int capacidadeMinima); Aumenta a capacidade do Vetor para armazenar o número de componentes dado pelo argumento capacidadeMinima. Sintaxe: boolean equals(Object objeto); Compara (igualdade) o objeto com os elementos do Vetor. Sintaxe: Object firstElement(); Retorna o primeiro elemento (item de posição 0) do Vetor. Sintaxe: Object get(int posicao); Retorna o elemento armazenado na posição do Vetor. Sintaxe: int hashCode(); Retorna o código hash do Vetor. Sintaxe: int indexOf(Object objeto); Procura e retorna a posição da primeira ocorrência de um elemento, testando a igualdade pelo método “equals”. Retorna -1 se não houver o objeto. Sintaxe: int indexOf(Object objeto, int posicao); Procura e retorna a posição da primeira ocorrência do objeto, começando a busca pela posição, e testando pela igualdade usando o método “equals”. Sintaxe: void insertElementAt(Object objeto, int posicao); Insere o objeto como um componente no Vetor na posição. Sintaxe: boolean isEmpty(); Testa se o Vetor não tem componentes, ou seja, se está vazia (true) ou não (false). Sintaxe: Object lastElement(); Retorna o último componente do Vetor. Sintaxe: int lastIndexOf(Object objeto); Retorna a posição da última ocorrência do objeto no Vetor. Sintaxe: int lastIndexOf(Object objeto, int posição); Retorna a posição da última ocorrência do objeto no Vetor, começando na posição. 64 Sintaxe: Object remove(int posição); Remove o elemento da posição no Vetor. Sintaxe: boolean remove(Object objeto); Remove a primeira ocorrência do objeto no Vetor, se o Vetor não contém o elemento, ele não é alterado. Sintaxe: boolean removeAll(Collection coleção); Remove do Vetor todos os elementos que contém a coleção. Sintaxe: void removeAllElements(); Remove todos os elementos do Vetor e seta o tamanho em zero. Sintaxe: boolean removeElement(Object objeto); Remove a primeira ocorrência do objeto do Vetor. Sintaxe: void removeElementAt(int posição); Deleta o elemento na posição. Sintaxe:protected void removeRange(int fromIndex, int toIndex); Remove da lista todos os elementos escolhidos entre o “fromIndex” (inclusive) e “toIndex” (exclusive). Sintaxe: boolean retainAll(Collection coleção); Mantém somente os elementos do Vetor que contém a coleção. Sintaxe: Object set(int posição, Object objeto); Troca o elemento da posição do Vetor com o elemento. Sintaxe: void setElementAt(Object objeto, int posição); Seta o objeto na posição do Vetor pelo objeto especificado. Sintaxe: void setSize(int newSize); Seta o tamanho do Vetor. Sintaxe: int size(); Retorna o número de elementos do Vetor. Sintaxe: List subList(int fromIndex, int toIndex); Retorna uma lista da porção da Lista entre “fromIndex” (inclusive) e “toIndex” (exclusive). Sintaxe: Object[] toArray(); Retorna um array contendo todos os elementos no Vetor. Sintaxe: Object[] toArray(Object[] objeto); Retorna um array contendo todos os elementos no Vetor. Sintaxe: String toString(); Retorna uma string do Vetor, contendo uma representação de cada elemento. Sintaxe: void trimToSize(); Ajusta a capacidade do Vetor para a atual dimensão do Vetor. Programa Exemplo: Mostra a utilização de vetor utilizando a classe Vector e alguns dos seus métodos. // ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgVector.java package progvector; import java.util.Scanner; import java.util.Vector; public class ProgVector { public static void main(String[] args) { Vector vetor = new Vector(); Scanner input = new Scanner(System.in); int u = -1, nodo; 65 do { u++; System.out.print("Nodo: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { vetor.add(nodo); // vetor.add(u, nodo); onde “u” é o último elemento } } while (nodo != 0); int n = vetor.size(); for (int i = 0; i < n;i++) { System.out.println("Elemento: " + vetor.get(i) + " "); } System.out.println("Número de Elementos: " + n); System.out.println("Vector: " + vetor); } } Exemplo para testar o programa: Nodo: 10 <enter> Nodo: 20 <enter> Nodo: 30 <enter> Nodo: 40 <enter> Nodo: 50 <enter> Nodo: 60 <enter> Nodo: 0 <enter> Elemento: 10 Elemento: 20 Elemento: 30 Elemento: 40 Elemento: 50 Elemento: 60 Número de Elementos: 6 Vector: [10, 20, 30, 40, 50, 60] Programa Exemplo: Mostra um vetor utilizando a classe Vector, inserindo em uma determinada posição escolhida pelo usuário (note que os elementos tem que ser inseridos numa ordem crescente de “0” … “n”, sem pular nenhuma posição). // --------------------------------------------------------------------------------------------------------------- Programa Principal: ProgVector2.java package progvector2; import java.util.Scanner; import java.util.Vector; public class ProgVector2 { public static void main(String[] args) { Vector vetor = new Vector(); Scanner input = new Scanner(System.in); int nodo, pos; do { System.out.print("Nodo: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { System.out.print("Posição: "); s = input.nextLine(); pos = Integer.parseInt(s); if (pos >= 0 && pos <= vetor.size()) { vetor.add(pos, nodo); } 66 else { System.out.println("ERRO: Posição Inválida "); } } exibeVector(vetor); } while (nodo != 0); int n = vetor.size(); for (int i = 0; i < n;i++) { System.out.println("Elemento: "+ vetor.get(i) + " "); } System.out.println("Número de Elementos: " + n); System.out.println("Vector: " + vetor); } // ------------------------------------------------------- exibeVector static void exibeVector(Vector vetor) { System.out.printf("Indice: "); for (int i = 0;i < vetor.size();i++) { System.out.printf("%2d ", i); } System.out.println(); System.out.print(" Vetor: "); for (Object i : vetor) { System.out.printf("%2d ", i); } System.out.println(); } } Exemplo para testar o programa: Nodo: 10 <enter> Posição: 0 <enter> Indice: 0 Vetor: 10 Nodo: 20 <enter> Posição: 1 <enter> Indice: 0 1 Vetor: 10 20 Nodo: 30 <enter> Posição: 2 <enter> Indice: 0 1 2 Vetor: 10 20 30 Nodo: 40 <enter> Posição: 6 <enter> ERRO: Posição Inválida Indice: 0 1 2 Vetor: 10 20 30 Nodo: 0 <enter> Indice: 0 1 2 Vetor: 10 20 30 Elemento: 10 Elemento: 20 Elemento: 30 Número de Elementos: 3 Vector: [10, 20, 30] 5.4 LinkedList (Lista Encadeada Simples) import java.util.LinkedList; A lista LinkedList é utilizada para armazenar elementos em uma lista encadeada simples (Figura 4), ou seja, lista alocada dinamicamente, onde a lista cresce enquanto houver memória livre. 67 Figura 4: LinkedList - Lista Encadeada Simples A seguir são descritos os principais métodos de uma LinkedList. Sintaxe: void add (int posição, Object objeto); Insere o objeto na posição da lista. Sintaxe: boolean add (Objetc objeto); Anexa o objeto no final da lista. Sintaxe: boolean addAll (Collection coleção); Anexa todos os elementos da coleção no final da lista, na ordem que eles são retornados do iterador da coleção. Sintaxe: boolean addAll (int posição, Collection coleção); Insere todos os elementos da coleção dentro da lista, começando na posição. Sintaxe: void addFirst (Object objeto); Insere o objeto no começo da lista. Sintaxe: void addLast (Object objeto); Anexa o objeto no final da lista. Sintaxe: void clear (); Remove todos os elementos da lista. Sintaxe: Object clone (); Retorna uma cópia da lista. Sintaxe: boolean contains (Object objeto); Retorna verdadeiro (true) se a lista contém o objeto. Sintaxe: Object get (int posição); Retorna o objeto da posição na lista. Sintaxe: Object getFirst (); Retorna o primeiro objeto da lista. Sintaxe: Object getLast (); Retorna o último objeto da lista. Sintaxe: int indexOf (Object objeto); Retorna a posição do objeto na lista ou (-1) se a lista não contém este objeto. Sintaxe: int lastIndexOf (Object objeto); Retorna a última posição do objeto na lista ou (-1) se a lista não contém este objeto. 68 Sintaxe: ListIterator listIterator (int posição); Retorna um iterador da lista dos elementos da lista, começando na posição na lista. Sintaxe: Object remove (int posição); Remove o objeto da posição na lista. Sintaxe: boolean remove (Object objeto); Remove a primeira ocorrência do objeto na lista. Sintaxe: Object removeFirst (); Remove e retorna o primeiro objeto da lista. Sintaxe: Object removeLast (); Remove e retorna o último objeto da lista. Sintaxe: Object set (int posição, Object objeto); Troca o objeto da posição na lista pelo o objeto especificado. Sintaxe: int size (); Retorna o número de elementos na lista. Sintaxe: Object [] toArray (); Retorna um “array” (vetor) contendo todos os elementos da lista. Sintaxe: Object [] toArray (Object [] objeto); Retorna um “array” (vetor) contendo todos os objetos da lista. Programa Exemplo: Mostra uma LinkedList e alguns de seus métodos inserindo inteiros. // ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedList.java package proglinkedlist; import java.util.LinkedList; import java.util.Scanner; public class ProgLinkedList { public static void main(String[] args) { LinkedList lista = new LinkedList(); Scanner input = new Scanner(System.in); int valor; char op; do { exibeLista(lista); System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { do { System.out.print("[F]irst, [L]ast ou [A]dd: "); s = input.nextLine(); op = s.charAt(0); } while ("FfLlAa".indexOf(op) == -1); switch (op) { case 'F': case 'f': lista.addFirst(valor); break; case 'L': case 'l': lista.addLast(valor); break; case 'A': case 'a': lista.add(valor); break; } } 69 } while (valor != 0); exibeLista(lista); } // ---------------------------------------------------------------------- exibeLista public static void exibeLista(LinkedList lista) { int n = lista.size(); System.out.print("LinkedList: ["); for (int i = 0;i < n;i++) { System.out.print(lista.get(i) + " "); } System.out.println("]"); } } Exemplo para testar o programa: LinkedList: [] Valor: 10 <enter> [F]irst, [L]ast ou [A]dd: f <enter> LinkedList: [10 ] Valor: 20 <enter> [F]irst, [L]ast ou [A]dd: l <enter> LinkedList: [10 20 ] Valor: 30 <enter> [F]irst, [L]ast ou [A]dd: a <enter> LinkedList: [10 20 30 ] Valor: 0 <enter> LinkedList: [10 20 30 ] Programa Exemplo: Mostra uma LinkedList e alguns dos seus métodos inserindo inteiros e ordenando-os. // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedList2.java package proglinkedlist2; import java.util.Arrays; import java.util.LinkedList; public class ProgLinkedList2 { public static void main(String[] args) { LinkedList lista = new LinkedList(); lista.add(40); lista.add(20); lista.add(60); lista.add(10); lista.add(30); lista.add(50); Object[] listaOrdenada = lista.toArray(); Arrays.sort(listaOrdenada); System.out.print("LinkedList Ordenada: ["); for (Object i : listaOrdenada) { System.out.print(i + " "); } System.out.printf("\b\b]\n"); // olhe a explicação abaixo } } Resultado do Programa: LinkedList Ordenada: [10, 20, 30, 40, 50, 60] 70 Observação: O comando for acima é chamado de foreach. A sintaxe é descrita abaixo: Foreach (para cada … ) Sintaxe: for (Tipo_dado variávelControle : coleção ) { System.out.println(variávelControle); } Diferenças entre Classe e Interface Uma interface em Java é uma classe abstrata onde todos os métodos são abstratos (abstract) e públicos (public), e todos os atributos são estáticos (static) e constantes tipadas (final). Ela é semelhante a especificação de uma classe abstrata pura, com uma diferença: os métodos das classes abstratas podem ou não ser implementados nas classes que a estendem, já os métodos das interfaces tem que ser obrigatoriamente implementados nas classes que as implementam. Uma interface permite estabelecer uma padronização que deve ser obedecida pela classe que a implementa. Quando uma classe implementa uma interface, ela deve garantir que todas as funcionalidades especificadas pela interface estarão presentes na classe. A sintaxe da declaração de uma interface é parecida na definição de classes, porém seu corpo define apenas as assinaturas dos métodos e constantes contidos na interface. 71 5.5 Arrays (array) import java.util.Arrays; A classe Arrays pode ser utilizada em variáveis do tipo vetor e permite “copiar”, “ordenar”, “buscar” e “manipular” vetores. Note que não se declara vetores do tipo Arrays. Programa Exemplo: Demonstra a utilização da classe Arrays e alguns de seus métodos. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgArraysTeste.java package progarraysteste; import java.util.Arrays; public class ProgArraysTeste { public static void main(String[] args) { int[] vetor = {60, 30, 50, 20, 40, 10}; System.out.println("Número de Elementos do Vetor: " + vetor.length); System.out.println("Vetor Original: " + Arrays.toString(vetor)); Arrays.sort(vetor); System.out.println("Vetor Ordenado: " + Arrays.toString(vetor)); int chaveProcura = 30; int indice = Arrays.binarySearch(vetor, chaveProcura); // vetor deve estar ordenado System.out.println("Chave: " + chaveProcura); System.out.println("Índice do Elemento Chave: " + indice); } } Resultado do Programa: Número de Elementos do Vetor: 6 Vetor Original: [60, 30, 50, 20, 40, 10] Vetor Ordenado: [10, 20, 30, 40, 50, 60] Chave: 30 Índice do Elemento Chave: 2 A seguir são descritos os principais métodos da classe Arrays. Sintaxe: static int binarySearch(byte[] vetor, byte chave); Procura em um vetor de “byte” pela chave utilizando algoritmo de busca binária. Sintaxe: static int binarySearch(char[] vetor, char chave); Procura em um vetor de “char” pela chave utilizando algoritmo de busca binária. Sintaxe: static int binarySearch(double[] vetor, double chave); Procura em um vetor de double pela chave utilizando algoritmo de busca binária. Sintaxe: static int binarySearch(float[] vetor, float chave); Procura em um vetor de float pela chave utilizando algoritmo de busca binária. 72 Sintaxe: static int binarySearch(int[] vetor, int chave); Procura em um vetor de int pela chave utilizando algoritmo de busca binária. Sintaxe: static int binarySearch(long[] vetor, long chave); Procura em um vetor de long pela chave utilizando algoritmo de busca binária. Sintaxe: static int binarySearch(Object[] vetor, Object chave); Procura em um vetor de Object pela chave utilizando algoritmo de busca binária. Sintaxe: static int binarySearch(short[] vetor, short chave); Procura em um vetor de short pela chave utilizando algoritmo de busca binária. Sintaxe: static boolean deepEquals(Object[] obj1, Object[] obj2); Retorna true se os dois arrays de objetos são iguais. Sintaxe: static int deepHashCode(Object[] objeto); Retorna o código hash baseado na localização do array de objetos. Sintaxe: static String deepToString(Object[] objeto); Retorna em forma de string a localização do array de objetos. Sintaxe: static boolean equals(boolean[] vetor1, boolean[] vetor2); Retorna true se os dois arrays de boolean são iguais. Sintaxe: static boolean equals(byte[] vetor1, byte[] vetor2); Retorna true se os dois arrays de byte são iguais. Sintaxe: static boolean equals(char[] vetor1, char[] vetor2); Retorna true se os dois arrays de char são iguais. Sintaxe: static boolean equals(double[] vetor1, double[] vetor2); Retorna true se os dois arrays de double são iguais. Sintaxe: static boolean equals(float[] vetor1, float[] vetor2); Retorna true se os dois arrays de float são iguais. Sintaxe: static boolean equals(int[] vetor1, int[] vetor2); Retorna true se os dois arrays de int são iguais. Sintaxe: static boolean equals(long[] vetor1, long[] vetor2); Retorna true se os dois arrays de long são iguais. Sintaxe: static boolean equals(Object[] vetor1, Object[] vetor2); Retorna true se os dois arrays de Object são iguais. Sintaxe: static boolean equals(short[] vetor1, short[] vetor2); Retorna true se os dois arrays de short são iguais. Sintaxe: static void fill(boolean[] vetor, boolean valor); Atribui um valor booleano para cada elemento do vetor de booleanos. Sintaxe: static void fill(boolean[] vetor, int fromIndex, int toIndex, boolean valor); Atribui um valor booleano para cada elemento da faixa do vetor de booleanos. Sintaxe: static void fill(byte[] vetor, byte valor); Atribui um valor byte para cada elemento do vetor de bytes. Sintaxe: static void fill(byte[] vetor, int fromIndex, int toIndex, byte valor); Atribui um valor byte para cada elemento da faixa do vetor de bytes. Sintaxe: static void fill(char[] vetor, char valor); Atribui um valor char para cada elemento do vetor de caracteres. Sintaxe: static void fill(char[] vetor, int fromIndex, int toIndex, char valor); Atribui um valor char para cada elemento da faixa do vetor de caracteres. Sintaxe: static void fill(double[] vetor, double valor); Atribui um valor double para cada elemento do vetor de double. 73 Sintaxe: static void fill(double[] vetor, int fromIndex, int toIndex, double valor); Atribui um valor double para cada elemento da faixa do vetor de double. Sintaxe: static void fill(float[] vetor, float valor); Atribui um valor float para cada elemento do vetor de float. Sintaxe: static void fill(float[] vetor, int fromIndex, int toIndex, float valor); Atribui um valor float para cada elemento da faixa do vetor de float. Sintaxe: static void fill(int[] vetor, int valor); Atribui um valor int para cada elemento do vetor de inteiros Sintaxe: static void fill(int[] vetor, int fromIndex, int toIndex, int valor); Atribui um valor int para cada elemento da faixa do vetor de inteiros. Sintaxe: static void fill(long[] vetor, int fromIndex, int toIndex, long valor); Atribui um valor long para cada elemento da faixa do vetor de inteiros longos. Sintaxe: static void fill(long[] vetor, long valor); Atribui um valor long para cada elemento do vetor de long. Sintaxe: static void fill(Object[] vetor, int fromIndex, int toIndex, Object valor); Atribui um valor Object para cada elemento da faixa do vetor de objetos. Sintaxe: static void fill(Object[] vetor, Object valor); Atribui um valor Object para cada elemento do vetor de Object. Sintaxe: static void fill(short[] vetor, int fromIndex, int toIndex, short valor); Atribui um valor short para cada elemento da faixa do vetor de inteiros curtos. Sintaxe: static void fill(short[] vetor, short val); Atribui um valor short para cada elemento do vetor de inteiros curtos. Sintaxe: static int hashCode(boolean[] vetor); Retorna o código hash com base no conteúdo do vetor de booleanos. Sintaxe: static int hashCode(byte[] vetor); Retorna o código hash com base no conteúdo do vetor de byte. Sintaxe: static int hashCode(char[] vetor); Retorna o código hash com base no conteúdo do vetor de caracteres. Sintaxe: static int hashCode(double[] vetor); Retorna o código hash com base no conteúdo do vetor de double. Sintaxe: static int hashCode(float[] vetor); Retorna o código hash com base no conteúdo do vetor de float. 74 Sintaxe: static int hashCode(int[] vetor); Retorna o código hash com base no conteúdo do vetor de inteiros. Sintaxe: static int hashCode(long[] vetor); Retorna o código hash com base no conteúdo do vetor de inteiros longos. Sintaxe: static int hashCode(Object[] vetor); Retorna o código hash com base no conteúdo do vetor de objetos. Sintaxe: static int hashCode(short[] vetor); Retorna o código hash com base no conteúdo do vetor inteiros curtos. Sintaxe: static void sort(byte[] vetor); Ordena o vetor de byte em ordem ascendente numérica. Sintaxe: static void sort(byte[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de byte em ordem ascendente numérica. Sintaxe: static void sort(char[] vetor); Ordena o vetor de char em ordem ascendente numérica. Sintaxe: static void sort(char[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de char em ordem ascendente numérica. Sintaxe: static void sort(double[] vetor); Ordena o vetor de double em ordem ascendente numérica. Sintaxe: static void sort(double[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de double em ordem ascendente numérica. Sintaxe: static void sort(float[] vetor); Ordena o vetor de float em ordem ascendente numérica. Sintaxe: static void sort(float[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de float em ordem ascendente numérica. Sintaxe: static void sort(int[] vetor); Ordena o vetor de int em ordem ascende numérica. Sintaxe: static void sort(int[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de int em ordem ascendente numérica. Sintaxe: static void sort(long[] vetor); Ordena o vetor de long em ordem ascendente numérica. Sintaxe: static void sort(long[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de long em ordem ascendente numérica. Sintaxe: static void sort(Object[] vetor); Ordena o vetor de Object em ordem ascendente numérica, de acordo com a ordem natural dos elementos. Sintaxe: static void sort(Object[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de Object em ordem ascendente numérica. Sintaxe: static void sort(short[] vetor); Ordena o vetor de short em ordem ascendente numérica. Sintaxe: static void sort(short[] vetor, int fromIndex, int toIndex); Ordena a faixa do vetor de short em ordem ascendente numérica. Sintaxe: static String toString(boolean[] vetor) Retorna uma string com o conteúdo do vetor de boleanos. Sintaxe: static String toString(byte[] vetor); Retorna uma string com o conteúdo do vetor de byte. Sintaxe: static String toString(char[] vetor); Retorna uma string com o conteúdo do vetor de char. 75 Sintaxe: static String toString(double[] vetor); Retorna uma string com o conteúdo do vetor de double. Sintaxe: static String toString(float[] vetor); Retorna uma string com o conteúdo do vetor de float. Sintaxe: static String toString(int[] vetor); Retorna uma string com o conteúdo do vetor de int. Sintaxe: static String toString(long[] vetor); Retorna uma string com o conteúdo do vetor de inteiros longos. Sintaxe: static String toString(Object[] vetor); Retorna uma string com o conteúdo do vetor de objetos. Sintaxe: static String toString(short[] vetor); Retorna uma string com o conteúdo do vetor de inteiros curtos. Programa Exemplo: Utiliza a classe Arrays e alguns métodos que permitem ordenar (sort) e listar um vetor. // ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgArrays.java package progarrays; import java.util.Arrays; import java.util.Scanner; public class ProgArrays { public static void main(String[] args) { final int MAX = 10; int [] vetor = new int[MAX]; Scanner input = new Scanner(System.in); int u = -1, n = 0, valor; do { u++; n++; System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { vetor[u] = valor; } else { u--; } } while (valor != 0 && n < MAX); Arrays.sort(vetor, 0, u); // último elemento // número de elementos // vetor, início, fim String extenso = Arrays.toString(vetor); System.out.println("Array: " + extenso); } } Exemplo para testar o programa: Valor: 10 <enter> Valor: 20 <enter> Valor: 30 <enter> Valor: 40 <enter> Valor: 50 <enter> Valor: 0 <enter> Array: [10, 20, 30, 40, 50, 0, 0, 0, 0, 0] 76 5.6 ArrayList (lista de array) A classe ArrayList possui os mesmos métodos da classe Vector e permite armazenar elementos como se fosse um vetor dinâmico, ou seja, sem limite da quantidade de elementos. Programa Exemplo: Mostra dois arrays que armazenam respectivamente: nomes e idades, note que não há ligação física entre eles, somente uma ligação lógica. // ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgArrayList.java package progarraylist; import java.util.ArrayList; public class ProgArrayList { public static void main(String[] args) { ArrayList <String> nome = new ArrayList <> (); // ArrayList nome = new ArrayList(); // funciona assim também nome.add("Paulo Roberto"); nome.add("Renato Luis"); nome.add("Francisco Carlos"); nome.add("Ana Maria"); nome.add("Julia Helena"); ArrayList <Integer> idade = new ArrayList (); idade.add(48); idade.add(46); idade.add(50); idade.add(53); idade.add(52); int n = nome.size(); for (int i = 0;i < n;i++) { System.out.printf("Nome: %-20s Idade: %d\n", nome.get(i), idade.get(i)); } } } Resultado do Programa: Nome: Paulo Roberto Idade: 48 Nome: Renato Luis Idade: 46 Nome: Francisco Carlos Idade: 50 Nome: Ana Maria Idade: 53 Nome: Julia Helena Idade: 52 Programa Exemplo: Mostra uma forma abreviada de listar um ArrayList, chamada foreach. // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgArrayListView.java package progarraylistview; import java.util.ArrayList; public class ProgArrayListView { public static void main(String[] args) { 77 ArrayList lista = new ArrayList(); lista.add("Ana"); lista.add("Beatriz"); lista.add("Carla"); lista.add("Débora"); for (Object i : lista) { System.out.println(i); } // foreach ... para cada ... } } Resultado do Programa: Ana Beatriz Carla Débora Programa Exemplo: Um vetor utilizando a classe Vector e a classe ArrayList, inserindo inteiros e caracteres. O programa utiliza o método toArray para criar um array de objetos (Object). // -------------------------------------------------------------------------------------------------------------- Programa Principal: ProgtoArray.java package progtoarray; import java.util.ArrayList; import java.util.Vector; public class ProgtoArray { public static void main(String[] args) { ArrayList <Integer> lista = new ArrayList(); lista.add(10); lista.add(30); lista.add(40); lista.add(1, 20); System.out.println("ArrayList: " + lista); Object [] objeto = lista.toArray(); System.out.print("Objetos: "); for(int i = 0;i < lista.size();i++) { System.out.print(objeto[i] + " "); } System.out.println(); Vector vetor = new Vector(); vetor.add('A'); vetor.add('C'); vetor.add('D'); vetor.add(1, 'B'); System.out.println("Vector: " + vetor); Object [] objet = vetor.toArray(); System.out.print("Objetos: "); for(int i = 0;i < vetor.size();i++) { System.out.print(objet[i] + " "); } System.out.println(); } } 78 Resultado do Programa: ArrayList: [10, 20, 30, 40] Objetos: 10 20 30 40 Vector: [A, B, C, D] Objetos: A B C D 5.6.1 Lista de exercícios: Vector, ArrayList e LinkedList 5.6.1.1 Escreva um programa em Java que recebe via teclado um conjunto de letras. Armazene todas as letras em um vetor de letras (Vector ou ArrayList) até que o usuário digite um F ou f. Logo após copie todas as letras (em ordem inversa) para outro vetor (inverso). Ao final imprima os dois vetores. Entrada: Letra: L <enter> Letra: I <enter> Letra: M <enter> Letra: A <enter> Letra: f <enter> Saída: [L, I, M, A] [A, M, I, L] 5.6.1.2 Escreva um programa em Java que recebe via teclado: número de idades e as respectivas idades. Armazene todas as idades em um vetor de idades (Vector ou ArrayList). Logo após a entrada de todas as idades, o programa deve receber via teclado: idade para consulta. O programa deve imprimir na tela, o número de idades antes da idade de consulta e o número de idades depois da idade de consulta. Exemplo para testar o programa: Número de idades: 6 <enter> Idade: 30 <enter> Idade: 60 <enter> Idade: 10 <enter> Idade: 50 <enter> Idade: 20 <enter> Idade: 40 <enter> Idade para consulta: 50 <enter> Antes: 3 Depois: 2 Continua [S/N]? n <enter> 5.6.1.3 Escreva um programa em Java que recebe via teclado um conjunto de números inteiros. Armazene todos os números inteiros em um vetor (Vector ou ArrayList) até que o usuário digite 0 (zero). Logo após permita ao usuário consultar um número informando o seu valor. O programa deve imprimir na tela a posição do número no vetor ou ERRO: Número não encontrado (O programa termina quando o usuário digitar 0 (zero) na entrada) (veja o exemplo abaixo): Exemplo para testar o programa: Número: 50 <enter> Número: 30 <enter> Número: 20 <enter> Número: 10 <enter> Número: 40 <enter> Número: 0 <enter> Valor: 20 <enter> Posição no vetor: 2 Valor: 40 <enter> Posição no vetor: 4 Valor: 60 <enter> ERRO: Número não encontrado Valor: 0 <enter> 79 5.6.1.4 Escreva um programa em Java que recebe via teclado "n" conceitos (A, B, C, D e E) até que o usuário digite F ou f. Armazene todos os conceitos em um vetor de conceitos (Vector ou ArrayList). Imprima na tela o número de alunos: aprovados (A, B e C), reprovados (D) e os infreqüentes (E). Entrada: Conceito: B <enter> Conceito: A <enter> Conceito: E <enter> Conceito: B <enter> Conceito: D <enter> Conceito: C <enter> Conceito: A <enter> Conceito: E <enter> Conceito: f <enter> Saída: 5 Aprovado(s) 1 Reprovado(s) 2 Infreqüente (s) 5.6.1.5 Escreva um programa em Java que recebe via teclado “n” nomes e armazena num vetor de nomes (Vector ou ArrayList). A entrada dos nomes termina quando o usuário digitar apenas <enter>. Logo após a entrada de todos os nomes o programa deve permitir a entrada via teclado de uma letra. O programa deve imprimir na tela todos os nomes que começam com a letra especificada pelo usuário. O programa termina quanto o usuário digitar “” (nada) na entrada da letra (conforme exemplos abaixo): Exemplo para testar o programa: Nome: Paulo <enter> Nome: Roberto <enter> Nome: Renato <enter> Nome: Pedro <enter> Nome: Fabio <enter> Nome: <enter> Letra: R <enter> Nome: Roberto Nome: Renato Letra: P <enter> Nome: Paulo Nome: Pedro Letra: T <enter> Letra: <enter> 5.6.1.6 Escreva um programa em Java que recebe via teclado “n” nomes e idades, armazenando em dois vetores (Vector ou ArrayList). A entrada dos dados termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?". Logo após a entrada de todos os dados o programa deve imprimir na tela todos os nomes e idades desde o mais velho até o mais novo. Entrada: Nome: Ana <enter> Idade: 12 <enter> Continua [S/N]? s <enter> Nome: Beatriz <enter> Idade: 13 <enter> Continua [S/N]? s <enter> Nome: Carla <enter> Idade: 14 <enter> Continua [S/N]? N <enter> Saída: Carla Beatriz Ana 14 13 12 5.6.1.7 Escreva um programa em Java que recebe via teclado “n” nomes armazenando em um vetor de nomes (Vector ou ArrayList). A entrada dos dados termina quando o usuário digitar apenas "enter". Logo após a entrada de todos os dados, o programa deve imprimir na tela todos os nomes em ordem alfabética de ‘A’ à ‘Z’ (conforme exemplo abaixo). 80 Entrada: Nome: Beatriz <enter> Nome: Ana <enter> Nome: Debora <enter> Nome: Carla <enter> Nome: Eva <enter> Nome: Geni <enter> Nome: Fernanda <enter> Nome: <enter> Saída: ArrayList: [Ana, Beatriz, Carla, Debora, Eva, Fernanda, Geni] 5.6.1.8 Escreva um programa em Java que recebe via teclado “n” idades, armazenando-as em um vetor (Vector ou ArrayList) até que o usuário digite ‘0’ (zero). O programa deve então imprimir na tela: (a) as idades em ordem crescente; (b) maior idade; (c) menor idade e (d) a média de idades(conforme exemplo abaixo). Entrada: Idade: 49 <enter> Idade: 51 <enter> Idade: 48 <enter> Idade: 50 <enter> Idade: 0 <enter> Saída: Idades Ordenadas: 48 49 50 51 Maior Idade: 51 Menor Idade: 48 Média de Idades: 49.5 5.6.1.9 Escreva um programa em Java que lê um vetor 5 elementos contendo o gabarito da LOTO. A seguir, ler outro vetor de 10 elementos contendo uma aposta qualquer (exatamente conforme o exemplo abaixo, ou seja, os dados devem estar em duas linhas, um ao lado do outro). A seguir imprima quantos pontos fez o apostador (conforme exemplo abaixo). Os vetores devem ser armazenados em um Vector ou ArrayList Entrada: 4 12 34 25 17 <enter> (gabarito) 3 17 55 21 34 4 27 29 20 11 <enter>(aposta) Saída: 3 ponto(s) 5.6.1.10 Escreva um programa em Java que lê o número de palpites para a megaSena. O programa deve então gerar “n” palpites para o Jogo da MegaSena (sem repetição em cada palpite e ordenados em ordem crescente). O programa deve exibir na tela estes palpites (conforme exemplo abaixo). Entrada: Número de Palpites para a MegaSena: 4 <enter> Saída: Palpite para MegaSena é [4, 22, 43, 55, 93, 99] Palpite para MegaSena é [17, 39, 57, 74, 81, 98] Palpite para MegaSena é [5, 9, 15, 18, 63, 93] Palpite para MegaSena é [14, 20, 42, 48, 80, 88] Observação: Note que cada palpite deve estar armazenado em um Vector ou ArrayList 5.6.1.11 Escreva um programa em Java que armazena “n” números inteiros em uma Lista Encadeada Simples (LinkedList). O programa possui três funções básicas: [I]ncluir, [C]onsultar e [R]emover, todas elas em ambos os lados da lista encadeada: [E]squerda e [D]ireita (conforme exemplo abaixo). 81 Exemplo para testar o programa: [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda ou [D]ireita e <enter> Dado: 10 LinkedList: [10] [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda ou [D]ireita d <enter> Dado: 20 LinkedList: [10, 20] [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda ou [D]ireita d <enter> Dado: 30 LinkedList: [10, 20, 30] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda ou [D]ireita e <enter> Dado Removido à esquerda: 10 LinkedList: [20, 30] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda ou [D]ireita e <enter> Dado Removido à esquerda: 20 LinkedList: [30] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda ou [D]ireita e <enter> Dado Removido à esquerda: 30 LinkedList: [] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda ou [D]ireita e <enter> ERRO: Lista Vazia LinkedList: [] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda ou [D]ireita d <enter> ERRO: Lista Vazia LinkedList: [] [I]ncluir, [C]onsultar, [R]emover ou [F]im: f <enter> 5.6.1.12 Complemente o programa anterior com a função de “Incluir”, “consultar” e “remover” em uma posição escolhida pelo usuário, ou seja, [E]squerda, [P]osição ou [D]ireita (conforme exemplo abaixo). Exemplo para testar o programa: [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda, [P]osição [D]ireita: e <enter> Dado: 10 <enter> LinkedList: [10] [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda, [P]osição [D]ireita: d <enter> Dado: 20 LinkedList: [10, 20] [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda, [P]osição [D]ireita: d <enter> Dado: 40 LinkedList: [10, 20, 40] [I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter> [E]squerda, [P]osição [D]ireita: p <enter> Dado: 30 <enter> Posição: 2 <enter> LinkedList: [10, 20, 30, 40] [I]ncluir, [C]onsultar, [R]emover ou [F]im: c <enter> [E]squerda, [P]osição [D]ireita: p <enter> Posição: 2 <enter> Dado Consultado: 30 LinkedList: [10, 20, 30, 40] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda, [P]osição [D]ireita: p <enter> Posição: 3 <enter> Dado Removido da Posição: 40 82 LinkedList: [10, 20, 30] [I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter> [E]squerda, [P]osição [D]ireita: p <enter> Posição: 6 <enter> ERRO: Posição Inválida LinkedList: [10, 20, 30] [I]ncluir, [C]onsultar, [R]emover ou [F]im: f <enter> 5.6.1.13 Escreva um programa em Java que armazena “n” números inteiros em uma Lista Encadeada Simples (LinkedList). O programa possui três funções básicas: [I]ncluir, [E]lemento e [R]emover, as funções “Incluir” e “Remover” em ambos os lados da lista encadeada: [E]squerda ou [D]ireita e a função “Elemento” deve listar o ANTECESSOR e o SUCESSOR deste elemento (ou “SEM ANTECESSOR” e/ou “SEM SUCESSOR”) (conforme exemplo abaixo). Exemplo para testar o programa: [I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter> [E]squerda ou [D]ireita e <enter> Dado: 10 <enter> LinkedList: [10] [I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter> [E]squerda ou [D]ireita d <enter> Dado: 20 <enter> LinkedList: [10, 20] [I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter> [E]squerda ou [D]ireita d <enter> Dado: 30 <enter> LinkedList: [10, 20, 30] [I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter> Elemento a Pesquisar: 20 <enter> Antecessor: 10 Sucessor: 30 LinkedList: [10, 20, 30] [I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter> Elemento a Pesquisar: 10 <enter> ERRO: SEM ANTECESSOR Sucessor: 20 LinkedList: [10, 20, 30] [I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter> Elemento a Pesquisar: 30 <enter> Antecessor: 20 ERRO: SEm SUCESSOR LinkedList: [10, 20, 30] [I]ncluir, [E]lemento, [R]emover ou [F]im: f <enter> 83 5.6.1.14 Escreva um programa em Java que armazena “n” números inteiros em uma Lista Encadeada Simples (LinkedList). O programa possui quatro funções básicas: [I]ncluir, [E]lemento, [P]esquisar e [R]emover. As funções “Incluir” e “Remover” em ambos os lados da lista encadeada: [E]squerda e [D]ireita. A função “Elemento” verifica o Antecessor e o Sucessor de um determinado elemento. A função “Pesquisar” pesquisa um determinado elemento pelo índice(conforme exemplo abaixo). Exemplo para testar o programa: [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter> [E]squerda ou [D]ireita: e <enter> Dado: 10 <enter> Indices: 0 LinkedList: [10] [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 20 <enter> Indices: 0 1 LinkedList: [10, 20] [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 30 <enter> Indices: 0 1 2 LinkedList: [10, 20, 30] [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 40 <enter> Indices: 0 1 2 3 LinkedList: [10, 20, 30, 40] [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: p <enter> Indice: 2 <enter> Dado Pesquisado pelo Indice: 30 Indices: 0 1 2 3 LinkedList: [10, 20, 30, 40] [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: p <enter> Indice: 8 <enter> ERRO: Indice Inexistente Indices: 0 1 2 3 LinkedList: [10, 20, 30, 40] [I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: f <enter> 5.6.1.15 Escreva um programa em Java que armazena “n” números inteiros em uma Lista Encadeada Simples (LinkedList). O programa possui três funções básicas: [I]ncluir, [S]ort e [C]lear All. A função “Incluir” inclui em ambos os lados da lista encadeada: [E]squerda e [D]ireita. A função “Sort” ordena a lista encadeada. A função “Clear All” remove todos os elementos(conforme exemplo abaixo). Exemplo para testar o programa: [I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter> [E]squerda ou [D]ireita: e <enter> Dado: 10 <enter> Indices: 0 LinkedList: [10] [I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 40 <enter> Indices: 0 1 LinkedList: [10, 40] [I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 50 <enter> Indices: 0 1 2 LinkedList: [10, 40, 50] [I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 30 <enter> Indices: 0 1 2 3 84 LinkedList: [10, 40, 50, 30] [I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter> [E]squerda ou [D]ireita: d <enter> Dado: 20 <enter> Indices: 0 1 2 3 4 LinkedList: [10, 40, 50, 30, 20] [I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter> [E]squerda ou [D]ireita: e <enter> Dado: 60 <enter> Indices: 0 1 2 3 4 5 LinkedList: [60, 10, 40, 50, 30, 20] [I]ncluir, [S]ort, [C]lear All ou [F]im: s <enter> Indices: 0 1 2 3 4 5 LinkedList: [10, 20, 30, 40, 50, 60] [I]ncluir, [S]ort, [C]lear All ou [F]im: c <enter> Indices: LinkedList: [] [I]ncluir, [S]ort, [C]lear All ou [F]im: f <enter> 5.6.1.16 Escreva um programa em Java que armazena “n” números inteiros em um vetor (Vector, ArrayList ou LinkedList), mantendo-os ordenados conforme a entrada das informações (conforme exemplo abaixo). O programa deve ir exibindo os elementos na tela a cada nova entrada. A entrada das informações termina quando o usuário digitar zero (0). Exemplo para testar o programa: Info: 10 <enter> ArrayList: [10] Info: 30 <enter> ArrayList: [10, 30] Info: 40 <enter> ArrayList: [10, 30, 40] Info: 20 <enter> ArrayList: [10, 20, 30, 40] Info: 5 <enter> ArrayList: [5, 10, 20, 30, 40] Info: 60 <enter> ArrayList: [5, 10, 20, 30, 40, 60] Info: 50 <enter> ArrayList: [5, 10, 20, 30, 40, 50, 60] Info: 20 <enter> ERRO: Informação Repetida ArrayList: [5, 10, 20, 30, 40, 50, 60] Info: 0 <enter> ArrayList: [5, 10, 20, 30, 40, 50, 60] 5.7 ArrayList bidimensional Em Java é possível criar um array bidimensional usando a classe ArrayList. Programa Exemplo: Mostra a utilização de um ArrayList bidimensional. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgArrayList2D.java package progarraylist2d; import java.util.ArrayList; public class ProgArrayList2D { public static void main(String[] args) { final int numeroLinhas = 7; final int numeroColunas = 5; ArrayList[][] tabela = new ArrayList[numeroLinhas][numeroColunas]; 85 int x = 10; for (int i = 0; i < numeroLinhas; i++) { int n = x; for (int j = 0; j < numeroColunas; j++) { tabela[i][j] = new ArrayList(); tabela[i][j].add(n); n = n + 10; } x++; } for (int i = 0; i < numeroLinhas; i++) { for (int j = 0; j < numeroColunas; j++) { System.out.print(tabela[i][j]); } System.out.println(); } } } Resultado do Programa: [10][20][30][40][50] [11][21][31][41][51] [12][22][32][42][52] [13][23][33][43][53] [14][24][34][44][54] [15][25][35][45][55] [16][26][36][46][56] Programa Exemplo: Escreva um programa em Java que lê duas matrizes: A e B e gera uma matriz C que é a multiplicação da matriz A com a matriz B. Todas as matrizes devem ser ArrayList’s. // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgMultMatriz.java package progmultmatriz; import java.util.ArrayList; import java.util.Scanner; public class ProgMultMatriz { public static void main(String[] args) { int ma, na, mb, nb; Scanner entrada = new Scanner(System.in); String s; System.out.print("Número de Linhas da Matriz A (mA): "); s = entrada.nextLine(); ma = Integer.parseInt(s); System.out.print("Número de Colunas da Matriz A(nA): "); s = entrada.nextLine(); na = Integer.parseInt(s); System.out.print("Número de Linhas da Matriz B(mB): "); s = entrada.nextLine(); mb = Integer.parseInt(s); System.out.print("Número de Colunas da Matriz B(nB): "); s = entrada.nextLine(); nb = Integer.parseInt(s); if (na != mb) { System.out.println("Erro Fatal: Multiplicação Impossível"); System.out.println("Número de Colunas de A (nA) tem que ser igual número de linhas de B (mB)"); System.exit(0); } ArrayList[][] a = new ArrayList[ma][na]; 86 ArrayList[][] b = new ArrayList[mb][nb]; ArrayList[][] c = new ArrayList[ma][nb]; System.out.println("Matriz A"); for (int lin = 0; lin < ma; lin++) { for (int col = 0; col < na; col++) { a[lin][col] = new ArrayList(); System.out.print("A[" + (lin + 1) + ", " + (col + 1) + "]: "); s = entrada.nextLine(); a[lin][col].add(Integer.parseInt(s)); } } System.out.println("Matriz B"); for (int lin = 0; lin < mb; lin++) { for (int col = 0; col < nb; col++) { b[lin][col] = new ArrayList(); System.out.print("B[" + (lin + 1) + ", " + (col + 1) + "]: "); s = entrada.nextLine(); b[lin][col].add(Integer.parseInt(s)); } } System.out.println("Matriz C = A x B"); for (int lin = 0; lin < ma; lin++) { for (int col = 0; col < nb; col++) { int soma = 0; for (int k = 0; k < na; k++) { c[lin][col] = new ArrayList(); String A = ""; A = A + a[lin][k].get(0); String B = ""; B = B + b[k][col].get(0); soma = soma + Integer.parseInt(A) * Integer.parseInt(B); } c[lin][col].add(soma); } } for (int lin = 0; lin < ma; lin++) { for (int col = 0; col < nb; col++) { System.out.println("C[" + (lin + 1) + ", " + (col + 1) + "]: " + c[lin][col]); } } } } Exemplo para testar o programa: Número de Linhas da Matriz A (mA): 2 <enter> Número de Colunas da Matriz A(nA): 2 <enter> Número de Linhas da Matriz B(mB): 2 <enter> Número de Colunas da Matriz B(nB): 3 <enter> Matriz A A[1, 1]: 1 <enter> A[1, 2]: 2 <enter> A[2, 1]: 3 <enter> A[2, 2]: 4 <enter> Matriz B B[1, 1]: 1 <enter> B[1, 2]: 2 <enter> B[1, 3]: 3 <enter> B[2, 1]: 4 <enter> B[2, 2]: 5 <enter> B[2, 3]: 6 <enter> Matriz C = A x B C[1, 1]: [9] C[1, 2]: [12] C[1, 3]: [15] 87 C[2, 1]: [19] C[2, 2]: [26] C[2, 3]: [33] Programa Exemplo: Escreva um programa em Java que leia uma matriz A (3 x 4) e cria 2 vetores SL e SC de 3 e 4 elementos que contenham respectivamente a soma das linhas (SL) e a soma das colunas (SC). Imprimir os vetores SL e SC. // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgArrayList2D_2.java package progarraylist2d_2; import java.util.ArrayList; import java.util.Scanner; public class ProgArrayList2D_2 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); final int numeroLinhas = 3, numeroColunas = 4; ArrayList <Integer> [][] a = new ArrayList[numeroLinhas][numeroColunas]; ArrayList <Integer> [] sl = new ArrayList[numeroLinhas]; ArrayList <Integer> [] sc = new ArrayList[numeroColunas]; for (int l = 0; l < numeroLinhas; l++) { for (int c = 0; c < numeroColunas; c++) { a[l][c] = new ArrayList(); // instanciar cada elemento System.out.print("a [" + (l + 1) + "," + (c + 1) + "]: "); String s = entrada.nextLine(); a[l][c].add(Integer.parseInt(s)); } } int k = 0; for (int l = 0; l < numeroLinhas; l++) { int soma = 0; for (int c = 0; c < numeroColunas; c++) { soma = soma + a[l][c].get(0).hashCode(); sl[k] = new ArrayList(); // instanciar cada elemento sl[k].add(soma); } k++; } System.out.println(); for (k = 0; k < numeroLinhas; k++) { System.out.println("sl[" + (k + 1) + "]: " + sl[k]); } k = 0; for (int c = 0; c < numeroColunas; c++) { int soma = 0; for (int l = 0; l < numeroLinhas; l++) { soma = soma + a[l][c].get(0).hashCode(); sc[k] = new ArrayList(); // instanciar cada elemento sc[k].add(soma); } k++; } System.out.println(); for (k = 0; k < numeroColunas; k++) { System.out.println("sc[" + (k + 1) + "]: " + sc[k]); } System.out.println(); } } 88 Exemplo para testar o programa: a [1,1]: 1 <enter> a [1,2]: 2 <enter> a [1,3]: 3 <enter> a [1,4]: 4 <enter> a [2,1]: 5 <enter> a [2,2]: 6 <enter> a [2,3]: 7 <enter> a [2,4]: 8 <enter> a [3,1]: 9 <enter> a [3,2]: 10 <enter> a [3,3]: 11 <enter> a [3,4]: 12 <enter> sl[1]: [10] sl[2]: [26] sl[3]: [42] sc[1]: [15] sc[2]: [18] sc[3]: [21] sc[4]: [24] Programa Exemplo: Escreva um programa em Java que gera uma matriz A (12 x 13) e divide todos os elementos de cada uma das 12 linhas de A pelo valor do maior elemento daquela linha. Imprimir a matriz A modificada. // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgArrayList2D_3.java package progarraylist2d_3; import java.util.ArrayList; public class ProgArrayList2D_3 { public static void main(String[] args) { final int numeroLinhas = 12, numeroColunas = 13; ArrayList<Double>[][] a = new ArrayList[numeroLinhas][numeroColunas]; double x = 1.0; // gera matriz A for (int l = 0; l < numeroLinhas; l++) { for (int c = 0; c < numeroColunas; c++) { a[l][c] = new ArrayList(); if (c == 0) { a[l][c].add(x); x++; } else { a[l][c].add(1.0); } } } // lista o ArrayList 2D (matriz a) System.out.println("Matriz Original: "); for (int l = 0; l < numeroLinhas; l++) { for (int c = 0; c < numeroColunas; c++) { System.out.printf("%4.1f ", a[l][c].get(0)); } System.out.println(); } 89 // ArrayList 2D ArrayList<Double>[] maior = new ArrayList[numeroLinhas]; // ArrayList 1D System.out.println("\nMatriz Modificada: "); for (int l = 0; l < numeroLinhas; l++) { maior[l] = new ArrayList(); maior[l].add(0.0); for (int c = 0; c < numeroColunas; c++) { if (a[l][c].get(0) > maior[l].get(0)) { maior[l].remove(0); maior[l].add(a[l][c].get(0)); } } } for (int l = 0; l < numeroLinhas; l++) { for (int c = 0; c < numeroColunas; c++) { double div = a[l][c].get(0) / maior[l].get(0); a[l][c] = new ArrayList(); a[l][c].add(div); } } for (int l = 0; l < numeroLinhas; l++) { System.out.printf("%4.1f -> ", maior[l].get(0)); for (int c = 0; c < numeroColunas; c++) { System.out.printf("%.2f ", a[l][c].get(0)); } System.out.println(); } } } Resultado do Programa: Matriz Original: 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 2,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 3,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 4,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 5,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 6,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 7,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 8,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 9,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 10,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 11,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 12,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 Matriz Modificada: 1,0 -> 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 2,0 -> 1,00 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 3,0 -> 1,00 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 4,0 -> 1,00 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 5,0 -> 1,00 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 6,0 -> 1,00 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 7,0 -> 1,00 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 8,0 -> 1,00 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 9,0 -> 1,00 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 10,0 -> 1,00 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 11,0 -> 1,00 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 12,0 -> 1,00 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 5.8 Strings (Cadeia de Caracteres) Java possui um classe que permite a manipulação de Strings (cadeia de caracteres) chamada String. 90 Uma string é um tipo de dado que permite armazenar e manipular um conjunto de caracteres, números e caracteres especiais (Figura 5). Declaração e inicialização: String s = “Pelotas”; String r = null; String str = ““; Figura 5: Representação gráfica de uma String Onde: p é o índice do primeiro caracter (ou seja, zero) Character primeiroCaracter = s.charAt(0); n é o número de caracteres da String int n = s.length(); u é o índice do último caracter da String int u = n – 1; Character ultimoCaracter = s.charAt(u); ou Character primeiroCaracter = s.charAt(n-1); Observação: Note que igualmente a um vetor (array), Vector, ArrayList, LinkedList, o primeiro caracter da String encontra-se na posição zero (0), por isto nunca pode-se acessar o elemento “n” da String e sim o elemento de índice “u”. Forma alternativa (Utilizar com um vetor de caracteres): char[] s = {'P', 'e', 'l', 'o', 't', 'a', 's'}; System.out.println(s); System.out.println(Arrays.toString(s)); char caracteres[] = {'A', 'B', 'C', 'D', 'E', 'F'}; String string = new String(caracteres); System.out.println("string: " + string); int n = string.length(); for (int i = 0; i < n; i++) { System.out.println("Código ASCII: " + string.codePointAt(i)); } for (char ch : string.toCharArray()) { // foreach System.out.println("Caracter: " + ch); } Resultado do Programa: Pelotas [P, e, l, o, t, a, s] string: ABCDEF Código ASCII: 65 Código ASCII: 66 Código ASCII: 67 91 Código ASCII: 68 Código ASCII: 69 Código ASCII: 70 Caracter: A Caracter: B Caracter: C Caracter: D Caracter: E Caracter: F 5.8.1 Métodos para manipular Strings A seguir são descritos os principais métodos que permitem manipular objetos do tipo String. Sintaxe: char charAt(int posição); Retorna o caracter contido na posição. Modo de usar: String s = “Pelotas”; char ch = s.charAt(0); // ch = ‘P’; Sintaxe: int compareTo(Object objeto); Compara a string com um objeto. Sintaxe: int compareTo(String outraString); Compara duas strings lexicograficamente (caracter à caracter). Sintaxe: int compareToIgnoreCase(String string); Compara duas strings lexicograficamente, ignorando diferenças entre maíusculas e minúsculas. Sintaxe: String concat(String string); Concatena a string no fim da outra string. Sintaxe: boolean contentEquals(String stringBuffer); Retorna true se e somente se a string representa a mesma sequência de caracteres do que a stringBuffer. Sintaxe: static String copyValueOf(char[] vetor); Retorna uma string que representa a sequência de caracteres do vetor de careacteres. Sintaxe: static String copyValueOf(char[] vetor, int offset, int count); Retorna uma string que representa uma sequência de caracteres do vetor. Sintaxe: boolean endsWith(String sufixo); Testa se a string termina com o sufixo especificado. Sintaxe: boolean equals(Object objeto); Compara a string com o objeto. Sintaxe: boolean equalsIgnoreCase(String outraString); Compara a string com a outraString, ignorando maiúsculas e minúsculas. Sintaxe: byte[] getBytes(); Codifica a string em uma sequência de bytes usando o conjunto de caracteres, armazenando o resultado em um novo vetor de bytes. Sintaxe: byte[] getBytes(String charsetName); Codifica a string em uma sequência de bytes usando o conjunto de caracteres do nome, armazenando o resultado dentro do novo vetor. Sintaxe: void getChars(int fonteBegin, int fonteEnd, char[] destino, int destinoBegin); Cópia a seqüência de caracteres para um vetor de caracteres destino. Sintaxe: int hashCode(); Retorna o código hash da string. Sintaxe: int indexOf(int caracter); Retorna o índice dentro da string da primeira ocorrência do caracter especificado ou -1 se não encontrar. Sintaxe: int indexOf(int caracter, int fromIndex); Retorna o índice dentro da string da primeira ocorrência do caracter, iniciando a busca no índice. 92 Sintaxe: int indexOf(String string); Retorna o índice dentro da string da primeira ocorrência da substring. Sintaxe: int indexOf(String string, int fromIndex); Retorna o índice dentro da string da primeira ocorrência da substring, iniciando a busca no índice. Sintaxe: String intern(); Retorna uma representação canônica da string objeto (forma mais simples). Sintaxe: int lastIndexOf(int caracter); Retorna o índice dentro da string da última ocorrência do caracter. Sintaxe: int lastIndexOf(int caracter, int fromIndex); Retorna o índice dentro da string da última ocurrência do caracter, pesquisando para trás começando no índice. Sintaxe: int lastIndexOf(String string); Retorna o índice dentro da string da ocorrência mais à direita da subseqüência. Sintaxe: int lastIndexOf(String string, int fromIndex); Retorna o índice dentro da string da última ocorrência da substring, buscando para trás começando o índice. Sintaxe: int length(); Retorna o comprimento da string, ou seja, o número de caracteres presentes na string no momento. Sintaxe: boolean matches(String expressaoRegular); Diz se a string corresponde a uma expressão regular ou não. Sintaxe: boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len); Testa se duas regiões das strings são iguais. Sintaxe: boolean regionMatches(int toffset, String other, int ooffset, int len); Testa se duas regiões das strings são iguais. Sintaxe: String replace(char velhoCaracter, char novoCaracter); Retorna uma nova string resultante da troca de todas as ocorrências do velhoCaracter nesta string com novoCaracter. Sintaxe: String replaceAll(String expressaoRegular, String replacement); Substitui cada subseqüência da seqüência de caracteres que corresponde a expressão regular com a substituição dada. Sintaxe: String replaceFirst(String expressaoRegular, String replacement); Substitui as primeiras substrings dessa string que corresponde à expressão regular com a substituição dada. Sintaxe: String[] split(String expressaoRegular); Divide a string em pedaços (substrings) em torno da expressão regular. Sintaxe: String[] split(String expressaoRegular, int limite); Divide a string em pedaços em torno da expressão regular. Sintaxe: boolean startsWith(String prefixo); Testa se esta string começa com o prefixo. Sintaxe: boolean startsWith(String prefixo, int toffset); Testa se a string começa com o prefixo começando pelo índice. Sintaxe: CharSequence subSequence(int beginIndex, int endIndex); Retorna uma nova string de caracteres que é uma subseqüência desta seqüência. Sintaxe: String substring(int beginIndex); Retorna uma nova string que é uma substring desta string. Sintaxe: String substring(int beginIndex, int endIndex); Retorna uma nova string que é uma substring desta string. Sintaxe: char[] toCharArray(); Converte a string em um novo vetor de caracteres. Sintaxe: String toLowerCase(); 93 Converte todos os caracteres da string para minúsculos. Sintaxe: String toString(); Retorna o objeto como string. Sintaxe: String toUpperCase(); Converte todos os caracteres da string para maiúsculos. Sintaxe: String trim(); Retorna uma cópia da string. Sintaxe: static String valueOf(boolean flag); Retorna uma representação string do argumento boolean. Sintaxe: static String valueOf(char caracter); Retorna uma representação string do argumento char. Sintaxe: static String valueOf(char[] vetor); Retorna uma representação string do argumento char []. Sintaxe: static String valueOf(char[] vetor, int offset, int count); Retorna uma representação string do argumento char []. Sintaxe: static String valueOf(double realDouble); Retorna uma representação string do argumento double. Sintaxe: static String valueOf(float realFloat); Retorna uma representação string do argumento float. Sintaxe: static String valueOf(int inteiro); Retorna uma representação string do argumento int. Sintaxe: static String valueOf(long longo); Retorna uma representação string do argumento long. Sintaxe: static String valueOf(Object objeto); Retorna uma representação string do argumento Object. Exemplos: a) Exemplo do uso dos métodos toUpperCase e toLowerCase: // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgToUpperCase.java package progtouppercase; public class ProgToUpperCase { public static void main(String[] args) { String s = "Paulo Roberto Gomes Luzzardi"; System.out.println("Nome: " + s); System.out.println("Nome: " + s.toUpperCase()); System.out.println("Nome: " + s.toLowerCase()); } } Resultado do Programa: Nome: Paulo Roberto Gomes Luzzardi Nome: PAULO ROBERTO GOMES LUZZARDI Nome: paulo roberto gomes luzzardi b) Exemplo do uso de length, charAt e indexOf: // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgInverte.java 94 package proginverte; import java.util.Scanner; public class ProgInverte { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s; int n; char op; do { System.out.print("Nome: "); s = input.nextLine(); System.out.print("Invertido: "); n = s.length(); // número de caracteres da String s for (int i = n-1;i >= 0;i--) { System.out.print(s.charAt(i)); // acesso a cada caracter da String s } System.out.println(); do { System.out.print("Continua [S/N]? "); s = input.nextLine(); op = s.charAt(0); } while ("SsNn".indexOf(op) == -1); // verifica se op é “SsNn” } while ("Ss".indexOf(op) != -1); // } while ("S".equalsIgnoreCase(s)); } } Exemplo para testar o orograma: Nome: pelotas <enter> Invertido: satolep Continua [S/N]? s <enter> Nome: satolep <enter> Invertido: pelotas Continua [S/N]? N <enter> c) Exemplo do uso de String.format: // --------------------------------------------------------------------------------------------------- Programa Principal: ProgStringFormat.java package progstringformat; public class ProgStringFormat { public static void main(String[] args) { float numero = 123.456789f; String formato = String.format("%.3f", numero); //JOptionPane.showMessageDialog(null, "numero: " + formato); System.out.printf("Número: %.4f\n", numero); System.out.println("Número Formatado: " + formato); } } Resultado do Programa: Número: 123,4568 Número Formatado: 123,457 5.8.2 Lista de exercícios: Strings 5.8.2.1 Escreva um programa em Java que recebe via teclado um nome. Logo após a entrada do nome imprima: número de letras maiúsculas, número de letras minúsculas, número de vogais e o número de consoantes, conforme exemplo abaixo: 95 Entrada: Nome: Faculdade de Tecnologia Senac <enter> Saída: (3) maiúscula(s) (23) minúscula(s) (12) vogais(s) (14) consoante(s) 5.8.2.2 Escreva um programa em Java que recebe via teclado uma palavra e uma letra. Logo após a entrada do nome e da letra imprima o número de letras que existe no nome ou ERRO: Não existe a letra (?) na palavra (?), conforme exemplo abaixo: Exemplo para testar o programa: Palavra: Luzzardi <enter> Letra: z <enter> 2 letra(s) Continua [S]im ou [N]ão? S <enter> Palavra: Luzzardi <enter> Letra: w <enter> ERRO: Não existe a letra (w) na palavra (Luzzardi) Continua [S]im ou [N]ão? N <enter> Observação: O programa deve ser encerrado quando o usuário digitar “N” ou “n” na pergunta: Continua [S]im ou [N]ão?. 5.8.2.3 Escreva um programa em Java que recebe via teclado uma palavra e uma posição. O programa deve imprimir na tela, a letra antecessora, a letra (da referida posição) e a letra sucessora, conforme exemplo abaixo: Entrada: Palavra: Universidade <enter> Posição: 7 <enter> Saída: Antecessora: s Letra: i Sucessora: d Observação: O programa deve imprimir na tela as seguintes mensagens de erro, se for o caso: Letra antecessora não existe, Letra sucessora não existe ou Posição inválida. 5.8.2.4 Escreva um programa em Java que recebe via teclado um nome. O programa deve imprimir, na tela, as palavras do nome em ordem inversa, uma por linha, conforme exemplo abaixo: Entrada: Nome: Paulo Roberto Gomes Luzzardi <enter> Saída: Luzzardi Gomes Roberto Paulo 5.8.2.5 Escreva um programa em Java que recebe via teclado um nome. Logo após a entrada do nome o programa deve imprimir (EM LETRA MAIÚSCULA) o sobrenome da pessoa, conforme exemplos abaixo: Exemplo para testar o programa: Sobrenome: LUZZARDI Sair [S/N]? N <enter> Nome: Renato Souza <enter> Sobrenome: SOUZA Sair [S/N]? s <enter> Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]? 5.8.2.6 Escreva um programa em Java que recebe via teclado um nome. Logo após a entrada do nome o programa deve imprimir na tela: sobrenome, primeiro nome e demais nomes abreviados, conforme exemplos abaixo: Exemplo para testar o programa: Nome: Paulo Roberto Gomes Luzzardi <enter> Autor: Luzzardi, Paulo R. G. 96 Sair [S/N]? N <enter> Nome: Renato Lima Souza <enter> Autor: Souza, Renato L. Sair [S/N]? s <enter> Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]? 5.8.2.7 Escreva um programa em Java que recebe via teclado o nome de um estado. Logo após a entrada do nome do estado imprima: a sigla do estado (2 letras maiúsculas), conforme exemplos abaixo: Exemplo para testar o programa: Estado: Rio Grande do Sul <enter> Sigla: RS Estado: são paulo <enter> Sigla: SP Estado: rio de janeiro <enter> Sigla: RJ Estado: <enter> Observação: O programa encerra quando o usuário digitar apenas <enter> na entrada do nome do estado. 5.8.2.8 Escreva um programa em Java que recebe via teclado uma palavra, início e fim. Logo após a entrada de todos os dados imprima a string resultante ou ERRO: Fim inválido ou Início inválido, conforme exemplos abaixo: Exemplo para testar o programa: Palavra: universidade <enter> Início: 7 <enter> Fim: 11 <enter> String resultante: idade Continua [S/N]? s <enter> Palavra: eletricidade <enter> Início: 7 <enter> Fim: 15 <enter> ERRO: Fim Inválido Continua [S/N]? N <enter> Observação: O programa termina quando o usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?. 5.9 Classe Object Em Java, todas as classes, sem nenhuma exceção, herdam direta ou indiretamente todos os métodos da classe Object, pois ela é a superclasse de qualquer outra classe. A seguir são descritos os métodos da classe Object. Sintaxe: protected Object clone(); Cria e retorna uma cópia do objeto. Sintaxe: boolean equals(Object objeto); Indica se um objeto é igual a outro. Sintaxe: protected void finalize(); Chama o coletor de lixo (garbage coletor) do objeto quando o coletor de lixo determina que não há mais referências ao objeto. Sintaxe: Class getClass(); Retorna a classe runtime do objeto. Sintaxe: int hashCode(); Retorna o valor do código hash do objeto. Sintaxe: void notify(); 97 Aguarda uma thread que está esperando o monitor do objeto. Sintaxe: void notifyAll(); Aguarda todas as threads que estão esperando o monitor do objeto. Sintaxe: String toString(); Retorna uma string do objeto. Sintaxe: void wait(); Faz a thread corrente esperar até que outra thread invoque os métodos notify() ou notifyAll() deste objeto. Sintaxe: void wait(long timeout); Faz a thread corrente esperar até que outra thread invoque os métodos notify() ou notifyAll() deste objeto ou um período especificado de tempo tiver decorrido. Sintaxe: void wait(long timeout, int nanos); Faz a thread corrente esperar até que outra thread invoque os métodos notify() ou notifyAll() deste objeto, ou outra thread interrompa a corrente thread, ou um período especificado de tempo tiver decorrido. Pacote: java.lang.Object (não é necessário fazer a chamada implícita deste pacote) // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgObject.java package progobject; public class ProgObject { public static void main(String[] args) throws Exception { Object objeto = new Object(); objeto = "Paulo Roberto"; System.out.println("Objeto: " + objeto); objeto = 48; System.out.println("Objeto: " + objeto); } } Resultado do Programa: Objeto: Paulo Roberto Objeto: 48 // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgObjeto.java package progobjeto; import java.util.Stack; public class ProgObjeto { public static void main(String[] args) throws Exception { Object objeto = "Paulo Roberto"; System.out.println("Objeto String: " + objeto); objeto = 48; System.out.println("Objeto Inteiro: " + objeto); Stack pilha = new Stack(); pilha.push(123); objeto = pilha.pop(); System.out.println("Objeto Pilha: " + objeto); Integer valor = objeto.hashCode(); System.out.println("Valor: " + valor); } } Resultado do Programa: Objeto String: Paulo Roberto Objeto Inteiro: 48 98 Objeto Pilha: 123 Valor: 123 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgNovoObjeto.java package prognovoobjeto; import java.util.Scanner; public class ProgNovoObjeto { public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String s; int n; System.out.print("Numero de Objetos: "); s = entrada.nextLine(); n = Integer.parseInt(s); Object [] objeto = new Object[n]; for (int i = 0;i < n;i++) { System.out.print("Nome: "); s = entrada.nextLine(); objeto[i] = s; } for (int i = n-1;i >= 0;i--) { System.out.println("String: " + objeto[i]); } // vetor de objetos } } Exemplo para testar o programa: Número de Objetos: 4 <enter> Nome: paulo <enter> Nome: roberto <enter> Nome: gomes <enter> Nome: luzzardi <enter> String: luzzardi String: gomes String: roberto String: paulo 5.10 Classe Iterator Iterator é um padrão de projeto que permite simplificar a iteração com um conjunto de objetos, tendo como função encapsular a iteração sobre objetos, simplificando desta forma, a manipulação de uma coleção de objetos. A seguir são descritos os métodos da classe Iterator. Sintaxe: boolean hasNext(); Retorna true se a iteração possui mais elementos. Sintaxe: E next(); Retorna o próximo elemento da iteração. Sintaxe: void remove(); Remove da coleção o último elemento retornado pelo iterador. Observação: Olhe o exemplo de utilização do Iterator da próxima seção (5.11). 99 5.11 Classe LinkedHashSet LinkedHashSet é uma das implementações da interface Set (conjunto). Esta implementação estende a implementação HashSet, adicionando uma ordem de iteração nos elementos, usando o Iterator. A ordem de inserção é a ordem dos elementos do conjunto. Utiliza uma lista duplamente encadeada para manter a ordem. A seguir são descritos os principais métodos da classe LinkedHashSet (HashSet, AbstractSet, AbstractCollection, Object e Set). Sintaxe: boolean add(E elemento); Adiciona o elemento no conjunto, se ele ainda não existir. Sintaxe: boolean remove(Object objeto); Remove o objeto especificado do conjunto. Sintaxe: void clear(); Remove todos os elementos do conjunto. Sintaxe: Object clone(); Retorna um clone do conjunto para um determinado objeto. Sintaxe: boolean contains (Object objeto); Retorna true se o objeto especificado existe, caso contrário retorna false. Sintaxe: int size (); Retorna o número de elementos do conjunto. Sintaxe: boolean isEmpty (); Retorna true se o conjunto está vazio. Sintaxe: boolean equals (Object objeto); Compara dois objetos e retorna true se são iguais ou false se são diferentes. Sintaxe: int hashCode (); Retorna o hashcode do conjunto. Sintaxe: boolean removeAll (Collection <?> coleção); Remove todos os elementos da coleção. // ------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashSet1.java package proglinkedhashset1; import java.util.Iterator; import java.util.LinkedHashSet; public class ProgLinkedHashSet1 { public static void main(String[] args) { LinkedHashSet<String> lista = new LinkedHashSet<>(); lista.add("Ana"); lista.add("Beatriz"); lista.add("Carla"); lista.add("Debora"); lista.add("Eva"); Iterator<String> iterator = lista.iterator(); System.out.print("LinkedHashSet: ["); while (iterator.hasNext()) { System.out.print(iterator.next() + ", "); } 100 System.out.println(“\b\b]”); } } Resultado do Programa: LinkedHashSet: [Ana, Beatriz, Carla, Debora, Eva] // ------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashSet2.java package proglinkedhashset2; import java.util.Iterator; import java.util.LinkedHashSet; public class ProgLinkedHashSet2 { public static void main(String[] args) { LinkedHashSet<Integer> lista = new LinkedHashSet<>(); lista.add(100); lista.add(200); lista.add(300); lista.add(400); lista.add(500); int n = lista.size(); System.out.println("Número de Elementos do Conjunto: " + n); int somaTotal = 0; Iterator<Integer> iterator = lista.iterator(); System.out.print("LinkedHashSet: ["); while (iterator.hasNext()) { int elemento = iterator.next(); somaTotal = somaTotal + elemento; System.out.print(elemento + ", "); } System.out.println("\b\b]"); System.out.println("Soma Total dos Elementos do Conjunto: " + somaTotal); double media = (double) somaTotal / n; System.out.println("Média do Conjunto: " + media); } } Resultado do Programa: Número de Elementos do Conjunto: 5 LinkedHashSet: [100, 200, 300, 400, 500] Média do Conjunto: 300.0 5.12 Classe Genérica em Java É possível em Java definir e utilizar uma classe genérica. Veja o exemplo a seguir aonde há uma classe genérica “Nodo”: // -------------------------------------------------------------------------------------------------------------------- Classe Genérica: Nodo.java package progclassegenerico_1; public class Nodo <E> { private E element; public void add(E element) { this.element = element; } public E get() { 101 return element; } } // ----------------------------------------------------------------------------------------------- Programa Principal: ProgClasseGenerica_1.java package progclassegenerico_1; public class ProgClasseGenerico { public static void main(String[] args) { Nodo <Integer> inteiro = new Nodo<>(); inteiro.add(123); System.out.println("Inteiro: " + inteiro.get()); Nodo <Double> real = new Nodo<>(); real.add(123.45); System.out.println("Double: " + real.get()); Nodo <String> string = new Nodo<>(); string.add("Paulo"); System.out.println("String: " + string.get()); Nodo <Character> caracter = new Nodo<>(); caracter.add('A'); System.out.println("Caracter: " + caracter.get()); Nodo <Float> numFloat = new Nodo<>(); numFloat.add(1.23f); System.out.println("Float: " + numFloat.get()); } } Resultado do Programa: Inteiro: 123 Double: 123.45 String: Paulo Caracter: A Float: 1.23 // ------------------------------------------------------------------------------------------------------------------ Classe Genérica: Pixel.java package progclassegenerica_2; public class Pixel <E>{ private E x; private E y; private int cor; public void add(E x, E y, int cor) { this.x = x; this.y = y; this.cor = cor; } public E getX() { return this.x; } public E getY() { return this.y; } public int getCor() { return this.cor; } } 102 // ----------------------------------------------------------------------------------------------- Programa Principal: ProgClasseGenerica_2.java package progclassegenerica_2; public class ProgClasseGenerica_2 { public static void main(String[] args) { Pixel <Integer> pixelInt = new Pixel<>(); pixelInt.add(100, 200, 3); System.out.println("x: " + pixelInt.getX()); System.out.println("y: " + pixelInt.getY()); System.out.println("Cor: " + pixelInt.getCor()); Pixel <Double> pixelDouble = new Pixel<>(); pixelDouble.add(50.70, 100.80, 4); System.out.println("x: " + pixelDouble.getX()); System.out.println("y: " + pixelDouble.getY()); System.out.println("Cor: " + pixelDouble.getCor()); } } Resultado do Programa: x: 100 y: 200 Cor: 3 x: 50.7 y: 100.8 Cor: 4 5.13 Fila Prioritária (PriorityQueue) É possível em Java definir e utilizar uma Fila com Prioridade através da classe PriorityQueue, ou seja, definir a ordem de retirada da Fila. PriorityQueue é uma Fila que possui uma forma prioritária na remoção dos seus elementos, ou seja, esta forma pode ser ascendente (crescente) ou descendente (decrescente) Veja exemplo ProgPriorityQueue abaixo. A seguir são descritos os principais construtores e métodos da classe PriorityQuere. Construtores PriorityQueue() Cria uma PriorityQueue com capacidade de 11 elementos de acordo com uma ordem natural dos seus elementos. PriorityQueue(Collection <? extends E> c) Cria uma PriorityQueue contebdo os elementos de uma coleção. PriorityQueue(Comparator <? Super E> comparator) Cria uma PriorityQueue com capacidade inicial padrão e cujos elementos são ordenados de acordo com o comparador especificado. PriorityQueue(int capacidadeInicial) Cria uma PriorityQueue com capacidade inicial especificada que ordena os elementos de acordo com sua Ordem natural. PriorityQueue(int capacidadeInicial, Comparator<? Super E> comparator) 103 Cria uma PriorityQueue com capacidade inicial especificada que ordena os elementos de acordo com o comparador especificado. PriorityQueue(PriorityQueue<? Extends E> c) Cria uma PriorityQueue contendo os elementos da PriorityQueue especificada. PriorityQueue(SortedSet<? Extends E> c) Cria uma PriorityQueue contendo os elementos da SortedSet especificada. Sintaxe: public boolean add(E element); Insere o elemento na Fila de Prioridade. Sintaxe: void clear(); Remove todos os elementos da PriorityQueue. Sintaxe: Comparator <? super E> comparator (); Retorna um comparador utilizado para ordenar os elementos da fila ou null se esta fila é classificada de acordo com a ordenação natural de seus elementos. Sintaxe: boolean contains(Object objeto); Retorna true se a Fila contém o objeto especificado. Sintaxe: Iterator <E> iterator (); Retorna um iterador sobre os elementos da Fila. Sintaxe: boolean offer (E element); Insere o elemento especificado na PriorityQueue. Sintaxe: E peek (); Recupera, mas não remove, o primeiro da Fila ou retorna null se a Fila está vazia. Sintaxe: E poll (); Recupera e remove o primeiro da Fila ou retorna null se a Fila está vazia. Sintaxe: boolean remove (Object objeto); Remove uma instância do objeto especificado desta Fila, se ele existir na Fila. Sintaxe: int size (); Retorna o número de elementos desta coleção. Sintaxe: Object [] toArray (); Retorna um array contendo todoso os elementos da Fila. Sintaxe: <T> T[] toArray (T[] array); Retorna um array contendo todos os elementos desta Fila; o tipo retornado é o mesmo tipo do array especificado. // ----------------------------------------------------------------------------------------------- Programa Principal: ProgFilaPrioridade.java package progfilaprioridade; import java.util.PriorityQueue; public class ProgFilaPrioridade { public static void main(String[] args) { PriorityQueue fila = new PriorityQueue(); // aloca 11 elementos fila.offer(20); fila.offer(40); fila.offer(10); fila.offer(30); System.out.println("Fila: " + fila); System.out.println("Menor Elemento Prioritário: " + (Integer) fila.poll()); System.out.print("PriorityQueue: ["); while (!fila.isEmpty()) { Integer nodo = (Integer) fila.poll(); System.out.print(nodo + ", "); } 104 // remove o menor elemento System.out.println("\b\b]"); } } Resultado do Programa: Fila: [10, 30, 20, 40] Menor Elemento Prioritário: 10 PriorityQueue: [20, 30, 40] A seguir, o programa exemplo, mostra uma Fila de Prioridade com prioridade do mais VELHO ao mais MOÇO. // ----------------------------------------------------------------------------------------------- Classe: Pessoa.java package progpriorityqueue; class Pessoa { // --------------------------------------------------------- atributos da classe private String nome; public int idade; // --------------------------------------------------------- construtor public Pessoa(String nome, int idade) { this.nome = nome; this.idade = idade; } @Override public String toString() { return("[" + nome + " tem " + idade + " anos]"); } } // ----------------------------------------------------------------------------------------------- Programa Principal: ProgPriorityQueue.java package progpriorityqueue; import java.util.PriorityQueue; public class ProgPriorityQueue { public static void main(String[] args) { // ordem descendente PriorityQueue <Pessoa> fila = new PriorityQueue<>((Pessoa p1, Pessoa p2) -> p2.idade - p1.idade); // ordem ascendente // PriorityQueue <Pessoa> fila = new PriorityQueue<>((Pessoa p1, Pessoa p2) -> p1.idade - p2.idade); fila.offer(new Pessoa("Paulo Roberto", 52)); fila.offer(new Pessoa("Renato Luis", 49)); fila.offer(new Pessoa("Ana Maria", 56)); fila.offer(new Pessoa("Francisco Carlos", 54)); fila.offer(new Pessoa("Julia Helena", 55)); System.out.println("Fila Prioritária: " + fila); while (!fila.isEmpty()) { System.out.println(fila.poll()); } } } Resultado do Programa: Fila Prioritária: [[Ana Maria, 56 anos], [Julia Helena, 55 anos], [Paulo Roberto, 52 anos], [Renato Luis, 49 anos], [Francisco Carlos, 54 anos]] [Ana Maria, 56 anos] [Julia Helena, 55 anos] 105 [Francisco Carlos, 54 anos] [Paulo Roberto, 52 anos] [Renato Luis, 49 anos] 106 6. Listas Lineares: Pilhas, Filas e Deques A seguir é visto a implementação de uma Pilha, uma Fila e um Deque implementados utizando as classes existentes em Java: Stack, Queue e ArrayDeque. Pilha: Estrutura linear organizada de forma que a entrada e a saída dos dados é feita na mesma extremidade (Figura 6). Forma de acesso: LIFO (Last Input First Output), ou seja, o último elemento a entrar na pilha é o primeiro a sair dela. Fila: Estrutura linear organizada de forma que a entrada dos dados é feita por uma extremidade da lista linear e, a saída, é feita na outra extremidade (Figura 6). Forma de acesso: FIFO (First Input First Output), ou seja, o primeiro elemento a entrar na fila é o primeiro a sair da fila. Figura 6: Representação de uma Fila e uma Pilha Funcionamento da Pilha acima: Entrada: 10, 20 e 30 (push) Saída: 30, 20 e 10 (pop) Funcionamento da Fila acima: Entrada: 10, 20 e 30 (insereFila) Saída: 10, 20 e 30 (removeFila) 6.1 Implementação de uma Pilha (Stack) 107 A seguir é mostrado a implementação de Pilha usando a classe Pilha e Stack (escrita pelo programador). Programa exemplo: Permite inserir números inteiros em uma Pilha usando uma classe Pilha implementada pelo programador. Quando o número digitado for igual à zero (0), todos os números da pilha são listados. // -------------------------------------------------------------------------------------------------------------------------------------- Classe: Pilha.java package progpilha; public class Pilha { // ----------------------------------------------- atributos da classe private int topo; private final int[] dados; // ----------------------------------------------- construtor Pilha(int numElementos) { dados = new int[numElementos]; topo = -1; } // ------------------------------------------------ push public void push(int i) { int max = dados.length - 1; if (topo < max) { topo++; dados[topo] = i; } else { System.out.println("Erro: Pilha Cheia"); } } // ------------------------------------------------ pop public int pop() { if (topo != 0) { int valor = dados[topo]; topo--; return (valor); } else { return (0); } } // ------------------------------------------------ exibe public void exibePilha() { System.out.print("Pilha: ["); for (int i = 0; i <= topo; i++) { System.out.print(dados[i] + ", "); } if (topo == -1) { System.out.println("]"); } else { System.out.println("\b\b]"); } } } // ----------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPilha.java package progpilha; import java.util.Scanner; public class ProgPilha { 108 public static void main(String[] args) { Pilha pilha = new Pilha(5); Scanner entrada = new Scanner(System.in); String s; int nodo; do { pilha.exibePilha(); System.out.print("Elemento: "); s = entrada.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) pilha.push(nodo); } while (nodo != 0); pilha.exibePilha(); } } Exemplo para testar o programa: Pilha: [] Elemento: 10 <enter> Pilha: [10] Elemento: 20 <enter> Pilha: [10, 20] Elemento: 30 <enter> Pilha: [10, 20, 30] Elemento: 40 <enter> Pilha: [10, 20, 30, 40] Elemento: 50 <enter> Pilha: [10, 20, 30, 40, 50] Elemento: 60 <enter> Erro: Pilha Cheia Pilha: [10, 20, 30, 40, 50] Elemento: 0 Pilha: [10, 20, 30, 40, 50] 109 Stack (Pilha) import java.util.Stack; A classe Stack é utilizada para armazenar elementos em uma Pilha. A seguir são descritos os principais métodos da classe Stack. Sintaxe: boolean isEmpty(); Testa se a pilha está vazia. Sintaxe: Object peek(); Verifica o objeto que está no topo da pilha sem removê-lo da pilha. Sintaxe: Object pop(); Remove o objeto do topo da pilha e retorna o valor do objeto. Sintaxe: Object push(Object objeto); Insere o objeto no topo da pilha. Sintaxe: int search(Object objeto); Retorna a posição que o objeto se encontra da pilha. Programa Exemplo: Mostra uma pilha utilizando a classe Stack e seus principais métodos de manipulação. // ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgStack2.java package progstack2; import java.util.Scanner; import java.util.Stack; public class ProgStack2 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); int nodo, n = 0; do { System.out.print("Nodo: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { pilha.push(nodo); n++; } } while (nodo != 0); System.out.println("Stack: " + pilha); String extenso = ""; while (!pilha.empty()) { extenso = extenso + pilha.pop() + ", "; } if (n == 0) { extenso = "]"; } else { extenso = extenso + "\b\b]"; } System.out.println("Pilha: [" + extenso); } } Exemplo para testar o programa: 110 Nodo: 10 <enter> Nodo: 20 <enter> Nodo: 30 <enter> Nodo: 40 <enter> Nodo: 50 <enter> Nodo: 60 <enter> Nodo: 0 <enter> Stack: [10, 20, 30, 40, 50, 60] Pilha: [60, 50, 40, 30, 20, 10] Programa Exemplo: Mostra uma pilha utilizando a classe Stack e seus principais métodos de manipulação. A diferença do programa ProgStack2 é a forma de retirar e imprimir os elementos da Pilha. No ProgStack2 foi utilizado uma String, no ProgStack3, foi usado um cast para Integer. // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgStack3.java package progstack3; import java.util.Scanner; import java.util.Stack; public class ProgStack3 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); int nodo, n = 0; do { System.out.print("Nodo: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { pilha.push(nodo); n++; } } while (nodo != 0); System.out.println("Stack: " + pilha); System.out.print("Pilha: ["); while (!pilha.empty()) { Integer info = (Integer) pilha.pop(); System.out.print(info + ", "); } System.out.println("\b\b]"); // cast para Integer } } Exemplo para testar o programa: Nodo: 10 <enter> Nodo: 20 <enter> Nodo: 30 <enter> Nodo: 40 <enter> Nodo: 50 <enter> Nodo: 60 <enter> Nodo: 0 <enter> Stack: [10, 20, 30, 40, 50, 60] Pilha: [60, 50, 40, 30, 20, 10] Programa Exemplo: Uma pilha utilizando a classe Stack e alguns dos seus métodos, permitindo procurar um elemento na pilha e retornando sua posição. Considere que a primeira posição é zero (0). // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgStack.java 111 package progstack; import java.util.Scanner; import java.util.Stack; public class ProgStack { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); int valor; do { System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { pilha.push(valor); } } while (valor != 0); do { System.out.print("Procurar: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { int posicao = pilha.search(valor); // procura elemento que contém o “valor” if (posicao == -1) { System.out.println("ERRO: Elemento não encontrado"); } else { System.out.println("Posição: " + posicao); } } } while (valor != 0); } } 112 Exemplo para testar o programa: Valor: 10 <enter> Valor: 20 <enter> Valor: 30 <enter> Valor: 40 <enter> Valor: 50 <enter> Valor: 0 <enter> Procurar: 30 <enter> Posição: 3 Procurar: 80 <enter> ERRO: Elemento não encontrado Procurar: 0 <enter> 6.2 Implementação de uma Fila (Queue) A seguir é visto uma implementação de uma Fila usando a classe Fila e Queue (LinkedList). Programa exemplo: Permite inserir números inteiros em uma Fila utilizando uma classe Fila implementada pelo programador. Quando o número digitado for igual à zero (0), todos os números da fila são listados. // -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Fila.java package progfila; public class Fila { // ---------------------------------------- atributos da classe private int inic, fim, n; private final int [] dados; // ---------------------------------------- construtor Fila(int numElementos) { inic = -1; fim = 0; n = 0; dados = new int[numElementos]; } // ------------------------------------------------ insereFila public void insereFila(int i) { int max = dados.length; if (n < max) { dados[fim] = i; fim++; n++; } else System.out.println("Erro: Fila Cheia"); } // ------------------------------------------------ retiraFila public int retiraFila() { if (n != 0) { inic++; n--; return(dados[inic]); } else return(0); } // ------------------------------------------------ isEmptyFila public boolean isEmptyFila() { if (n != 0) { 113 return(false); } else { return(true); } } } // ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgFila.java package progfila; import java.util.Scanner; public class ProgFila { public static void main(String[] args) { Fila fila = new Fila(5); Scanner entrada = new Scanner(System.in); int nodo, nodos = 0; do { System.out.print("Elemento: "); String s = entrada.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { fila.insereFila(nodo); nodos++; } } while (nodo != 0); String extenso = ""; System.out.print("Fila: ["); nodo = fila.retiraFila(); if (nodo != 0) { extenso = extenso + nodo + ", "; } while (!fila.isEmptyFila()) { nodo = fila.retiraFila(); extenso = extenso + nodo + ", "; } if (nodos == 0) { System.out.print(extenso + "]\n"); } else { System.out.print(extenso + "\b\b]\n"); } } } 114 Exemplo para testar o programa: Elemento: 10 <enter> Elemento: 20 <enter> Elemento: 30 <enter> Elemento: 40 <enter> Elemento: 50 <enter> Elemento: 60 <enter> Erro: Fila Cheia Elemento: 0 <enter> Fila: [10, 20, 30, 40, 50] Queue (Fila) import java.util.Queue; A interface Queue é utilizada para armazenar elementos em uma Fila. A seguir são descritos os principais métodos da interface Queue. Sintaxe: E element(); Recupera, mas não remove, o primeiro da fila. Sintaxe: boolean offer(E elemento); Insere o elemento dentro desta fila, se possível. Sintaxe: E peek(); Recupera, mas não remove, o primeiro da fila, retornando null se esta fila está vazia. Sintaxe: E poll(); Recupera e remove o primeiro da fila, ou null se esta fila está vazia. Sintaxe: E remove(); Recupera e remove o primeiro da fila. Sintaxe: boolean isEmpty() Retorna true se a Fila está vazia ou false se ela não está vazia Programa Exemplo: Mostra uma fila utilizando a classe Queue e LinkedList e seus principais métodos. // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgQueue.java package progqueue; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgQueue { public static void main(String[] args) { Queue fila = new LinkedList(); // Fila é implementada como uma Lista Encadeada Simples (LinkedList) Scanner input = new Scanner(System.in); String extenso = ""; int nodo; do { System.out.print("Nodo: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { fila.offer(nodo); } } while (nodo != 0); System.out.println("Queue: " + fila); 115 if (!fila.isEmpty()) { do { extenso = extenso + fila.poll() + ", "; } while (!fila.isEmpty()); } if (extenso.equals("")) { System.out.println("Fila: []"); } else { System.out.println("Fila: [" + extenso + "\b\b]"); } } } Exemplo para testar o programa: Nodo: 10 <enter> Nodo: 20 <enter> Nodo: 30 <enter> Nodo: 40 <enter> Nodo: 50 <enter> Nodo: 0 <enter> Queue: [10, 20, 30, 40, 50] Fila: [10 ,20, 30, 40, 50] Programa Exemplo: Mostra uma Fila utilizando a classe Queue e LinkedList e seus principais métodos. A diferença do ProgQueue é que neste os elementos são retirados da Fila usando-se um cast para Integer e não usando uma String temporária. // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgQueue2.java package progqueue2; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgQueue2 { public static void main(String[] args) { Queue fila = new LinkedList(); // Fila é implementada com uma Lista Encadeada Simples Scanner input = new Scanner(System.in); Integer nodo; do { System.out.print("Nodo: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { fila.offer(nodo); } } while (nodo != 0); System.out.println("Queue: " + fila); System.out.print("Fila: ["); if (!fila.isEmpty()) { do { nodo = (Integer) fila.poll(); System.out.print(nodo + ", "); } while (!fila.isEmpty()); System.out.println("\b\b]"); } else { System.out.println("]"); } // cast para Integer } } 116 Exemplo para testar o programa: Nodo: 10 <enter> Nodo: 20 <enter> Nodo: 30 <enter> Nodo: 40 <enter> Nodo: 50 <enter> Nodo: 0 <enter> Queue: [10, 20, 30, 40, 50] Fila: [10 ,20, 30, 40, 50] Observação: No programa exemplo acima, a Fila (Queue) foi implementada como uma lista encadeada simples (LinkedList). 6.3 Implementação de um Deque (ArrayDeque) A seguir é visto uma implementação de um Deque (Figura 7) utilizando a classe Deque e ArrayDeque. Figura 7: Representação visual de um Deque Programa exemplo: Permite inserir números inteiros em um Deque (pelos lados esquerdo ou direito) utilizando uma classe Deque implementada pelo programador. Para finalizar a entrada dos dados, digite zero (0). // ---------------------------------------------------------------------------------------------------------------------------------------- Classe: Deque.java package progdeque; public class Deque { private final int[] vetor; private int inic; private int fim; private int n; // --------------------------------------------------------- construtor public Deque(int numeroElementos) { inic = -1; fim = 0; n = 0; vetor = new int[numeroElementos]; } 117 // ------------------------------------------------------------ insereDequeDireita public void insereDequeDireita(int i) { int max = vetor.length; if (n < max) { vetor[fim] = i; fim++; n++; } else { System.out.println("Erro: Deque Cheia à Direita"); } } // ------------------------------------------------------------------- insereDequeEsquerda public void insereDequeEsquerda(int valor) { int max = vetor.length; if (n < max) { for (int i = n; i > 0; i--) { vetor[i] = vetor[i - 1]; } vetor[0] = valor; fim++; n++; } else { System.out.println("Erro: Deque Cheia à Esquerda"); } } // ------------------------------------------------ retiraDequeDireita public int retiraDequeDireita() { if (n != 0) { fim--; int valor = vetor[fim]; n--; return (valor); } else { return (0); } } // ---------------------------------------------------- retiraDequeEsquerda public int retiraDequeEsquerda() { if (n != 0) { inic++; n--; return (vetor[inic]); } else { return (0); } } // -------------------------------------------------- emptyDeque public boolean emptyDeque() { if (n == 0) { return (true); } else { return (false); } } // -------------------------------------------------- exibeDeque public void exibeDeque() { System.out.print("Deque: ["); if (n == 0) { System.out.println("]"); } else { for (int i = 0; i < n; i++) { 118 System.out.print(vetor[i] + ", "); } System.out.println("\b\b]"); } } } // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgDeque.java package progdeque; import java.util.Scanner; public class ProgDeque { public static void main(String[] args) { Deque deque = new Deque(5); Scanner input = new Scanner(System.in); int nodo; char op; do { deque.exibeDeque(); System.out.print("Elemento: "); String s = input.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) { do { System.out.print("[E]squerda ou [D]ireita: "); s = input.nextLine(); op = s.charAt(0); } while ("EeDd".indexOf(op) == -1); if (nodo != 0) { switch (op) { case 'E': case 'e': deque.insereDequeEsquerda(nodo); break; case 'D': case 'd': deque.insereDequeDireita(nodo); break; } } } } while (nodo != 0); do { int esquerda = deque.retiraDequeEsquerda(); if (esquerda == 0) { System.out.println("Deque: Vazia à esquerda"); } else { System.out.println("Esquerda: " + esquerda); } int direita = deque.retiraDequeDireita(); if (esquerda == 0) { System.out.println("Deque: Vazia à direita"); } else { System.out.println("Direita: " + direita); } } while (!deque.emptyDeque()); } } Exemplo para testar o programa: Deque: [] Elemento: 10 <enter> 119 [E]squerda ou [D]ireita: e <enter> Deque: [10] Elemento: 20 <enter> [E]squerda ou [D]ireita: d <enter> Deque: [10, 20] Elemento: 30 <enter> [E]squerda ou [D]ireita: d <enter> Deque: [10, 20, 30] Elemento: 40 <enter> [E]squerda ou [D]ireita: d <enter> Deque: [10, 20, 30, 40] Elemento: 50 <enter> [E]squerda ou [D]ireita: d <enter> Deque: [10, 20, 30, 40, 50] Elemento: 60 <enter> [E]squerda ou [D]ireita: d <enter> Erro: Deque Cheia à Direita Deque: [10, 20, 30, 40, 50] Elemento: 60 <enter> [E]squerda ou [D]ireita: e <enter> Erro: Deque Cheia à Esquerda Deque: [10, 20, 30, 40, 50] Elemento: 0 <enter> Esquerda: 10 Direita: 50 Esquerda: 20 Direita: 40 Esquerda: 30 Direita: 0 Java possui classes pré-definidas para trabalhar com Deque: ArrayDeque, LinkedBlockingDeque e LinkedList. Construtores: ArrayDeque() Construi um deque em um array vazio com 16 elementos. ArrayDeque(int numeroElements); Construi um deque em um array vazio com numeroElements elementos. A seguir são descritos os métodos da classe ArrayDeque. Sintaxe: boolean add(E elemento); Insere o elemento no fim do deque. Sintaxe: void addFirst(E elemento); Insere o elemento no início do deque. Sintaxe: void addLast(E elemento); Insere o elemento do final do deque. Sintaxe: void clear(); Remove todos os elementos do deque. Sintaxe: ArrayDeque<E> clone(); Retorna uma cópia do deque. Sintaxe: boolean contains(Object objeto); Retorna true se o deque contém o objeto. Sintaxe: Iterator<E> descendingIterator(); Retorna um iterator sobre os elementos no deque em ordem sequencial reversa. Sintaxe: E element(); 120 Recupera, mas não remove, o elemento corrente da fila representada pelo deque. Sintaxe: E getFirst(); Recupera, mas não remove, o primeiro elemento do deque. Sintaxe: E getLast(); Recupera, mas não remove, o último elemento do deque. Sintaxe: boolean isEmpty(); Retorna true se o deque não contém elementos. Sintaxe: Iterator <E> iterator(); Retorna o iterator sobre os elementos do deque. Sintaxe: boolean offer(E elemento); Insere o elemento no fim do deque. Sintaxe: boolean offerFirst(E elemento); Insere o elemento no início do deque. Sintaxe: boolean offerLast(E elemento); Insere o elemento no final do deque. Sintaxe: E peek(); Recupera, mas não remove, o elemento corrente da fila representada pelo deque ou retorna null se o deque está vazio. Sintaxe: E peekFirst(); Recupera, mas não remove, o primeiro elemento do deque, ou retorna null se o deque está vazio. Sintaxe: E peekLast(); Recupera, mas não remove, o último elemento do deque ou retorna null se o deque está vazio. Sintaxe: E poll(); Recupera e remove o elemento corrente da fila representada pelo deque ou retorna null se este deque está vazio. Sintaxe: E pollFirst(); Recupera e remove o primeiro elemento do deque ou retorna null se o deque está vazio. Sintaxe: E pollLast(); Recupera e remove o último elemento do deque ou retorna null se o deque está vazio. Sintaxe: E pop(); Retira um elemento na pilha representada por este deque. Sintaxe: void push(E elemento); Insere um elemento na pilha representada por este deque. Sintaxe: E remove(); Recupera e remove o cabeça da fila representado por este deque. Sintaxe: boolean remove(Object objeto); Remove a instância de um objeto deste deque. Sintaxe: E removeFirst(); Recupera e remove o primeiro elemento do deque. Sintaxe: boolean removeFirstOccurrence(Object objeto); Remove a primeira ocorrência do objeto do deque (quando percorre o deque do primeiro ao último). Sintaxe: E removeLast(); Recupera e remove o último elemento do deque. Sintaxe: boolean removeLastOccurrence(Object objeto); Remove a última ocorrência do objeto do deque (quando percorre o deque do primeiro ao último). Sintaxe: int size(); Retorna o número de elementos do deque. 121 Sintaxe: Object[] toArray(); Retorna um array contendo todos os elementos do deque em ordem crescente (do primeiro até o último elemento). Sintaxe: <T> T[] toArray(T[] array); Retorna um array contendo todos os elementos do deque em ordem crescente (do primeiro até o último elemento); o tipo do array retornado é aquele especificado pelo array. A seguir é demonstrado a utilização de um Deque através da classe ArrayDeque e seus principais métodos. Pacote: import java.util.ArrayDeque; // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgArrayDeque.java package progarraydeque; import java.util.ArrayDeque; import java.util.Scanner; public class ProgArrayDeque { public static void main(String[] args) { ArrayDeque deque = new ArrayDeque(); Scanner entrada = new Scanner(System.in); String s; char tecla = 'f', op = 'f'; int = 0; Integer nodo; // aloca com 16 elementos do { System.out.println("Deque: " + deque); System.out.print("[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: "); do { s = entrada.nextLine(); if (!s.equals("")) { tecla = s.charAt(0); } } while (!strChr("IiCcEeFf", tecla)); if (!strChr("Ff", tecla)) { System.out.print("[E]squerda ou [D]ireita: "); do { s = entrada.nextLine(); if (!s.equals("")) { op = s.charAt(0); } } while (!strChr("EeDd", op)); switch (tecla) { case 'I': case 'i': System.out.print("Nodo: "); s = entrada.nextLine(); nodo = Integer.parseInt(s); if (strChr("Ee", op)) { deque.addFirst(nodo); } else { deque.addLast(nodo); } n++; if (n > 16) { System.out.println("ERRO: Deque Cheio"); System.exit(1); } break; case 'C': case 'c': if (!deque.isEmpty()) { if (strChr("Ee", op)) { 122 nodo = (Integer) deque.peekFirst(); } else { nodo = (Integer) deque.peekLast(); } System.out.println("Consultado: " + nodo); } else { System.out.println("ERRO: Deque Vazio"); } break; case 'E': case 'e': if (!deque.isEmpty()) { if (strChr("Ee", op)) { nodo = (Integer) deque.pollFirst(); } else { nodo = (Integer) deque.pollLast(); } System.out.println("Excluiu: " + nodo); n--; } else { System.out.println("ERRO: Deque Vazio"); } break; // cast // cast } } } while (!strChr("Ff", tecla)); } // --------------------------------------------------------------- strChr static boolean strChr(String s, char tecla) { int n = s.length(); for (int i = 0;i < n;i++) { if (s.charAt(i) == tecla) { return(true); } } return(false); } } Exemplo para testar o programa: Deque: [] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i <enter> [E]squerda ou [D]ireita: e <enter> Nodo: 10 <enter> Deque: [10] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i <enter> [E]squerda ou [D]ireita: d <enter> Nodo: 20 <enter> Deque: [10, 20] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i <enter> [E]squerda ou [D]ireita: d <enter> Nodo: 30 <enter> Deque: [10, 20, 30] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: f <enter> 6.4 Lista de Exercícios: Listas Lineares (Pilhas, Filas e Deques) 6.4.1 Escreva um programa em Java que leia um nome via teclado. Logo após a entrada utilize uma Pilha (caracteres) para armazenar as letras da abreviatura deste nome. Exiba a abreviatura invertida do nome extraída da pilha, a pilha vazia e ainda o número de letras da abreviatura, conforme exemplo abaixo. 123 Entrada: Nome: paulo roberto gomes luzzardi <enter> Saída: Abreviatura: LGRP Pilha: [] Total de Letras: 4 6.4.2 Escreva um programa em Java que leia um nome via teclado. Logo após a entrada utilize uma Fila (caracteres) para armazenar e exibir (na tela do computador) todos os carateres deste nome SEM ESPAÇOS EM BRANCO e ainda o número de espaços eliminados na exibição, conforme exemplo abaixo. Entrada: Nome: paulo roberto gomes luzzardi <enter> Saída: Nome Modificado: paulorobertogomesluzzardi Número de Espaços eliminados: 3 6.4.3 Escreva um programa em Java que lê nomes via teclado. Para cada nome digitado pelo usuário, armazene em uma Pilha [f] para feminino, [m] para masculino ou [i] para indeterminado, conforme exemplo abaixo. Ao final imprima a Pilha, o total de homens, o total de mulheres e o total de indeterminados. Entrada: Nome: Debora <enter> Nome: Carla <enter> Nome: Beatriz <enter> Nome: Paulo <enter> Nome: Renato <enter> Nome: <enter> Saída: Pilha: [m, m, i, f, f] 2 homens 2 mulheres 1 indeterminados 6.4.4 Escreva um programa em Java que recebe “n” nomes via teclado (até que o usuário digite apenas <enter>). Insira todos os nomes ORDENADOS em uma Fila de Strings (conforme exemplo abaixo). Ao final, o programa deve exibir a Fila contendo os nomes em ordem alfabética (a saída dos dados deve ser exatamente igual ao exemplo abaixo). Entrada: Nome: Debora <enter> Nome: Carla <enter> Nome: Eva <enter> Nome: Beatriz <enter> Nome: Ana <enter> Nome: <enter> Saída: Fila: [Ana, Beatriz, Carla, Debora, Eva] 6.4.5 Escreva um programa em Java que recebe via teclado: valor e quantidade. O programa deve inserir ambos valores em uma Fila (conforme exemplo abaixo). Ao final, o programa deve exibir a Fila e após extrair todos os valores e quantidades imprimindo-os na tela conforme suas quantidades (conforme exemplo abaixo) e ainda o total de valores impressos. Entrada: Saída: Valor: 10 <enter> Quantidade: 3 <enter> Valor: 20 <enter> Quantidade: 4 <enter> Valor: 30 <enter> Quantidade: 2 <enter> Valor: 0 <enter> // saída do programa Fila: [10, 3, 20, 4, 30, 2] Saída: 10 10 10 20 20 20 20 30 30 Total de Valores Impressos: 9 124 6.4.6 Escreva um programa em Java que recebe “n” nomes via teclado (até que o usuário digite apenas <enter>). Para cada nome digitado, insira a quantidade de caracteres de cada palavra em uma Pilha de inteiros (conforme exemplo abaixo). Ao final, o programa deve exibir: (a) Pilha criada com as referidas quantidades, o total de caracteres contidos na pilha de quantidades, o total de nomes digitadas pelo usuário e a pilha vazia após as contagens (a saída dos dados deve ser exatamente igual ao exemplo abaixo). Entrada: Nome: Paulo <enter> Nome: Roberto <enter> Nome: Gomes <enter> Nome: Luzzardi <enter> Nome: <enter> Saída: Pilha: [5 7 5 8] Total de Caracteres: 25 letra(s) Total de Nomes: 4 Pilha: [] 6.4.7 Escreva um programa em Java que lê um nome qualquer via teclado. Logo após a entrada utilize uma Pilha (caracteres) e uma Fila (caracteres) para armazenar apenas as consoantes (Fila) e as vogais (Pilha) deste nome, respectivamente. Exiba a Fila e a Pilha gerada, conforme exemplo abaixo. Entrada: Nome: paulo roberto gomes luzzardi <enter> Saída: Fila: [p, l, r, b, r, t, g, m, s, l, z, z, r, d] Pilha: [i, a , u , e , o , o , e , o , o , u, a] 6.4.8 Escreva um programa em Java que lê um nome qualquer via teclado. Logo após a entrada utilize uma pilha ou uma fila (caracteres) para exibir o nome invertido, conforme exemplo abaixo. Entrada: Nome: paulo roberto gomes luzzardi <enter> Saída: Nome Invertido: idrazzul semog otrebor oluap 6.4.9 Escreva um programa em Java que lê um nome via teclado. Logo após a entrada utilize uma Pilha (caracteres) e uma Fila (caracteres) para armazenar apenas as consoantes (Fila) e as vogais (Pilha) deste nome, respectivamente. Exiba a Fila, o total de consoantes, Pilha, o total de vogais e o total de letras, exatamente conforme o exemplo abaixo. Entrada: Nome: paulo roberto gomes luzzardi <enter> Saída: Fila: [p, l, r, b, r, t, g, m, s, l, z, z, r, d] Total de Consoantes: 14 Fila: [] Pilha: [a, u, o, o, e, o, o, e, u, a, i] Total de Vogais: 11 Pilha: [] Total de Letras: 25 6.4.10 Escreva um programa em Java que lê um nome qualquer via teclado. Logo após a entrada utilize uma Fila para inserir todas as palavras no nome e uma Pilha para armazenar apenas iniciais de cada palavra do nome. Exiba a Fila e a Pilha gerada, conforme exemplo abaixo. Entrada: Nome: Paulo Roberto Gomes Luzzardi <enter> Saída: Fila: [Paulo, Roberto, Gomes, Luzzardi] <- fim da fila Pilha: [P, R, G, L] <- topo da pilha 6.4.11 Implemente um programa em Java que possui duas pilhas: p1 e p2. Insira “n” números na pilha (p1), para cada valor inserido na pilha (p1), duplique e armazene o valor na segunda pilha (p2). Quando o usuário 125 digitar 0 (zero), o programa deve imprimir ambas as pilhas e o conteúdo das duas pilhas em ordem crescente. Entrada: Valor: 10 <enter> Valor: 20 <enter> Valor: 30 <enter> Valor: 0 <enter> Saída: p1: [10, 20, 30] p2: [20, 40, 60] Pilhas: 10 20 20 30 40 60 30 20 10 p1 60 40 20 p2 6.4.12 Implemente um programa em Java que possui duas filas: f1 e f2. Insira “n” números na fila (f1) até que o usuário digite 0 (zero). O programa deve então excluir todos os valores da fila (f1) e inseri-los na fila (f2) triplicando cada valor. Ao final o programa deve imprimir ambas as filas, o maior e o menor valor de ambas as filas. Entrada: Valor: 10 <enter> Valor: 20 <enter> Valor: 30 <enter> Valor: 0 <enter> Saída: f1: [] f2: [30, 60, 90] Maior: 90 Menor: 10 30 20 10 f1 90 60 30 f2 6.4.13 Escreva um programa em Java que lê uma palavra via teclado. Logo após a entrada utilize uma pilha para inverter e exibir esta palavra na tela e ainda o número de letras da palavra (conforme exemplo abaixo). Entrada: Palavra: pelotas <enter> Saída: Palavra Invertida: satolep Total de Letras: 7 6.4.14 Escreva um programa em Java que recebe via teclado: valor inicial, valor final e intervalo. O programa deve inserir “n” valores em uma Fila (desde o valor inicial até o valor final levando em consideração o intervalo entre eles)(conforme exemplo abaixo). Ao final, o programa deve exibir a Fila criada com estes valores. O programa acaba quando o valor inicial for igual a zero. Exemplo para testar o programa: Valor Inicial: 10 <enter> Valor Final: 70 <enter> Intervalo: 10 <enter> Fila: [10, 20, 30, 40, 50, 60, 70] Valor Inicial: 60 <enter> Valor Final: 20 <enter> Intervalo: 5 <enter> Fila: [60, 55, 50, 45, 40, 35, 30, 25, 20] Valor Inicial: 0 <enter> 6.4.15 Escreva um programa em Java que recebe “n” valores inteiros via teclado. O programa deve inserir cada inteiro em uma Pilha (Stack) e dobrar o valor e inserir em uma Fila (Queue). Ao final, o programa deve exibir na tela todas as informações contidas no exemplo abaixo. O programa termina quando o usuário digitar zero (0) na entrada das informações. Entrada: Nodo: 100 <enter> Nodo: 200 <enter> Nodo: 300 <enter> Nodo: 0 <enter> 126 Saída: Pilha: [100, 200, 300] Topo da Pilha: 300 Base da Pilha: 100 Número de Elementos da Pilha: 3 Fila: [200, 400, 600] Primeiro Elemento da Fila: 200 Número de Elementos da Fila: 3 ou Entrada: Nodo: 0 <enter> Saída: Pilha: [] Fila: [] 127 7. Mapas (Maps) 7.1 Conceitos básicos sobre Mapas Maps associam chaves à valores, onde as chaves devem ser únicas, mas os valores não. Maps utilizam o conceito de Tabelas Hash (Figura 8), onde as Tabelas Hash são estruturas que permitem associar uma chave a um valor. Elas permitem acesso aos valores através de sua chave associada. Uma chave é calculada através de uma função em uma posição na Tabela Hash. Tanto a localização (armazenamento) e a recuperação da chave é feita da mesma forma, ou seja, através de um cálculo matemático. Figura 8: Representação gráfica de uma Tabela Hash (Hashtable) Java utiliza a classe HashTable para manipular este tipo de estrutura de dados complexa. Para manipular elementos na tabela Hash, são usados os seguintes métodos: Sintaxe: public V put(K chave, V valor); Armazena um par de objetos na tabela Hash. Sintaxe: public V get(Object chave) Retorna o objeto associado ao objeto chave. Sintaxe: public V remove(Object chave); Remove o par de objetos com a chave. Sintaxe: public boolean containsKey(Object chave). Consulta se uma determinada chave existe na tabela. Sintaxe: public boolean contains(Object valor); Verifica se um determinado valor está presente na tabela associado a qualquer chave. Sintaxe: public int size(); Retorna o número de pares de elementos na tabela. Alguns tipos de Maps: HashTable (ordem ascendente), HashMap (ordem ascendente), TreeMap (ordem ascendente) e LinkedHashMap (ordem de inclusão). Exemplos de Mapas com HashTable: (Observação: pacote obsoleto) // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgHashTable.java package proghashtable; import java.util.Hashtable; public class ProgHashTable { public static void main(String args[]) { 128 Hashtable pessoa = new Hashtable(); pessoa.put(20, "Beatriz"); // chave, valor pessoa.put(30, "Carla"); // chave, valor pessoa.put(10, "Ana"); // chave, valor System.out.println("Tamanho da Hashtable: " + pessoa.size()); System.out.println("Tabela Hash: " + pessoa.toString()); pessoa.clear(); } } Resultado do Programa: Tamanho da Hashtable: 3 Tabela Hash: {10=Ana, 20=Beatriz, 30=Carla} Exemplos de Mapas com HashMap: // ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgMap1.java package progmap1; import java.util.HashMap; import java.util.Map; public class ProgMap1 { public static void main(String[] args) { Map <Integer, String> mapa = new HashMap<>(); mapa.put(2, "Beatriz"); mapa.put(5, "Eva"); mapa.put(1, "Ana"); mapa.put(3, "Carla"); mapa.put(4, "Debora"); System.out.println("Mapa: " + mapa.toString()); } } Resultado do Programa: Mapa: {1=Ana, 2=Beatriz, 3=Carla, 4=Debora, 5=Eva} // ---------------------------------------------------------------------------------------------------------- Programa principal: ProgMap2.java package progmap2; import java.util.HashMap; import java.util.Map; public class ProgMap2 { public static void main(String[] args) { Map <Integer, String> mapa = new HashMap<>(); mapa.put(4, "Debora"); mapa.put(2, "Beatriz"); mapa.put(5, "Eva"); mapa.put(1, "Ana"); mapa.put(3, "Carla"); System.out.println("Chaves: " + mapa.keySet()); System.out.println("Valores: " + mapa.values()); } } Resultado do Programa: Chaves: [1, 2, 3, 4, 5] Valores: [Ana, Beatriz, Carla, Debora, Eva] 129 // ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap3.java package progmap3; import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.TreeSet; public class ProgMap3 { public static void main(String[] args) { Map <String, Integer> mapa = new HashMap<>(); mapa.put("Eva", 5); mapa.put("Beatriz", 2); mapa.put("Carla", 3); mapa.put("Ana", 1); mapa.put("Debora", 4); Set <String> keys = mapa.keySet(); // carrega as chaves TreeSet <String> sortedkeys = new TreeSet<> (keys); // ordena as chaves for (String key : sortedkeys) { // exibe as chaves em ordem System.out.println("Chave: " + mapa.get(key) + " | Pessoa: " + key); } } } Resultado do Programa: Chave: 1 | Pessoa: Ana Chave: 2 | Pessoa: Beatriz Chave: 3 | Pessoa: Carla Chave: 4 | Pessoa: Debora Chave: 5 | Pessoa: Eva // ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap4.java package progmap4; import java.util.HashMap; import java.util.Map; public class ProgMap4 { public static void main(String[] args) { Map<Integer, String> mapa = new HashMap<>(); mapa.put(5, "Eva"); mapa.put(2, "Beatriz"); mapa.put(3, "Carla"); mapa.put(1, "Ana"); mapa.put(4, "Debora"); int n = mapa.size(); for (int i = 1; i <= n; i++) { System.out.println("Chave: " + i + " | Pessoa: " + mapa.get(i)); } } } Resultado do Programa: Chave: 1 | Pessoa: Ana Chave: 2 | Pessoa: Beatriz Chave: 3 | Pessoa: Carla Chave: 4 | Pessoa: Debora Chave: 5 | Pessoa: Eva // ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap5.java 130 package progmap_5; import java.util.HashMap; import java.util.Map; public class ProgMap_5 { public static void main(String[] args) { Map<String, String> mapa = new HashMap<>(); mapa.put("E", "Eva"); mapa.put("B", "Beatriz"); mapa.put("C", "Carla"); mapa.put("A", "Ana"); mapa.put("D", "Debora"); System.out.println("Número de Elementos do Mapa: " + mapa.size()); // listando o número de elementos do mapa System.out.println("Mapa: " + mapa); // listando todo o mapa System.out.print("Chaves: "); // listando as chaves for (String st : mapa.keySet()) { System.out.print(st + " "); } System.out.print("\nValores: "); // listando os valores for (String st : mapa.values()) { System.out.print(st + " "); } System.out.println(); } } Resultado do Programa: Número de Elementos do Mapa: 5 Mapa: {D=Debora, E=Eva, A=Ana, B=Beatriz, C=Carla} Chaves: D E A B C Valores: Debora Eva Ana Beatriz Carla Exemplos de Mapas com TreeMap: // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgTreeMap.java package progtreemap; import java.util.TreeMap; public class ProgTreeMap { public static void main(String[] args) { TreeMap<String, Integer> alunos = new TreeMap<>(); alunos.put("Carla", 17); alunos.put("Debora", 18); alunos.put("Beatriz", 19); alunos.put("Ana", 20); // ordem ascendente for (String key : alunos.keySet()) { System.out.printf("%-7s -> %2d\n",key, alunos.get(key)); } System.out.println("keySet: " + alunos.keySet()); alunos.clear(); } } Resultado do Programa: Ana -> 20 Beatriz -> 19 Carla -> 17 Debora -> 18 keySet: [Ana, Beatriz, Carla, Debora] 131 // -------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashMap.java package proglinkedhashmap; import java.util.LinkedHashMap; public class ProgLinkedHashMap { public static void main(String[] args) { LinkedHashMap pessoa = new LinkedHashMap(); pessoa.put("Carla", 67.12); pessoa.put("Debora", 70.23); pessoa.put("Ana", 56.13); pessoa.put("Beatriz", 57.45); pessoa.put("Eva", 59.12); System.out.println("Mapa: " + pessoa.toString()); for (Object key : pessoa.keySet()) { System.out.printf("%-7s -> %.2f\n", key, pessoa.get(key)); } } } Resultado do Programa: Mapa: {Carla=67.12, Debora=70.23, Ana=56.13, Beatriz=57.45, Eva=59.12} Carla -> 67,12 Debora -> 70,23 Ana -> 56,13 Beatriz -> 57,45 Eva -> 59,12 7.2 Lista de Exercícios: Mapas 7.2.1 Escreva um programa em Java que utiliza uma LinkedHashMap e tenha o seguinte resultado: Resultado do Programa: Carla -> (2) Eva -> (4) Ana -> (0) Beatriz -> (1) Debora -> (3) Mapa: Ana Beatriz Carla Debora Eva 7.2.2 Escreva um programa em Java que utiliza uma TreeMap e tenha o seguinte resultado: Resultado do Programa: Ana -> A Beatriz -> B Carla -> C Debora -> D keySet: [Ana, Beatriz, Carla, Debora] 7.2.3 Escreva um programa em Java que utiliza uma Map e tenha o seguinte resultado: Resultado do Programa: Chave: 1 | Pessoa: Ana | Bytes: 3 Chave: 2 | Pessoa: Beatriz | Bytes: 7 Chave: 3 | Pessoa: Carla | Bytes: 5 Chave: 4 | Pessoa: Debora | Bytes: 6 Chave: 5 | Pessoa: Eva | Bytes: 3 132 7.2.4 Escreva um programa em Java que utiliza uma HashTable e tenha o seguinte resultado: Resultado do Programa: Tamanho da Hashtable: 3 Chaves: [10, 20, 30] Valor: [Ana, Beatriz, Carla] 7.2.5 Escreva um programa em Java que utiliza um Map (HashMap) e tenha o seguinte resultado: Resultado do Programa: Número de Elementos do Mapa: 5 Mapa: {D=Debora, E=Eva, A=Ana, B=Beatriz, C=Carla} Chaves: [D, E, A, B, C] Valores: [Debora, Eva, Ana, Beatriz, Carla] 133 8. Processamento de fluxos de dados, caracteres e objetos (Arquivos) Fluxos de dados ou streams são utilizados para manipulação de arquivos em Java. Arquivos são abstrações utilizadas para que um programa interaja com os dispositivos de saída, conectados ao computador, através de operações de gravação e leitura de dados. Este conceito virtual foi extraído do conceito real da utilização de arquivos físicos (armários cinzas de ferro), onde abria-se as gavetas, coloca-se e retira-se fichas de dentro dele. Java descreve um arquivo como se fosse um fluxo sequencial de caracteres (terminado por EOF – End Of File) ou bytes (pelo número total de bytes). Há dois tipos de arquivos em Java: Binário: Baseado em stream de bytes, onde um conjunto de bytes é escrito e lido do disco em blocos (Figura 11). Texto: Baseado em uma fila (stream) de caracteres (Figuras 9 e 10). Caracteres são armazenados e recuperados como uma sequência de caracteres separada por linhas terminadas por um caractere de fim de linha (\n) e uma marca no final do arquivo EOF (End Of File). Figura 9: Exemplo de um arquivo texto 134 Figura 10: Editor hexadecimal mostrando o arquivo texto Note que num arquivo texto é possível distinguir e interpretar os caracteres presentes no arquivo, ou seja, eles são codificados na linguagem natural das pessoas (texto legível visto acima à direita da Figura 10), onde cada caracter ocupa um byte na memória (8 bits). Figura 11: Editor hexadecimal mostrando o arquivo binário Note que num arquivo binário não é possível distinguir e interpretar os caracteres presentes no arquivo, ou seja, eles não são codificados na linguagem natural das pessoas (texto ilegível visto acima à direita da Figura 11) e sim como um conjunto de bytes representando cada caracter. Observação: Os códigos acima estão em hexadecimal, onde 0x41 é 65 em decimal (ou letra A), por exemplo. Em Java é possível manipular arquivos através da classe File (Arquivo). 135 8.1 Métodos para manipular arquivos em Java A seguir são descritos os principais métodos para manipular arquivos em Java: Sintaxe: boolean canRead(); Testa se o aplicativo pode ler o arquivo indicado pelo pathname (caminho). Sintaxe: boolean canWrite(); Testa se o aplicativo pode modificar o arquivo indicado pelo pathname (caminho). Sintaxe: int compareTo(File nomeCaminho); Compara dois pathnames lexicograficamente. Sintaxe: int compareTo(Object objeto); Compara o pathname com outro objeto. Sintaxe: boolean createNewFile(); Cria um novo arquivo vazio com o nome do pathname, se e somente se um arquivo com este nome ainda não existe. Sintaxe: static File createTempFile(String prefixo, String sufixo); Cria um arquivo vazio no diretório de arquivos temporários, usando o prefixo e o sufixo dado para gerar o seu nome. Sintaxe: static File createTempFile(String prefixo, String sufixo, File diretório); Cria um novo arquivo vazio no diretório especificado, usando o prefixo e o sufixo dado pela string para gerar o seu nome. Sintaxe: boolean delete(); Deleta o arquivo ou diretório informado no pathname. Sintaxe: void deleteOnExit(); Solicita que o arquivo ou diretório indicado por este pathname seja excluído quando a máquina virtual termina. Sintaxe: boolean equals(Object objeto); Testa se o pathname é igual ao objeto indicado. Sintaxe: boolean exists(); Testa se o arquivo ou diretório indicado para este pathname existe. Sintaxe: File getAbsoluteFile(); Retorna a forma absoluta do pathname. Sintaxe: String getAbsolutePath(); Retorna uma string absoluta do pathname. Sintaxe: File getCanonicalFile(); Retorna a forma canônica do pathname. Sintaxe: String getCanonicalPath(); Retorna uma string canônica do pathname. 136 Sintaxe: String getName(); Retorna o nome do arquivo ou diretório indicado pelo pathname. Sintaxe: String getParent(); Retorna uma string do caminho pai, o caminho abstrato, ou nulo se este caminho não é nome de um diretório pai. Sintaxe: File getParentFile(); Retorna o caminho abstrato pai do caminho, ou nulo se este caminho não é nome de um diretório pai. Sintaxe: String getPath(); Converte este pathname em uma string do pathname. Sintaxe: int hashCode(); Calcula o código hash para este pathname. Sintaxe: boolean isAbsolute(); Testa se este pathname é absoluto Sintaxe: boolean isDirectory(); Testa se o arquivo indicado por este caminho (pathname) é um diretório. Sintaxe: boolean isFile(); Testa se o arquivo indicado por este caminho (pathname) é um arquivo (file). Sintaxe: boolean isHidden(); Testa se o arquivo indicado por este caminho (pathname) é um arquivo escondido. Sintaxe: long lastModified(); Retorna o tempo em que o arquivo indicado por este caminho foi modificado pela última vez. Sintaxe: long length(); Retorna o comprimento do arquivo indicado pelo pathname. Sintaxe: String[] list(); Retorna um vetor de strings com os nomes dos arquivos e diretórios no diretório indicado por este caminho. Sintaxe: String[] list(FilenameFilter filtro); Retorna um vetor de strings com os nomes de arquivos e diretórios no diretório indicado por este caminho que satisfaçam o filtro. Sintaxe: File[] listFiles(); Retorna um vetor de pathname indicando os arquivos no diretório indicado por este caminho. Sintaxe: File[] listFiles(FileFilter filtro); Retorna um vetor de pathname indicando os arquivos e diretórios no diretório indicado por este caminho que satisfaçam o filtro. Sintaxe: File[] listFiles(FilenameFilter filtro); Retorna um vetor de pathname indicando os arquivos e diretórios no diretório indicado por este caminho que satisfaçam o filtro. Sintaxe: static File[] listRoots(); Lista o sistema de arquivos disponíveis principais (root). Sintaxe: boolean mkdir(); Cria o diretório chamado por este caminho. Sintaxe: boolean mkdirs(); Cria o diretório chamado por este pathname, incluindo os diretórios pai necessários, mas inexistentes. Sintaxe: boolean renameTo(File dest); Renomeia o arquivo indicado pelo pathname. Sintaxe: boolean setLastModified(long time); Define o tempo da última modificação do arquivo ou diretório chamado por este caminho. Sintaxe: boolean setReadOnly(); Marca o arquivo ou diretório chamado por este caminho que só são permitidas operações de leitura. Sintaxe: String toString(); Retorna uma string pathname deste caminho. 137 Sintaxe: URI toURI(); Constrói um arquivo URI que representa esse caminho. Sintaxe: URL toURL(); Converte este caminho em um arquivo: URL. 8.2 Abertura de um arquivo texto A seguir são vistos alguns programas exemplos mostrando a manipulação de arquivos em Java. Programa exemplo: Abre um arquivo texto e exibe o número de bytes do referido arquivo. // -------------------------------------------------------------------------------------------------- Programa Principal: ProgAbreTexto.java package progabretexto; import java.io.File; public class ProgAbreTexto { public static void main(String[] args) { String nomeArquivo = "/Users/pluzzardi/luzzardi.txt"; File arqTexto = new File(nomeArquivo); if (arqTexto.exists()) { long bytes = arqTexto.length(); System.out.println("Arquivo: " + nomeArquivo); System.out.println("Bytes: " + bytes); } else { System.out.println("ERRO: Arquivo não existe"); } } } Resultado do Programa: Arquivo: /Users/pluzzardi/luzzardi.txt Bytes: 131 138 8.3 Listar um diretório Programa exemplo: Exibe na tela (lista) os arquivos e diretórios do pathname (caminho) especificado. // ------------------------------------------------------------------------------------------------ Programa Principal: ProgListaDiretorio.java package proglistadiretorio; import java.io.File; public class ProgListaDiretorio { public static void main(String[] args) { File diretorio = new File("//Users//pluzzardi"); String [] arquivos = diretorio.list(); for (String arquivo : arquivos) { File filho = new File(diretorio, arquivo); System.out.println(filho.getAbsolutePath()); } } } Resultado do Programa: /Users/pluzzardi/.bash_history /Users/pluzzardi/.CFUserTextEncoding /Users/pluzzardi/.config /Users/pluzzardi/.cups /Users/pluzzardi/.dropbox /Users/pluzzardi/.DS_Store /Users/pluzzardi/.gbas /Users/pluzzardi/.local /Users/pluzzardi/.netbeans-derby /Users/pluzzardi/.ssh /Users/pluzzardi/.Trash /Users/pluzzardi/.viminfo /Users/pluzzardi/Desktop /Users/pluzzardi/Documents /Users/pluzzardi/Downloads /Users/pluzzardi/Dropbox /Users/pluzzardi/frutas.luz /Users/pluzzardi/Frutas.txt /Users/pluzzardi/Leitura.zip /Users/pluzzardi/Library /Users/pluzzardi/luzzardi.dat /Users/pluzzardi/Luzzardi.txt /Users/pluzzardi/Movies /Users/pluzzardi/Music /Users/pluzzardi/NetBeansProjects /Users/pluzzardi/nomes.sort /Users/pluzzardi/nomes.txt /Users/pluzzardi/palavras.dat /Users/pluzzardi/pessoa.dat /Users/pluzzardi/pessoas.dat /Users/pluzzardi/Pictures /Users/pluzzardi/Projects /Users/pluzzardi/Public Programa exemplo: Exibe na tela (lista) os arquivos e diretórios do pathname especificado pelo usuário. // ------------------------------------------------------------------------------------- Programa Principal: ProgListaDiretorioUsuario.java package proglistadiretoriousuario; 139 import java.io.File; import java.util.Scanner; public class ProgListaDiretorioUsuario { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Pathname: "); String nomeDiretorio = entrada.nextLine(); File diretorio = new File(nomeDiretorio); String [] arquivos = diretorio.list(); for (int i = 0;i < arquivos.length;i++) { File filho = new File(diretorio, arquivos[i]); System.out.println(filho.getAbsolutePath()); } } } Resultado do Programa: Pathname: /Users/pluzzardi /Users/pluzzardi/.bash_history /Users/pluzzardi/.CFUserTextEncoding /Users/pluzzardi/.config /Users/pluzzardi/.cups /Users/pluzzardi/.dropbox /Users/pluzzardi/.DS_Store /Users/pluzzardi/.gbas /Users/pluzzardi/.local /Users/pluzzardi/.netbeans-derby /Users/pluzzardi/.ssh /Users/pluzzardi/.Trash /Users/pluzzardi/.viminfo /Users/pluzzardi/Desktop /Users/pluzzardi/Documents /Users/pluzzardi/Downloads /Users/pluzzardi/Dropbox /Users/pluzzardi/frutas.luz /Users/pluzzardi/Frutas.txt /Users/pluzzardi/Leitura.zip /Users/pluzzardi/Library /Users/pluzzardi/luzzardi.dat /Users/pluzzardi/Luzzardi.txt /Users/pluzzardi/Movies /Users/pluzzardi/Music /Users/pluzzardi/NetBeansProjects /Users/pluzzardi/nomes.sort /Users/pluzzardi/nomes.txt /Users/pluzzardi/palavras.dat /Users/pluzzardi/pessoa.dat /Users/pluzzardi/pessoas.dat /Users/pluzzardi/Pictures /Users/pluzzardi/Projects /Users/pluzzardi/Public 8.4 Manipulação de um arquivo de palavras A seguir são mostrados alguns programas exemplos que manipulam um arquivo contendo palavras (palavras.dat). Veja o formato no exemplo abaixo: 5 carambola 140 beringela abacate ervilha damasco Programa exemplo: Permite criar um arquivo de palavras (palavras.dat) permitindo a gravação destas palavras no arquivo. // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgCriaPalavras.java package progcriapalavras; import java.io.File; import java.io.FileWriter; import java.util.Scanner; public class ProgCriaPalavras { public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String diretorio = "/Users/pluzzardi"; File arquivo = new File(diretorio, "palavras.dat"); if (!arquivo.exists()) { // proteção para não apagar o arquivo já criado try (FileWriter file = new FileWriter(arquivo)) { System.out.print("Número de Palavras: "); String s = entrada.nextLine(); int numPalavras = Integer.parseInt(s); file.write((byte)numPalavras); file.write('\n'); for (int i = 1;i <= numPalavras;i++) { System.out.print("Palavra: "); byte a = (byte) System.in.read(); while(a != '\n') { file.write(a); a = (byte) System.in.read(); } file.write('\n'); } file.close(); } } else { System.out.println("ERRO: Arquivo já existe"); } } } Exemplo de gravação no arquivo “palavras.dat”: Número de palavras: 5 <enter> Palavra: carambola <enter> Palavra: beringela <enter> Palavra: abacate <enter> Palavra: ervilha <enter> Palavra: damasco <enter> Arquivo gerado: palavras.dat 5 carambola beringela abacate ervilha damasco 141 Observação: Se o programa for executado novamente, dará a seguinte mensagem: “ERRO: Arquivo já existe”, isto protege o arquivo criado anteriormente Programa exemplo: Permite abrir o arquivo de palavras (palavras.dat) e exibe-os na tela. // --------------------------------------------------------------------------------------------------- Programa Principal: ProgCarregaPalavras.java package progcarregapalavras; import java.io.File; import java.io.FileReader; public class ProgCarregaPalavras { public static void main(String[] args) throws Exception { String diretorio = "/Users/pluzzardi"; File arquivo = new File(diretorio, "palavras.dat"); byte a; if (arquivo.exists()) { try (FileReader file = new FileReader(arquivo)) { int numPalavras = file.read(); file.read(); for (int i = 1;i <= numPalavras;i++) { System.out.print("Palavra: "); a = (byte) file.read(); while(a != '\n') { System.out.printf("%c", a); a = (byte) file.read(); } System.out.println(); } file.close(); } } else { System.out.println("ERRO: Arquivo não existe"); } } } Resultado do Programa: Palavra: carambola Palavra: beringela Palavra: abacate Palavra: ervilha Palavra: damasco Programa exemplo: Permite consultar o arquivo de palavras (palavras.dat). Para tanto é solicitado, ao usuário, o número do registro para ser calculado a posição deste registro no arquivo. Logo após o registro é exibido na tela. // -------------------------------------------------------------------------------------- Programa Principal: ProgCarregaPalavrasUsuario.java package progcarregapalavrasusuario; import java.io.*; import java.util.*; public class ProgCarregaPalavrasUsuario { 142 public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String s; String diretorio = "/Users/pluzzardi"; File arquivo = new File(diretorio, "palavras.dat"); FileInputStream in = new FileInputStream(arquivo); InputStreamReader conversor = new InputStreamReader(in); BufferedReader buffer = new BufferedReader(conversor); FileReader file = new FileReader(arquivo); if (arquivo.exists()) { System.out.println("Arquivo: " + arquivo); int numPalavras = file.read(); String temp = buffer.readLine(); // descarta a primeira linha System.out.println("Total de Palavras: " + numPalavras); String [] linha = new String[numPalavras + 1]; for (int i = 0;i < numPalavras;i++) { linha[i] = buffer.readLine(); } buffer.close(); in.close(); file.close(); int pos; do { System.out.print("Posição [1.." + numPalavras + "] ou [0] Sair: "); s = entrada.nextLine(); pos = Integer.parseInt(s); if (pos >= 1 && pos <= numPalavras) { System.out.println("Palavra: " + linha[pos - 1]); } else { if (pos != 0) { System.out.println("ERRO: Posição Inválida"); } } } while (pos != 0); } else { System.out.println("ERRO: Arquivo não existe"); } } } Resultado do Programa: Arquivo: /Users/pluzzardi/palavras.dat Total de Palavras: 5 Posição [1..5] ou [0] Sair: 1 <enter> Palavra: carambola Posição [1..5] ou [0] Sair: 2 <enter> Palavra: beringela Posição [1..5] ou [0] Sair: 3 <enter> Palavra: abacate Posição [1..5] ou [0] Sair: 4 <enter> Palavra: ervilha Posição [1..5] ou [0] Sair: 5 <enter> Palavra: damasco Posição [1..5] ou [0] Sair: 6 <enter> ERRO: Posição Inválida Posição [1..5] ou [0] Sair: 0 <enter> 8.5 Arquivo Texto A seguir é mostrado um programa que lê um arquivo texto contendo: 143 a) Total de Palavras; b) Lista de Palavras (nome de frutas). 144 Arquito Texto: Frutas.txt 15 abacaxi abacate banana pitanga goiaba morango carambola kiwi laranja bergamota tomate uva caqui lima jaca // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgLeitura.java package progleitura; import java.io.*; public class ProgLeitura { public static void main(String[] args) { int linhas = 0; int max = 0; String palavras [], linha; String nomeArquivo = "/Users/pluzzardi/Frutas.txt"; try { FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto); max = Integer.parseInt(leitor.readLine()); palavras = new String[max]; System.out.println("Total de palavras: " + max); int i = 0; while ((linha = leitor.readLine()) != null) { palavras[i] = linha; System.out.println("Palavra: " + palavras[i]); linhas++; i++; } int n = (int) (Math.random() * max); System.out.println("Palavra Sorteada: " + palavras[n]); } catch(IOException e){ System.out.println("Erro: Problema com o Arquivo "); } } } Resultado do Programa: Total de palavras: 15 Palavra: abacaxi Palavra: abacate Palavra: banana Palavra: pitanga Palavra: goiaba Palavra: morango Palavra: carambola Palavra: kiwi Palavra: laranja Palavra: bergamota 145 Palavra: tomate Palavra: uva Palavra: caqui Palavra: lima Palavra: jaca Palavra Sorteada: carambola A seguir é mostrado um outro programa que lê um arquivo texto exibindo: (a) número de linhas e (b) número de bytes. // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgBytes.java package progbytes; import java.io.*; import java.util.Scanner; public class ProgBytes { public static void main(String[] args) { int linhas = 0; long bytes = 0; String buffer; Scanner input = new Scanner(System.in); String nomeArquivo; System.out.print("Nome do Arquivo: "); nomeArquivo = input.nextLine(); try { FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto); int i = 0; while ((buffer = leitor.readLine()) != null) { bytes = bytes + buffer.length(); linhas++; i++; } System.out.println(linhas + " Linha(s)"); System.out.println(bytes + " Byte(s)"); } catch(IOException e){ System.out.println("Erro: Problema com o Arquivo"); } } } Resultado do Programa: Nome do Arquivo: /Users/pluzzardi/NetBeansProjects/Bytes/src/bytes/bytes.java <enter> 37 Linha(s) 987 Byte(s) A seguir é mostrado um outro programa que lê um arquivo texto exibindo: a) Todas as linhas do arquivo texto com seu respectivo número; b) Número de Linhas; c) Número de Bytes. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgListar.java 146 package proglistar; import java.io.*; import java.util.Scanner; public class ProgListar { public static void main(String[] args) { int linhas = 0; long bytes = 0; String buffer; Scanner input = new Scanner(System.in); String nomeArquivo; System.out.print("Nome do Arquivo: "); nomeArquivo = input.nextLine(); try { FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto); int i = 0; while ((buffer = leitor.readLine()) != null) { bytes = bytes + buffer.length(); linhas++; System.out.printf("%2d: %s\n", linhas, buffer); i++; } System.out.println(linhas + " Linha(s)"); System.out.println(bytes + " Byte(s)"); } catch(IOException e){ System.out.println("Erro: Problema com o Arquivo"); } } } Resultado do Programa: Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter> 1: 15 2: abacaxi 3: abacate 4: banana 5: pitanga 6: goiaba 7: morango 8: carambola 9: kiwi 10: laranja 11: bergamota 12: tomate 13: uva 14: caqui 15: lima 16: jaca 16 Linha(s) 93 Byte(s) A seguir é mostrado um outro programa que lê um arquivo texto e o número de uma linha e exibe a linha especificada: // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinha.java package proglinha; import java.io.*; 147 import java.util.Scanner; public class ProgLinha { public static void main(String[] args) { int linha = 0, numLinha; String s, buffer; Scanner input = new Scanner(System.in); String nomeArquivo; boolean listou = false; System.out.print("Nome do Arquivo: "); nomeArquivo = input.nextLine(); try { FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto); System.out.print("Número da Linha: "); s = input.nextLine(); numLinha = Integer.parseInt(s); int i = 0; while ((buffer = leitor.readLine()) != null) { linha++; if (linha == numLinha) { System.out.printf("%2d: %s\n", linha, buffer); listou = true; } i++; } } catch(IOException e){ System.out.println("Erro: Problema com o Arquivo"); } if (!listou) { System.out.println("ERRO: Linha não Encontrada"); } } } Resultado do Programa: Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter> Número da Linha: 5 <enter> 5: pitanga O seguinte programa mostra como gravar três informações em um arquivo texto (Pessoa.dat): nome, idade e sexo de diversas pessoas. // ----------------------------------------------------------------------------------------------- Programa Principal: ProgWriteDados.java package progwritedados; import java.io.File; import java.io.FileWriter; import java.util.Scanner; public class ProgWriteDados { public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String s; String diretorio = "/Users/pluzzardi/"; File arquivo = new File(diretorio, "Pessoa.dat"); if (!arquivo.exists()) { try (FileWriter file = new FileWriter(arquivo)) { do { System.out.print("Nome: "); String nome = entrada.nextLine(); 148 file.write(nome); file.write(":"); System.out.print("Idade: "); String idade = entrada.nextLine(); file.write(idade); file.write(":"); System.out.print("Sexo [M/F]: "); s = entrada.nextLine(); char sexo = s.charAt(0); file.write(sexo); file.write(":"); System.out.print("Continua [S/N]? "); do { s = entrada.nextLine(); } while (!"SsNn".contains(s)); } while ("S".equalsIgnoreCase(s)); file.close(); } } else { System.out.println("ERRO: Arquivo já existe");} } } Exemplo para testar o programa: Nome: Paulo Roberto <enter> Idade: 51 <enter> Sexo [M/F]: m <enter> Continua [S/N]? s <enter> Nome: Renato Luis <enter> Idade: 49 <enter> Sexo [M/F]: m <enter> Continua [S/N]? s <enter> Nome: Francisco Carlos <enter> Idade: 53 <enter> Sexo [M/F]: m <enter> Continua [S/N]? n <enter> O seguinte programa mostra como recarregar as três informações gravadas em um arquivo texto acima (Pessoa.dat). // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgReadDados.java package progreaddados; import java.io.File; import java.io.FileReader; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.Scanner; public class ProgReadDados { public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String diretorio = "/Users/pluzzardi/"; File arquivo = new File(diretorio, "Pessoa.dat"); FileInputStream in = new FileInputStream(arquivo); InputStreamReader conversor = new InputStreamReader(in); BufferedReader buffer = new BufferedReader(conversor); if (arquivo.exists()) { try (FileReader file = new FileReader(arquivo)) { String linha = buffer.readLine(); // lê todos os dados System.out.println("Linha: " + linha); 149 String[] partes = linha.split(":"); int n = partes.length; System.out.println("Partes: " + n); for (int i = 0; i < n; i = i + 3) { System.out.println("Nome: " + partes[i]); System.out.println("Idade: " + Integer.parseInt(partes[i + 1])); System.out.println("Sexo: " + partes[i + 2]); } } buffer.close(); } else { System.out.println("ERRO: Arquivo já existe"); } } } 150 Resultado do Programa: Linha: Paulo Roberto:52:m:Rento Luis:49:m:Francisco Carlos:54:m: Partes: 9 Nome: Paulo Roberto Idade: 52 Sexo: m Nome: Rento Luis Idade: 49 Sexo: m Nome: Francisco Carlos Idade: 54 Sexo: m O programa a seguir mostra como anexar (append) mais informações ao arquivo texto (Pessoa.dat) já existente, sem sobre-escrevê-lo. // ----------------------------------------------------------------------------------------------- Programa Principal: ProgAppendDados.java package progappenddados; import java.io.File; import java.io.IOException; import java.io.*; import java.util.Scanner; public class ProgAppendDados { public static void main(String[] args) throws IOException { Scanner entrada = new Scanner(System.in); String s; String diretorio = "/Users/pluzzardi/"; File arquivo = new File(diretorio, "Pessoa.dat"); if (arquivo.exists()) { try (FileWriter file = new FileWriter(arquivo, true)) { // true indica append, ou seja, anexar no fim do arquivo do { // o arquivo não é sobre-escrito, ou seja, ele não é apagado. Os dados antigos System.out.print("Nome: "); // são mantidos e os novos anexados ao fim do arquivo String nome = entrada.nextLine(); file.write(nome); file.write(":"); System.out.print("Idade: "); String idade = entrada.nextLine(); file.write(idade); file.write(":"); System.out.print("Sexo [M/F]: "); s = entrada.nextLine(); char sexo = s.charAt(0); file.write(sexo); file.write(":"); System.out.print("Continua [S/N]? "); do { s = entrada.nextLine(); } while (!"SsNn".contains(s)); } while ("S".equalsIgnoreCase(s)); } } else { System.out.println("ERRO: Arquivo não existe"); } } Exemplo para testar o programa: Nome: Ana Maria <enter> Idade: 56 <enter> Sexo [M/F]: f <enter> Continua [S/N]? s <enter> 151 Nome: Julia Helena <enter> Idade: 55 <enter> Sexo [M/F]: f <enter> Continua [S/N]? n <enter> Resultado do Programa: (ProgReadDados) Linha: Paulo Roberto:52:m:Rento Luis:49:m:Francisco Carlos:54:m:Ana Maria:56:f:Julia Helena:55:f Partes: 15 Nome: Paulo Roberto Idade: 52 Sexo: m Nome: Rento Luis Idade: 49 Sexo: m Nome: Francisco Carlos Idade: 54 Sexo: m Nome: Ana Maria Idade: 56 Sexo: f Nome: Julia Helena Idade: 55 Sexo: f 8.6 Lista de exercícios: Arquivos (Files) 8.6.1 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve imprimir na tela o número de bytes (caracteres) e o número de linhas do arquivo ou ERRO: Arquivo não existe. Entrada: Nome do arquivo texto: lista.java <enter> Saída: (12345) Bytes (44) Linhas ou ERRO: Arquivo não existe 8.6.2 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número da linha. O programa deve imprimir a linha especificada ou ERRO: Linha não existe (zero para abandonar). Exemplo para testar o programa: Nome do arquivo texto: lista.java <enter> Número de linha: 7 <enter> 7: int i, j, k; Número de linha: 70 <enter> ERRO: Linha não existe Número de linha: 0 <enter> // saída do programa ERRO: Arquivo não existe 8.6.3 Escreva um programa em Java que recebe via teclado o nome de dois arquivos texto (origem e destino). O programa deve copiar o conteúdo do arquivo origem para o arquivo destino. Entrada: Saída: Arquivo origem: lista.java <enter> Arquivo destino: lista.tmp <enter> (20345) Bytes copiados 152 8.6.4 Escreva um programa em Java que recebe via teclado o nome do arquivo texto fonte e o nome do arquivo texto destino. O programa deve converter o arquivo para maiúsculo ou minúsculo (conforme escolha do usuário) gerando o arquivo texto destino. Entrada: Arquivo fonte: lista.java <enter> Arquivo destino: lista.tmp <enter> [+] Maiúsculo ou [-] Minúsculo: + <enter> Saída: (1234) Bytes convertidos 8.6.5 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto e uma palavra. O programa deve imprimir todas as linhas que possuem esta palavra. Entrada: Nome do arquivo texto: palavra.java <enter> Palavra: if <enter> Saída: 23: if (a == b) { 33: if (ch == '\n') { 37: if (compara(linha,palavra)) { 41: if (ch != '\n') { 59: if (linha[i] == palavra[0]) { 65: if (linha[k] != palavra[j]) { 69: if (achei) { ou Erro: Palavra não existe 8.6.6 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número inicial e número final. O programa deve imprimir desde a linha inicial até a linha final ou ERRO: Linhas não existem. Entrada: Nome do arquivo texto: lista.java <enter> Número inicial: 7 <enter> Número final: 9 <enter> Saída: 7: int i, j, k; 8: char tecla; 9: long bytes = 0; ou Entrada: Número inicial: 70 <enter> Número final: 90 <enter> Saída: ERRO: Linhas não existem 8.6.7 Escreva um programa em Java (grava.java) que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário inserir nomes neste arquivo via teclado. O programa termina quando o usuário digitar <enter> na entrada do nome. Exemplo para testar o programa: Nome do arquivo texto: nomes.txt <enter> Nome: Beatriz <enter> Nome: Eva <enter> Nome: Debora <enter> Nome: Carla <enter> Nome: Fatima <enter> Nome: Ana <enter> Nome: <enter> 153 8.6.8 Escreva um programa em Java (ler.java) que recebe via teclado o nome de um arquivo texto. O programa deve ler e imprimir na tela todos os nomes armazenados no arquivo pelo programa "grava.java". Entrada: Nome do arquivo texto: nomes.txt <enter> Saída: Nome: Beatriz Nome: Eva Nome: Debora Nome: Carla Nome: Fatima Nome: Ana 8.6.9 Escreva um programa em Java (sort.java) que recebe via teclado o nome de um arquivo texto origem e um destino. O programa deve ler, ordenar e gravar novamente os nomes no arquivo destino. Exemplo para testar o programa: Nome do arquivo texto origem: nomes.txt <enter> Nome do arquivo texto destino: nomes.srt <enter> Ok, arquivo ordenado e copiado Observação: Utilize o programa anterior (ler.java) para ver os nomes ordenados. 8.6.10 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário inserir nome, idade e sexo ([M]asculino ou [F]eminino) neste arquivo via teclado. O programa termina quando o usuário digitar <enter> na entrada do nome. Exemplo para testar o programa: Nome do arquivo texto: dados.txt <enter> Nome: Paulo Roberto <enter> Idade: 41 <enter> Sexo [M/F]: m <enter> Nome: Renato Luis <enter> Idade: 38 <enter> Sexo [M/F]: m <enter> Nome: Ana Maria <enter> Idade: 44 <enter> Sexo [M/F]: f <enter> Nome: <enter> 8.6.11 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve ler e imprimir na tela todos os dados (nome, idade e sexo) armazenados no arquivo pelo programa "8.6.10" (veja exemplo abaixo). Entrada: Nome do arquivo texto: dados.txt <enter> Saída: Nome: Paulo Roberto Idade: 41 Sexo: MASCULINO Nome: Renato Luis Idade: 38 Sexo: MASCULINO Nome: Ana Maria Idade: 44 Sexo: FEMININO 8.6.12 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve verificar a quantidade de homens e a quantidade de mulheres no aquivo criado pelo programa "14.6.10". Entrada: Nome do arquivo texto: dados.txt <enter> 154 Saída: (2) Homens (1) Mulheres 8.7 Acesso randômico em arquivos texto É possível acessar um arquivo texto de forma randômica (aleatória), ou seja, não puramente sequencial como é o padrão. Desta forma, pode-se acessar qualquer linha de um arquivo texto. // ---------------------------------------------------------------------------------------------- Programa Principal: ProgRadomTexto.java package prograndomtexto; import java.io.RandomAccessFile; import java.io.IOException; import java.util.Scanner; public class ProgRandomTexto { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); try { int nl; RandomAccessFile file = new RandomAccessFile(nomeArquivo, "r"); do { boolean encontrouLinha = false; System.out.print("Linha: "); String s = input.nextLine(); nl = Integer.parseInt(s); int linhas = 0; while ((linha = file.readLine()) != null) { linhas++; if (nl == linhas) { System.out.println(nl + ": " + linha); encontrouLinha = true; } } if (!encontrouLinha) { System.out.println("ERRO: Linha não existe"); } file.seek(0); // volta para a primeira linha } while (nl != 0); file.close(); } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } } Exemplo para testar o programa: Nome do Arquivo Texto: /Users/pluzzardi/Frutas.txt <enter> Linha: 3 <enter> 3: abacate Linha: 5 <enter> 5: pitanga Linha: 99 <enter> ERRO: Linha não existe Linha: 0 <enter> 155 ERRO: Linha não existe 8.8 Arquivo binário de objetos em Java Em Java é possível gravar e carregar dados em arquivos binários que nada mais são que são filas de bytes. Abaixo são vistos dois programas: (a) BinaryWrite grava dados (nome idade e sexo) que são armazenados em um ArrayList e (b) programa BinaryRead recupera os dados (como uma lista de dados) gravados no arquivo binário gerado pelo programa BinaryWrite. // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgBinaryWrite.java package progbinarywrite; import java.io.File; import java.io.ObjectOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class ProgBinaryWrite { public static void main(String[] args) throws IOException { Scanner input = new Scanner(System.in); String s; ArrayList pessoa = new ArrayList(); System.out.print("Nome do Arquivo Binário: "); String nomeArquivo = input.nextLine(); try { File file = new File(nomeArquivo); try (ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(file))) { do { System.out.print("Nome: "); String nome = input.nextLine(); System.out.print("Idade: "); s = input.nextLine(); int idade = Integer.parseInt(s); System.out.print("Sexo [M/F]: "); s = input.nextLine(); char sexo = s.charAt(0); pessoa.add(nome); pessoa.add(idade); pessoa.add(sexo); do { System.out.print("Continua [S/N]? "); s = input.nextLine(); } while (!"SsNn".contains(s)); } while (!"Nn".contains(s)); output.writeObject(pessoa); // grava ArrayList } } catch (IOException | NumberFormatException e) { System.out.println(e.toString()); } } } Exemplo para testar o programa: Nome do Arquivo Binário: /Users/pluzzardi/pessoa.dat <enter> Nome: Paulo <enter> Idade: 51 <enter> 156 Sexo [M/F]: m <enter> Continua [S/N]? s <enter> Nome: Renato <enter> Idade: 49 <enter> Sexo [M/F]: M <enter> Continua [S/N]? s <enter> Nome: Francisco <enter> Idade: 53 <enter> Sexo [M/F]: m <enter> Continua [S/N]? s <enter> Nome: Ana <enter> Idade: 55 <enter> Sexo [M/F]: f <enter> Continua [S/N]? s <enter> Nome: Julia <enter> Idade: 54 <enter> Sexo [M/F]: F <enter> Continua [S/N]? N <enter> // ----------------------------------------------------------------------------------------------- Programa Principal: ProgBinaryRead.java package progbinaryread; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.util.Scanner; public class ProgBinaryRead { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Nome do Arquivo Binário: "); String nomeArquivo = entrada.nextLine(); try { File file = new File(nomeArquivo); ObjectInputStream input = new ObjectInputStream(new FileInputStream(file)); Object pessoa = input.readObject(); System.out.println(pessoa.toString()); } catch (IOException | ClassNotFoundException e) { System.out.println(e.toString()); } } } Entrada: Nome do Arquivo Binário: /Users/pluzzardi/pessoa.dat <enter> Saída: [Paulo, 51, m, Renato, 49, M, Francisco, 53, m, Ana, 55, f, Julia, 54, F] 8.9 Leitura e gravação de objetos (registro) em Arquivos Em Java é possível ler e gravar dados organizados em registros. Um registro é um conjuntos de campos, onde campos são qualquer tipo em Java. public class Registro { Object nome; Object idade; Object sexo; } nome idade sexo 157 8.9.1 Gravação de objetos em um arquivo binário de objetos O programa abaixo permite gravar em um arquivo binário de objetos as seguintes informações: nome, idade e sexo. file.addFile("Paulo Roberto", 50, 'm'); file.addFile("Adriane Maria", 42, 'f'); file.addFile("Paola", 13, 'f'); // -------------------------------------------------------------------------------------------------------------------------- Classe: Registro.java package progwritefileregistro; public class Registro { Object nome; Object idade; Object sexo; Registro(String nome, int idade, char sexo) { this.nome = nome; this.idade = idade; this.sexo = sexo; } } // ------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java package progwritefileregistro; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; public class FileObjeto { // ------------------------------ atributos da classe String nomeFile; private ObjectOutputStream fileOut; FileObjeto(String nomeArquivo) { nomeFile = nomeArquivo; try { fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile)); System.out.println("Ok, Arquivo criado: " + nomeFile); } catch (IOException ioException) { System.out.println("ERRO Fatal: Problema na criação do Arquivo: " + nomeFile); } } // ------------------------------- addFile public void addFile(String nome, int idade, char sexo) throws IOException, ClassNotFoundException { Registro registro = new Registro(nome, idade, sexo); fileOut.writeObject(registro.nome); fileOut.writeObject(registro.idade); fileOut.writeObject(registro.sexo); } // ------------------------------- closeFile public void closeFile() { try { if (fileOut != null) { 158 fileOut.close(); System.out.println("Ok, Arquivo fechado: " + nomeFile); } } catch (IOException ioException) { System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile); System.exit(1); } } } // --------------------------------------------------------------------------------------- Programa Principal: ProgWriteFileRegistro.java package progwritefileregistro; import java.io.IOException; import java.util.Scanner; public class ProgWriteFileRegistro { public static void main(String[] args) throws IOException, ClassNotFoundException { Scanner input = new Scanner(System.in); System.out.print("Nome do Arquivo Binário: "); String nomeArquivo = input.nextLine(); FileObjeto file = new FileObjeto(nomeArquivo); file.addFile("Paulo Roberto", 50, 'm'); file.addFile("Adriane Maria", 42, 'f'); file.addFile("Paola", 13, 'f'); file.closeFile(); } } Entrada: Nome do Arquivo Binário: /Users/pluzzardi/Objeto.dat <enter> Saída: Ok, Arquivo criado: /Users/pluzzardi/Objeto.dat Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat Observação: Por questões didáticas, simplificação, não foi testado se o arquivo binário existe, ou seja, se ele existir, será sobre-escrito. Solução 2: Nesta solução o usuário digita os nomes, idades e sexo das pessoas. // --------------------------------------------------------------------------------------------------------------------------- Classe: Registro.java package progwritefileregistro2; public class Registro { Object nome; Object idade; Object sexo; Registro(String nome, int idade, char sexo) { this.nome = nome; this.idade = idade; this.sexo = sexo; } } // -------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java package progwritefileregistro2; import java.io.FileOutputStream; import java.io.IOException; 159 import java.io.ObjectOutputStream; public class FileObjeto { // ------------------------------ atributos da classe String nomeFile; private ObjectOutputStream fileOut; FileObjeto(String nomeArquivo) { nomeFile = nomeArquivo; try { fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile)); System.out.println("Ok, Arquivo criado: " + nomeFile); } catch (IOException ioException) { System.out.println("ERRO Fatal: Problema na criação do Arquivo: " + nomeFile); } } // ----------------------------------------------------------------------------------------------------------------------------- addFile public void addFile(Registro registro) throws IOException, ClassNotFoundException { fileOut.writeObject(registro.nome); fileOut.writeObject(registro.idade); fileOut.writeObject(registro.sexo); } // -------------------------------------- closeFile public void closeFile() { try { if (fileOut != null) { fileOut.close(); System.out.println("Ok, Arquivo fechado: " + nomeFile); } } catch (IOException ioException) { System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile); System.exit(1); } } } // ---------------------------------------------------------------------------------------- Programa Principal: ProgWriteFileRegistro2.java package progwritefileregistro2; import java.io.IOException; import java.util.Scanner; public class ProgWriteFileRegistro2 { public static void main(String[] args) throws IOException, ClassNotFoundException { Scanner input = new Scanner(System.in); char ch; System.out.print("Nome do Arquivo: "); String nomeArquivo = input.nextLine(); FileObjeto file = new FileObjeto(nomeArquivo); do { System.out.print("Nome: "); String nome = input.nextLine(); System.out.print("Idade: "); String s = input.nextLine(); int idade = Integer.parseInt(s); System.out.print("sexo [M]asculino ou [F]eminino: "); s = input.nextLine(); char sexo = s.charAt(0); Registro registro = new Registro(nome, idade, sexo); file.addFile(registro); System.out.print("Continua [S/N]? "); do { 160 s = input.nextLine(); ch = s.charAt(0); } while (!strChr("SsNn", ch)); } while (strChr("Ss", ch)); file.closeFile(); } // --------------------------------------------------------- strChr static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0;i < n;i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } } Exemplo para testar o programa: Nome do Arquivo: /Users/pluzzardi/luz.dat <enter> Ok, Arquivo criado: /Users/pluzzardi/luz.dat Nome: Paulo Roberto <enter> Idade: 51 <enter> sexo [M]asculino ou [F]eminino: m <enter> Continua [S/N]? s <enter> Nome: Renato Luis <enter> Idade: 49 <enter> sexo [M]asculino ou [F]eminino: m <enter> Continua [S/N]? s <enter> Nome: Francisco Carlos <enter> Idade: 53 <enter> sexo [M]asculino ou [F]eminino: m <enter> Continua [S/N]? n <enter> Ok, Arquivo fechado: /Users/pluzzardi/luz.dat 8.9.2 Leitura objetos em um arquivo binário de objetos O programa abaixo permite carregar (ler) de um arquivo binário de objetos com as seguintes informações: nome, idade e sexo. // --------------------------------------------------------------------------------------------------------------------------------------- Classe: Registro.java package progreadfileregistro; public class Registro { Object nome; Object idade; Object sexo; } // ---------------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java package progreadfileregistro; import java.io.FileInputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.EOFException; public class FileObjeto { // ---------------------------------- atributos da classe String nomeFile; 161 private ObjectInputStream fileIn; // ----------------------------------------------- construtor FileObjeto(String nomeArquivo) { nomeFile = nomeArquivo; try { fileIn = new ObjectInputStream(new FileInputStream(nomeFile)); System.out.println("Ok, Arquivo Aberto: " + nomeFile); } catch (IOException ioException) { System.out.println("ERRO Fatal: Problema na Abertura do Arquivo: " + nomeFile); System.exit(1); } } // ----------------------------------------------------------------------------------------------------- getFile public void getFile() throws IOException, ClassNotFoundException { Registro registro = new Registro(); System.out.println("Nome Idade Sexo"); try { while (true) { registro.nome = fileIn.readObject(); registro.idade = fileIn.readObject(); registro.sexo = fileIn.readObject(); System.out.printf("%-20s %2d %c\n", registro.nome, registro.idade, registro.sexo); } } catch (EOFException endOfFileException) { } } // ------------------------------------------- closeFile public void closeFile() { try { if (fileIn != null) { fileIn.close(); System.out.println("Ok, Arquivo fechado: " + nomeFile); } } catch (IOException ioException) { System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile); System.exit(1); } } } // -------------------------------------------------------------------------------------- Programa Principal: ProgReadFileRegistro.java package progreadfileregistro; import java.io.IOException; import java.util.Scanner; public class ProgReadFileRegistro { public static void main(String[] args) throws IOException, ClassNotFoundException { Scanner input = new Scanner(System.in); System.out.print("Nome do Arquivo Binário: "); String nomeArquivo = input.nextLine(); FileObjeto file = new FileObjeto(nomeArquivo); file.getFile(); file.closeFile(); } } Entrada: Nome do Arquivo Binário: /Users/pluzzardi/Objeto.dat <enter> Saída: Ok, Arquivo Aberto: /Users/pluzzardi/Objeto.dat 162 Nome Idade Sexo Paulo Roberto 50 m Adriane Maria 42 f Paola 13 f Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat ou Entrada: Nome do Arquivo: /Users/pluzzardi/luz.dat <enter> Saída: Ok, Arquivo Aberto: /Users/pluzzardi/luz.dat Nome Idade Sexo Paulo Roberto 51 m Renato Luis 49 m Francisco Carlos 53 m Ok, Arquivo fechado: /Users/pluzzardi/luz.dat 163 9. Noções de desenvolvimento de aplicações em camadas (MVC) 9.1 Conceitos Model View Controller (MVC – Modelo Visão Controlador) é um modelo de arquitetura de programa que divide a representação da informação e da interação. O model (modelo) contém os dados da aplicação, as regras de negócios, a lógica e os métodos. Uma view (visão) pode ser qualquer saída ou impressão da representação dos dados. Pode-se possuir várias visões da mesma informação. O controller (controlador) faz a mediação da entrada, convertendo-a em comandos para o modelo ou visão. As vantagens do MVC são resusabilidade de código e separação de conceitos. Resumindo, as partes presentes no MVC tem as seguintes funções: Controller enxerga a view e reconhece o model. Recebe requisições do usuário da view e envia para o model executar as requisições. Model recebe as requisições e as executa, atualizando os dados da aplicação. View analisa o model e espera os dados serem atualiza-dos, mostrando os dados atualizados. Vantagens do modelo Model View Controller: 1. É fácil manter, testar e atualizar. 2. É simples incluir novos dados, apenas pela inclusão de seus visualizadores e controles. 3. Torna a aplicação escalável. 4. Desenvolvimento paralelo do model, view e controller por serem independentes. Desvantagens do modelo Model View Controller: 1. Necessita quantidade maior de tempo para analisar e modelar o sistema. 2. Necessita pessoas especializadas. 3. Não recomendável para aplicações pequenas. 9.2 Primeiro exemplo da utilização do MVC (ProgMVCPessoa) A seguir é visto e descrito a utilização do MVC em Java (Figura 12). O programa ProgMVCPessoa trabalha com as seguintes informações de uma pessoa (nome, idade e sexo). 164 Figura 12: Exemplo de MVC // ------------------------------------------------------------------------------------------------------------------------------------------------- Pacote: entity // -------------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package entity; public final class Pessoa { // --------------------------------- atributos da classe private String nome; private int idade; private char sexo; // ---------------------------------- construtores da classe public Pessoa() { setNome("xxxxxxxxxx"); setIdade(-99); setSexo('x'); } public Pessoa(String nome, int idade, char sexo) { setNome(nome); 165 setIdade(idade); setSexo(sexo); } // ----------------------------------------------------- métodos públicos da classe public void setNome(String nome) { this.nome = nome; } public void setIdade(int idade) { this.idade = idade >= 0 && idade <= 110 ? idade : -99; } public void setSexo(char sexo) { if (strChr("MmFf", sexo)) { this.sexo = sexo; } else { this.sexo = 'x'; } } public String getNome() { return (nome); } public int getIdade() { return (idade); } public char getSexo() { return (sexo); } // ----------------------------------------------------------- métodos estáticos da classe static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 166 // --------------------------------------------------------------------------------------------------------------------------------------- Pacote: pessoaView // ---------------------------------------------------------------------------------------------------------------------------------- Classe: PessoaView.java package pessoaView; import entity.Pessoa; import service.PessoaService; public final class PessoaView { // -------------------------------------------- atributos da classe PessoaService pessoaService; // ------------------------------- construtor da classe PessoaView() { pessoaService = new PessoaService("Paulo Roberto", 152, 't'); exibeView(pessoaService); PessoaService pessoaService = new PessoaService(); pessoaService.alteraPessoa("Renato Luis", 49, 'm'); exibeView(pessoaService); } // --------------------------------------------------------------- métodos públicos da classe public void exibeView(Pessoa pessoa) { System.out.println("Nome: " + pessoa.getNome()); if (pessoa.getIdade() != -99) { System.out.println("Idade: " + pessoa.getIdade()); } else { System.out.println("ERRO: Idade Inválida"); } if (pessoa.getSexo() != 'x') { System.out.println("Sexo: " + pessoa.getSexo()); } else { System.out.println("ERRO: Sexo Inválido"); } } public void exibeView(PessoaService pessoa) { System.out.println("Nome: " + pessoa.getPessoa().getNome()); if (pessoa.getPessoa().getIdade() != -99) { System.out.println("Idade: " + pessoa.getPessoa().getIdade()); } else { System.out.println("ERRO: Idade Inválida"); } if (pessoa.getPessoa().getSexo() != 'x') { System.out.println("Sexo: " + pessoa.getPessoa().getSexo()); } else { System.out.println("ERRO: Sexo Inválido"); } } } // ------------------------------------------------------------------------------------------------------------------- Programa Principal: Principal.java package pessoaView; public class Principal { public static void main(String[] args) { new PessoaView(); } } // -------------------------------------------------------------------------------------------------------------------------------------------- Pacote: service // -------------------------------------------------------------------------------------------------------------------------- Classe: PessoaService.java 167 package service; import entity.Pessoa; public class PessoaService { // --------------------------------- atributos da classe private Pessoa pessoa; // ------------------------------------------ construtor da classe public PessoaService() { pessoa = new Pessoa(); } public PessoaService(String nome, int idade, char sexo) { pessoa = new Pessoa(); alteraPessoa(nome, idade, sexo); } // --------------------------------------------------------------------------------------------- métodos públicos da classe public void alteraPessoa(String nome, int idade, char sexo) { pessoa.setNome(nome); pessoa.setIdade(idade); pessoa.setSexo(sexo); } public Pessoa getPessoa() { return(pessoa); } } Resultado do Programa: Nome: Paulo Roberto ERRO: Idade Inválida ERRO: Sexo Inválido Nome: Renato Luis Idade: 49 Sexo: m 9.3 Segundo exemplo da utilização do MVC (ProgMVCPessoa2) A seguir é visto e descrito a utilização do MVC em Java (Figura 13). O programa ProgMVCPessoa trabalha com as seguintes informações de uma pessoa (nome, idade e sexo) e permite ao usuário digitar estas informações via teclado. 168 Figura 13: Exemplo de MVC // --------------------------------------------------------------------------------------------------------------------------------------------- Pacote: entity // ---------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package entity; public final class Pessoa { // -------------------------------- atributos da classe private String nome; private int idade; private char sexo; // --------------------------------- construtores da classe public Pessoa() { setNome("xxxxxxxxxx"); setIdade(-99); setSexo('x'); } public Pessoa(String nome, int idade, char sexo) { setNome(nome); setIdade(idade); setSexo(sexo); } // ---------------------------------------------------------- métodos públicos da classe public void setNome(String nome) { this.nome = nome; } public void setIdade(int idade) { this.idade = idade >= 0 && idade <= 110 ? idade : -99; 169 } public void setSexo(char sexo) { if (strChr("MmFf", sexo)) { this.sexo = sexo; } else { this.sexo = 'x'; } } public String getNome() { return (nome); } public int getIdade() { return (idade); } public char getSexo() { return (sexo); } // ----------------------------------------------------------------- métodos públicos da classe static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } // ----------------------------------------------------------------------------------------------------------------------------------------- Pacote: pessoaView // ------------------------------------------------------------------------------------------------------------ Classe: PessoaView.java package pessoaView; import entity.Pessoa; import service.PessoaService; import static util.Utilidade.*; public final class PessoaView { // ------------------------------------------------ atributos da classe PessoaService pessoaService; // ------------------------------------------------- construtor da classe PessoaView() { String nome = lerString("Digite seu Nome: "); int idade = lerInteiro("Digite sua Idade: "); char sexo = lerChar("Seu Sexo [M]asculino ou [F]eminino: "); pessoaService = new PessoaService(nome, idade, sexo); exibeView(pessoaService); PessoaService pessoaService = new PessoaService(); nome = lerString("Digite seu Nome: "); idade = lerInteiro("Digite sua Idade: "); sexo = lerChar("Sexo [M]asculino ou [F]eminino: "); pessoaService.alteraPessoa(nome, idade, sexo); exibeView(pessoaService); } // ---------------------------------------------------------------- métodos públicos da classe public void exibeView(Pessoa pessoa) { System.out.println("Nome: " + pessoa.getNome()); if (pessoa.getIdade() != -99) { System.out.println("Idade: " + pessoa.getIdade()); 170 } else { System.out.println("ERRO: Idade Inválida"); } if (pessoa.getSexo() != 'x') { System.out.println("Sexo: " + pessoa.getSexo()); } else { System.out.println("ERRO: Sexo Inválido"); } } public void exibeView(PessoaService pessoa) { System.out.println("Nome: " + pessoa.getPessoa().getNome()); if (pessoa.getPessoa().getIdade() != -99) { System.out.println("Idade: " + pessoa.getPessoa().getIdade()); } else { System.out.println("ERRO: Idade Inválida"); } if (pessoa.getPessoa().getSexo() != 'x') { System.out.println("Sexo: " + pessoa.getPessoa().getSexo()); } else { System.out.println("ERRO: Sexo Inválido"); } } } // -------------------------------------------------------------------------------------------------------------------- Programa Principal: Principal.java package pessoaView; public class Principal { public static void main(String[] args) { new PessoaView(); } } // -------------------------------------------------------------------------------------------------------------------------------------------- Pacote: service // ----------------------------------------------------------------------------------------------------------------------------- Classe: PessoaService.java package service; import entity.Pessoa; public class PessoaService { // -------------------------------------- atributos da classe private Pessoa pessoa; // -------------------------------------- construtor da classe public PessoaService() { pessoa = new Pessoa(); } public PessoaService(String nome, int idade, char sexo) { pessoa = new Pessoa(); alteraPessoa(nome, idade, sexo); } // ------------------------------------------------------------------------------------------- métodos públicos da classe public void alteraPessoa(String nome, int idade, char sexo) { pessoa.setNome(nome); pessoa.setIdade(idade); pessoa.setSexo(sexo); } public Pessoa getPessoa() { return(pessoa); } 171 } // ----------------------------------------------------------------------------------------------------------------------------------------------- Pacote: util // ------------------------------------------------------------------------------------------------------------- Classe: Utilidade.java package util; import java.util.Scanner; public class Utilidade { public static String lerString(String mensagem) { Scanner input = new Scanner(System.in); System.out.print(mensagem); String s = input.nextLine(); return(s); } public static int lerInteiro(String mensagem) { Scanner input = new Scanner(System.in); System.out.print(mensagem); String s = input.nextLine(); int inteiro = Integer.parseInt(s); return(inteiro); } public static char lerChar(String mensagem) { Scanner input = new Scanner(System.in); System.out.print(mensagem); String s = input.nextLine(); char ch = s.charAt(0); return(ch); } } 172 Entrada: Digite seu Nome: Paulo Roberto <enter> Digite sua Idade: 52 <enter> Seu Sexo [M]asculino ou [F]eminino: m <enter> Saída: Nome: Paulo Roberto Idade: 52 Sexo: m ou Entrada: Digite seu Nome: Adriane Maria <enter> Digite sua Idade: 44 <enter> Sexo [M]asculino ou [F]eminino: f <enter> Saída: Nome: Adriane Maria Idade: 44 Sexo: f 173 10. Conceitos gerais 10.1 Como é calculado o hashcode no Java A seguir é visto um pequeno programa que mostra o cálculo do hashcode de uma string (String) e/ou de um objeto (Object) em Java. // ----------------------------------------------------------------------------------------------- Programa Principal: ProgHash.java package proghash; public class ProgHash { public static void main(String[] args) { String s = "abcdef"; Object objeto = "abcdef"; int n = s.length(); System.out.println("HashCode: " + s.hashCode()); int hash = 0; for (int i = 0;i < s.length();i++) { hash = 31 * hash + s.charAt(i); } System.out.println("Hash calculado: " + hash); System.out.println("HashCode objeto: " + objeto.hashCode()); } } Resultado do Programa: HashCode: -1424385949 Hash calculado: -1424385949 HashCode objeto: -1424385949 Observação: Note que o resultado deu negativo pois extrapolou o máximo dos inteiros positivos (int). Veja na Tabela 5, abaixo, a faixa de valores ddos números inteiros. Tabela 5: Tipos de dados do Java Tipo boolean char byte short int long float double Bytes 1 2 1 2 4 8 4 8 Bits 8 16 8 16 32 64 32 64 Faixa de valores true ou false 0 à 65.535 -128 à 127 -32.768 à 32.767 -2.147.483.648 à 2.147.483.647 -2E63 à 2E63 1.40239846e-46 à 3.40282347e+38 4.94065645841246544e-324 à 1.7976931348623157e+308 174 11. Lista Encadeada Simples em Java 11.1 Lista Encadeada de Inteiros A implementação de uma Lista Encadeada permite alocacar dinamicamente elementos na memória RAM, ou seja, a lista linear de elementos cresce com a execução do programa enquanto houver memória livre. Operações como inserção e remoção são mais simples. Este tipo de estrutura se chama Lista Encadeada Simples ou Lista Encadeada (Figura 14). Figura 14: Lista Encadeada Simples Funcionamento: Nas listas encadeadas simples ou duplamente encadeadas, aonde os elementos são alocados dinamicamente, elas crescem com a necessidade do usuário. Por outro lado, o programador não precisa estipular um tamanho fixo para elas, pois elas podem crescer enquanto houver memória livre, ou seja, os elementos alocados e armazenados podem estar em qualquer posição da área de dados da memória RAM (Random Access Memory) [Figura 15]. Desta forma, os elementos precisam estar conectados por uma ligação entre os nodos da lista, esta ligação se chama “elo”. Em Java este “elo” é uma referência. Além disso, é necessário armazenar, pelo menos, a referência do primeiro elemento da lista, para se ter acesso aos demais elementos da lista. E para facilitar, pode-se ainda armazenar o número de elementos da lista (e o último), pois para obter esta informação, seria necessário percorrer toda a lista contando os elementos. Esta operação é muito dispendiosa se a lista for muito grande. public class Nodo { public int info; public Nodo elo; } // info: informação que será armazenada na memória RAM // guarda a referência do próximo elemento Observação: Note que esta lista encadeada simples (acima) funcionará como uma pilha, pois ela cresce para a esquerda, ou seja, toda inserção e remoção é realizada apenas num extremo (lado esquerdo). 175 Figura 15: Alocação de elementos na Memória RAM A Figura 15 acima, mostra a diferença entre alocação estática de memória e a alocação dinâmica de memória. Note que na estática (lado esquerdo) há contiguidade física, ou seja, os elementos estão um ao lado do outro, por causa disto é possível “indexar” cada elemento de um vetor, ou seja, x[0], x[1], … x[n]. Note que na dinâmica (lado direito) é necessário (obrigatório) armazenar a referência do primeiro elemento e o primeiro elemento necessita ter um “elo” para o segundo e assim sucessivamente, até que o último elemento não aponta para “nenhum” elemento (referência do último é null). Note que o vetor “x” alocado estaticamente é: short []x = {10, 20, 30, 40, 50, 60, 70, 80}; Observação: Cada elemento do tipo short ocupa 2 bytes na memória RAM Note que a lista encadeada simples é: 10 20 30 40 50 // onde 10 é o primeiro // 50 é o último elemento Problema proposto: Escrever um programa em Java que permite inserir, excluir, consultar dados em uma lista encadeada simples. Programa exemplo: Demonstra a “inclusão”, “exclusão” e “consulta” de números inteiros em uma lista encadeada simples utilizando as classes: Nodo e ListaSimples escritas pelo programador. 176 // --------------------------------------------------------------------------------------------------------------------------------- Classe: Nodo.java package progsimples; public class Nodo { public int info; public Nodo elo; } // --------------------------------------------------------------------------------------------------------------------------------- Classe: ListaSimples.java package progsimples; public class ListaSimples { // ------------------------------------ atributos da classe private int n; private Nodo primeiro; // ------------------------------------ construtor ListaSimples() { primeiro = null; n = 0; } // ----------------------------------------------------------- métodos públicos da classe // ----------------------------------------------------------- incluir public void incluir(int valor) { Nodo ref = new Nodo(); ref.info = valor; if (n != 0) { ref.elo = primeiro; } n++; primeiro = ref; } // ----------------------------------------------------------- excluir public int excluir() { if (n == 0) { return (-999); } else { Nodo ref = primeiro; int valor = ref.info; primeiro = ref.elo; n--; if (n == 0) { primeiro = null; } return (valor); } } // ----------------------------------------------------------- pesquisar public int pesquisar(int valor) { if (n != 0) { Nodo ref = primeiro; int posicao = 1; while (ref != null) { if (ref.info == valor) { return (posicao); } ref = ref.elo; posicao++; } } else { System.out.println("ERRO: Lista Vazia"); } return (-1); 177 } // ----------------------------------------------------------- exibir public void exibir() { Nodo ref = primeiro; System.out.print("Lista Encadeada Simples: ["); if (n == 0) { System.out.println("Vazia]"); } else { while (ref != null) { System.out.print(ref.info + " "); ref = ref.elo; } System.out.println("\b]"); } } // ----------------------------------------------------------- exibirDescritor public void exibeDescritor() { System.out.println("Descritor: | " + primeiro + " | " + n + " |"); } // ----------------------------------------------------------- removeAll public void removeAll() { primeiro = null; n = 0; System.gc(); } // ----------------------------------------------------------- consultar public int consultar() { if (n == 0) { return (-999); } else { Nodo ref = primeiro; int valor = ref.info; return (valor); } } // ---------------------- métodos privados da classe // ---------------------- métodos estáticos da classe } // ------------------------------------------------------------------------------------------------------------------------------- Classe: ProgSimples.java package progsimples; import java.util.Scanner; public class ProgSimples { public static void main(String[] args) { ListaSimples simples = new ListaSimples(); Scanner input = new Scanner(System.in); char op; int valor, posicao; do { simples.exibeDescritor(); simples.exibir(); do { System.out.print("[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: "); String s = input.nextLine(); op = s.charAt(0); } while (!strChr("IiEeCcPpRrFf", op)); if (strChr("Ff", op)) { System.exit(0); 178 } switch (op) { case 'I': case 'i': System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); simples.incluir(valor); break; case 'E': case 'e': valor = simples.excluir(); if (valor != -999) { System.out.println("Valor Excluído à Esquerda: " + valor); } else { System.out.println("ERRO: Lista vazia à Esquerda"); } break; case 'P': case 'p': System.out.print("Valor à Pesquisar: "); s = input.nextLine(); int valorPesquisar = Integer.parseInt(s); posicao = simples.pesquisar(valorPesquisar); if (posicao != -1) { System.out.println("Posição do Valor pesquisado: " + posicao); } else { System.out.println("ERRO: Valor não encontrado"); } break; case 'R': case 'r': simples.removeAll(); break; case 'C': case 'c': valor = simples.consultar(); if (valor != -999) { System.out.println("Valor Consultado à Esquerda: " + valor); } else { System.out.println("ERRO: Lista vazia à Esquerda"); } break; } } while (!strChr("Ff", op)); } public static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } Exemplo para testar o programa: Descritor: | null | 0 | Lista Encadeada Simples: [Vazia] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> Valor: 10 <enter> Descritor: | progsimples.Nodo@77eec5fe | 1 | Lista Encadeada Simples: [10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> 179 Valor: 20 <enter> Descritor: | progsimples.Nodo@5d08e435 | 2 | Lista Encadeada Simples: [20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> Valor: 30 <enter> Descritor: | progsimples.Nodo@72be834a | 3 | Lista Encadeada Simples: [30 20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> Valor: 40 <enter> Descritor: | progsimples.Nodo@399daa20 | 4 | Lista Encadeada Simples: [40 30 20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: 40 Descritor: | progsimples.Nodo@72be834a | 3 | Lista Encadeada Simples: [30 20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter> Valor à Pesquisar: 20 <enter> Posição do Valor pesquisado: 2 Descritor: | progsimples.Nodo@72be834a | 3 | Lista Encadeada Simples: [30 20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter> Valor Consultado à Esquerda: 30 Descritor: | progsimples.Nodo@72be834a | 3 | Lista Encadeada Simples: [30 20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: 30 Descritor: | progsimples.Nodo@5d08e435 | 2 | Lista Encadeada Simples: [20 10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: 20 Descritor: | progsimples.Nodo@77eec5fe | 1 | Lista Encadeada Simples: [10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: 10 Descritor: | null | 0 | Lista Encadeada Simples: [Vazia] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter> 11.2 Lista Encadeada Genérica (String, Integer ou Double) A seguir, a Lista Simples Genérica permite armazenar elementos dos seguintes tipos de dados: String, Integer, Double ou Character. Sintaxe: ListaSimplesGenerica <String> simples = new ListaSimplesGenerica<>(); // --------------------------------------------------------------------------------------------------------------------------------- Classe: Nodo.java package progsimples; public class Nodo<E> { E element; Nodo<E> elo; } // ------------------------------------------------------------------------------------------------------------- Classe: ListaSimplesGenerica.java package progsimples; public class ListaSimplesGenerica <E>{ // ---------------------- atributos da classe private int n; private Nodo primeiro; // ---------------------- construtor 180 ListaSimplesGenerica() { primeiro = null; n = 0; } // ----------------------------------------------------------- métodos públicos da classe // ----------------------------------------------------------- incluir public void incluir(Object valor) { Nodo ref = new Nodo(); ref.element = valor; if (n != 0) { ref.elo = primeiro; } n++; primeiro = ref; } // ----------------------------------------------------------- excluir public Object excluir() { if (n == 0) { return (-999); } else { Nodo ref = primeiro; Object valor = ref.element; primeiro = ref.elo; n--; if (n == 0) { primeiro = null; } return (valor); } } // ----------------------------------------------------------- pesquisar public int pesquisar(Object valor) { if (n != 0) { Nodo ref = primeiro; int posicao = 1; while (ref != null) { if (ref.element.equals(valor)) { return (posicao); } ref = ref.elo; posicao++; } } else { System.out.println("ERRO: Lista Vazia"); } return (-1); } // ----------------------------------------------------------- exibir public void exibir() { Nodo ref = primeiro; System.out.print("Lista Encadeada Simples: ["); if (n == 0) { System.out.println("Vazia]"); } else { while (ref != null) { System.out.print(ref.element + " "); ref = ref.elo; } System.out.println("\b]"); } } // ----------------------------------------------------------- exibirDescritor public void exibeDescritor() { 181 System.out.println("Descritor: | " + primeiro + " | " + n + " |"); } // ----------------------------------------------------------- removeAll public void removeAll() { primeiro = null; n = 0; System.gc(); } // ----------------------------------------------------------- consultar public Object consultar() { if (n == 0) { return (-999); } else { Nodo ref = primeiro; Object valor = ref.element; return (valor); } } // ---------------------- métodos privados da classe // ---------------------- métodos estáticos da classe } // ----------------------------------------------------------------------------------------------------------- Classe: ProgListaSimplesGenerica.java package progsimples; import java.util.Scanner; public class ProgSimplesGenerica { public static void main(String[] args) { ListaSimplesGenerica<String> simples = new ListaSimplesGenerica<>(); // troque String por Integer ou Double e teste novamente Scanner input = new Scanner(System.in); char op; int posicao; Object valor; do { simples.exibeDescritor(); simples.exibir(); do { System.out.print("[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: "); String s = input.nextLine(); op = s.charAt(0); } while (!strChr("IiEeCcPpRrFf", op)); if (strChr("Ff", op)) { System.exit(0); } switch (op) { case 'I': case 'i': System.out.print("Valor: "); String s = input.nextLine(); simples.incluir(s); break; case 'E': case 'e': valor = simples.excluir(); if (valor.hashCode() != -999) { System.out.println("Valor Excluído à Esquerda: " + valor); } else { System.out.println("ERRO: Lista vazia à Esquerda"); } break; 182 case 'P': case 'p': System.out.print("Valor à Pesquisar: "); String valorPesquisar = input.nextLine(); posicao = simples.pesquisar(valorPesquisar); if (posicao != -1) { System.out.println("Posição do Valor pesquisado: " + posicao); } else { System.out.println("ERRO: Valor não encontrado"); } break; case 'R': case 'r': simples.removeAll(); break; case 'C': case 'c': valor = simples.consultar(); if (valor.hashCode() != -999) { System.out.println("Valor Consultado à Esquerda: " + valor); } else { System.out.println("ERRO: Lista vazia à Esquerda"); } break; } } while (!strChr("Ff", op)); } public static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } Exemplo para testar o programa: Descritor: | null | 0 | Lista Encadeada Simples: [Vazia] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> Valor: Ana <enter> Descritor: | progsimples.Nodo@6d6f6e28 | 1 | Lista Encadeada Simples: [Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> Valor: Beatriz <enter> Descritor: | progsimples.Nodo@135fbaa4 | 2 | Lista Encadeada Simples: [Beatriz Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> Valor: Carla <enter> Descritor: | progsimples.Nodo@45ee12a7 | 3 | Lista Encadeada Simples: [Carla Beatriz Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter> Valor à Pesquisar: Beatriz <enter> Posição do Valor pesquisado: 2 Descritor: | progsimples.Nodo@45ee12a7 | 3 | Lista Encadeada Simples: [Carla Beatriz Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter> Valor Consultado à Esquerda: Carla Descritor: | progsimples.Nodo@45ee12a7 | 3 | Lista Encadeada Simples: [Carla Beatriz Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: Carla Descritor: | progsimples.Nodo@135fbaa4 | 2 | 183 Lista Encadeada Simples: [Beatriz Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: Beatriz Descritor: | progsimples.Nodo@6d6f6e28 | 1 | Lista Encadeada Simples: [Ana] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter> Valor Excluído à Esquerda: Ana Descritor: | null | 0 | Lista Encadeada Simples: [Vazia] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter> ERRO: Lista vazia à Esquerda Descritor: | null | 0 | Lista Encadeada Simples: [Vazia] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter> 12. Lista Duplamente Encadeada em Java Na lista duplamente encadeada (Figura 16), cada elemento possui um elo para o anterior (antecessor) e o posterior (sucessor), sendo que a lista pode ter ou não descritor. Descritor: Estrutura que normalmente armazena o primeiro elemento, a quantidade de elemen-tos e o último elemento da Lista. private Nodo primeiro; private int n; private Nodo ultimo; Problema: Escrever um programa em Java que insere, exclui, pesquisa, consulta e remove todos os dados em uma lista duplamente encadeada com descritor. Programa exemplo: Demonstra a “inclusão”, “exclusão”, “pesquisa”, “consulta”, “remoção completa” e “exibição” de números inteiros (à esquerda, à direita e na posição escolhida pelo usuário) em uma lista duplamente encadeada com descritor utilizando as classes: Nodo e Dupla. Figura 16: Lista Duplamente Encadeada // ------------------------------------------------------------------------------------------------------------------------------------------- Classe: Nodo.java package progdupla; public class Nodo { public Nodo anterior = null; public int info; public Nodo posterior = null; 184 } // --------------------------------------------------------------------------------------------------------------------------------------- Classe: Descritor.java package progdupla; public class Descritor { public Nodo primeiro; public int n; public Nodo ultimo; Descritor(Nodo primeiro, int n, Nodo ultimo) { this.primeiro = primeiro; this.n = 0; this.ultimo = ultimo; } } // ------------------------------------------------------------------------------------------------------------------------------------- Classe: ListaDupla.java package progdupla; public class ListaDupla { // ---------------------- atributos da classe Descritor descritor; // +----------------------------+ // | primeiro | n | último | // +---------------------------+ // ---------------------- construtor ListaDupla() { descritor = new Descritor(null, 0, null); } // inicializa descritor // ----------------------------------------------------------- métodos públicos da classe // ----------------------------------------------------------- incluirEsquerda public void incluirEsquerda(int valor) { Nodo ref = new Nodo(); ref.info = valor; if (descritor.n == 0) { descritor.ultimo = ref; } else { ref.posterior = descritor.primeiro; descritor.primeiro.anterior = ref; } descritor.n++; descritor.primeiro = ref; } // ----------------------------------------------------------- incluirDireita public void incluirDireita(int valor) { Nodo ref = new Nodo(); ref.info = valor; if (descritor.n == 0) { descritor.primeiro = ref; } else { ref.anterior = descritor.ultimo; descritor.ultimo.posterior = ref; } descritor.n++; descritor.ultimo = ref; } // ---------------------------------------------------------------------- incluirPosicao public void incluirPosicao(int valor, int posicao) { if (posicao >= 0 && posicao <= descritor.n) { Nodo ref = new Nodo(); ref.info = valor; Nodo aux = descritor.primeiro; if (posicao == 1) { incluirEsquerda(valor); 185 } else { if (posicao == descritor.n + 1) { incluirDireita(valor); } else { for (int i = 1; i < posicao - 1; i++) { aux = aux.posterior; } descritor.n++; ref.anterior = aux; ref.posterior = aux.posterior; aux.posterior.anterior = ref; aux.posterior = ref; } } } else { System.out.println("ERRO: Posição Inválida"); } } // ----------------------------------------------------------- excluirEsquerda public int excluirEsquerda() { if (descritor.n == 0) { return (-999); } else { Nodo ref = descritor.primeiro; int valor = ref.info; descritor.primeiro = ref.posterior; if (descritor.primeiro != null) { descritor.primeiro.anterior = null; } descritor.n--; if (descritor.n == 0) { descritor.ultimo = null; } return (valor); } } // ----------------------------------------------------------- excluirDireita public int excluirDireita() { if (descritor.n == 0) { return (-999); } else { Nodo ref = descritor.ultimo; int valor = ref.info; descritor.ultimo = ref.anterior; if (descritor.ultimo != null) { descritor.ultimo.posterior = null; } descritor.n--; if (descritor.n == 0) { descritor.primeiro = null; } return (valor); } } // ----------------------------------------------------------- excluirPosicao public int excluirPosicao(int posicao) { if (descritor.n == 0) { return (-999); } else { if (posicao == 1) { return (excluirEsquerda()); } else { if (posicao == descritor.n) { return (excluirDireita()); } else { 186 Nodo ref = descritor.primeiro; Nodo aux = ref; for (int i = 1; i < posicao; i++) { aux = ref; ref = ref.posterior; } int valor = ref.info; aux.posterior = ref.posterior; ref.posterior.anterior = aux; descritor.n--; if (descritor.n == 0) { descritor.ultimo = null; } return (valor); } } } } // ----------------------------------------------------------- pesquisar public int pesquisar(int valor) { if (descritor.n != 0) { Nodo ref = descritor.primeiro; int posicao = 1; while (ref != null) { if (ref.info == valor) { return (posicao); } ref = ref.posterior; posicao++; } } else { System.out.println("ERRO: Lista Vazia"); } return (-1); } // ----------------------------------------------------------- exibirEsquerda public void exibirEsquerda() { Nodo ref = descritor.primeiro; System.out.print("Lista pela Esquerda: ["); if (descritor.n == 0) { System.out.println("Vazia]"); } else { while (ref != null) { System.out.print(ref.info + " "); ref = ref.posterior; } System.out.println("\b]"); } } // ----------------------------------------------------------- exibirDireita public void exibirDireita() { Nodo ref = descritor.ultimo; System.out.print("Lista pela Direita: ["); if (descritor.n == 0) { System.out.println("Vazia]"); } else { while (ref != null) { System.out.print(ref.info + " "); ref = ref.anterior; } System.out.println("\b]"); } } 187 // ----------------------------------------------------------- exibirDescritor public void exibeDescritor() { System.out.println("Descritor: | " + descritor.primeiro + " | " + descritor.n + " | " + descritor.ultimo + " |"); } // ----------------------------------------------------------- removeAll public void removeAll() { descritor = new Descritor(null, 0, null); System.gc(); } // ----------------------------------------------------------- consultarEsquerda public int consultarEsquerda() { if (descritor.n == 0) { return (-999); } else { Nodo ref = descritor.primeiro; int valor = ref.info; return (valor); } } // ----------------------------------------------------------- consultarDireita public int consultarDireita() { if (descritor.n == 0) { return (-999); } else { Nodo ref = descritor.ultimo; int valor = ref.info; return (valor); } } // ----------------------------------------------------------- consultarPosicao public int consultarPosicao(int posicao) { if (descritor.n == 0) { return (-999); } else { if (posicao == 1) { return (consultarEsquerda()); } else { if (posicao == descritor.n) { return (consultarDireita()); } else { Nodo ref = descritor.primeiro; for (int i = 1; i < posicao; i++) { ref = ref.posterior; } int valor = ref.info; return (valor); } } } } // ---------------------- métodos privados da classe // ---------------------- métodos estáticos da classe } // ------------------------------------------------------------------------------------------------------------------- Programa Principal: ProgDupla.java package progdupla; import java.util.Scanner; public class ProgDupla { 188 public static void main(String[] args) { ListaDupla dupla = new ListaDupla(); Scanner input = new Scanner(System.in); char ch = 'T', op; int valor, posicao; do { dupla.exibeDescritor(); dupla.exibirDireita(); dupla.exibirEsquerda(); do { System.out.print("[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: "); String s = input.nextLine(); op = s.charAt(0); } while (!strChr("IiEeCcPpRrFf", op)); if (strChr("Ff", op)) { System.exit(0); } if (strChr("IiEeCc", op)) { do { System.out.print("[E]squerda, [D]ireita ou [P]osição: "); String s = input.nextLine(); ch = s.charAt(0); } while (!strChr("DdEePp", ch)); } switch (op) { case 'I': case 'i': System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); switch (ch) { case 'D': case 'd': dupla.incluirDireita(valor); break; case 'E': case 'e': dupla.incluirEsquerda(valor); break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); dupla.incluirPosicao(valor, posicao); break; } break; case 'E': case 'e': switch (ch) { case 'D': case 'd': valor = dupla.excluirDireita(); if (valor != -999) { System.out.println("Valor Excluído à Direita: " + valor); } else { System.out.println("ERRO: Lista vazia à Direita"); } break; case 'E': case 'e': valor = dupla.excluirEsquerda(); if (valor != -999) { System.out.println("Valor Excluído à Esquerda: " + valor); } else { System.out.println("ERRO: Lista vazia à Esquerda"); } 189 break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); valor = dupla.excluirPosicao(posicao); if (valor != -999) { System.out.println("Valor Excluído na Posição: " + valor); } else { System.out.println("ERRO: Lista vazia na Posição"); } break; } break; case 'P': case 'p': System.out.print("Valor à Pesquisar: "); s = input.nextLine(); int valorPesquisar = Integer.parseInt(s); posicao = dupla.pesquisar(valorPesquisar); if (posicao != -1) { System.out.println("Posição do Valor pesquisado: " + posicao); } else { System.out.println("ERRO: Valor não encontrado"); } break; case 'R': case 'r': dupla.removeAll(); break; case 'C': case 'c': switch (ch) { case 'D': case 'd': valor = dupla.consultarDireita(); if (valor != -999) { System.out.println("Valor Consultado à Direita: " + valor); } else { System.out.println("ERRO: Lista vazia à Direita"); } break; case 'E': case 'e': valor = dupla.consultarEsquerda(); if (valor != -999) { System.out.println("Valor Consultado à Esquerda: " + valor); } else { System.out.println("ERRO: Lista vazia à Esquerda"); } break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); valor = dupla.consultarPosicao(posicao); if (valor != -999) { System.out.println("Valor Consultado na Posição: " + valor); } else { System.out.println("ERRO: Lista vazia na Posição"); } break; } break; } } while (!strChr("Ff", op)); } 190 public static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } Exemplo para testar o programa: Descritor: | null | 0 | null | Lista pela Direita: [Vazia] Lista pela Esquerda: [Vazia] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> [E]squerda, [D]ireita ou [P]osição: e <enter> Valor: 10 <enter> Descritor: | progdupla.Nodo@3ed8d90c | 1 | progdupla.Nodo@3ed8d90c | Lista pela Direita: [10] Lista pela Esquerda: [10] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> [E]squerda, [D]ireita ou [P]osição: d <enter> Valor: 20 <enter> Descritor: | progdupla.Nodo@3ed8d90c | 2 | progdupla.Nodo@e91c310 | Lista pela Direita: [20 10] Lista pela Esquerda: [10 20] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> [E]squerda, [D]ireita ou [P]osição: d <enter> Valor: 40 <enter> Descritor: | progdupla.Nodo@3ed8d90c | 3 | progdupla.Nodo@39d56e9 | Lista pela Direita: [40 20 10] Lista pela Esquerda: [10 20 40] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter> [E]squerda, [D]ireita ou [P]osição: p <enter> Valor: 30 <enter> Posição: 3 <enter> Descritor: | progdupla.Nodo@3ed8d90c | 4 | progdupla.Nodo@39d56e9 | Lista pela Direita: [40 30 20 10] Lista pela Esquerda: [10 20 30 40] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter> Valor à Pesquisar: 30 <enter> Posição do Valor pesquisado: 3 Descritor: | progdupla.Nodo@3ed8d90c | 4 | progdupla.Nodo@39d56e9 | Lista pela Direita: [40 30 20 10] Lista pela Esquerda: [10 20 30 40] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter> [E]squerda, [D]ireita ou [P]osição: d <enter> Valor Consultado à Direita: 40 Descritor: | progdupla.Nodo@3ed8d90c | 4 | progdupla.Nodo@39d56e9 | Lista pela Direita: [40 30 20 10] Lista pela Esquerda: [10 20 30 40] [I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter> 191 13. Classe entrada de inteiros e reais em Java sem erro na digitação A seguir, são vistos dois programas em Java, cada um com as classes: EntradaDadosScanner e EntradaDadosSwing, respectivamente, e que permitem a entrada de dados via teclado de números inteiros (leInteiro) e reais (LeReal) sem erro de conversão (Integer.parseInt e Double.parseDouble) por descuido na digitação pelo usuário, ou seja, o usuário pode digitar qualquer coisa (em tese, por enquanto) que os métodos da classe eliminam os erros de digitação. Imagine a seguinte entrada de um inteiro e de um real em um programa Java com este tipo de digitação (em vermelho): Exemplo para testar o programa: Digite um Inteiro: -123 de oliveira 4,.56—78 <enter> Inteiro Digitado: 12345678 Digite um Real: -123,.,.45--,.56 <enter> Real Digitado: 123.4556 Analise a resposta em letras azuis. O programa eliminou todos os caracteres inválidos para um inteiro ou para um real, inclusive pontos (.) e vírgulas (,) repetidas e o sinal negativo (-) no local indevido. // --------------------------------------------------------------------------------- Programa Principal: ProgEntradaDadosScanner.java package progentradadadosscanner; public class ProgEntradaDadosScanner { public static void main(String[] args) { EntradaDadosScanner entrada = new EntradaDadosScanner(); int inteiro = entrada.leInteiro("Digite um Inteiro: "); System.out.println("Inteiro Digitado: " + inteiro); Double real = entrada.leReal("Digite um Real: "); System.out.println("Real Digitado: " + real); } } // ------------------------------------------------------------------------------------------------------- Classe: EntradaDadosScanner.java package progentradaDados; import java.util.Scanner; public class EntradaDadosScanner { // ------------------------------------------------------ métodos públicos da classe // -------------------------------------------------- leInteiro public int leInteiro(String mensagem) { Scanner input = new Scanner(System.in); String s; int limite, n; do { System.out.print(mensagem); s = input.nextLine(); s = s.replaceAll("[^0-9\\-]", ""); n = s.length(); // eliminar letras e caracteres não numéricos 192 if (n == 1 && s.charAt(0) == '-') { s = ""; } else { if (n > 0) { s = retiraNegativosForaLugar(s); if (s.charAt(0) == '-') { limite = 11; } else { limite = 10; } if (n >= limite) { s = verificaLimites(s); } } } } while (s.isEmpty()); int inteiro = Integer.parseInt(s); // conversão segura sem erros return (inteiro); } // ----------------------------------------------------------- leReal public double leReal(String mensagem) { Scanner input = new Scanner(System.in); String s; do { System.out.print(mensagem); s = input.nextLine(); s = s.replaceAll("[^0-9\\-.,]", ""); // eliminar letras s = verificaVirgulaPonto(s); s = retiraNegativosForaLugar(s); int n = s.length(); if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) { s = ""; } } while (s.isEmpty()); double real = Double.parseDouble(s); // conversão segura sem erros return (real); } // ----------------------------------------------------- métodos privados da classe // -------------------------------------------------- verificaVirgulaPonto private String verificaVirgulaPonto(String s) { int pontos = 0; char[] r = s.toCharArray(); int n = s.length(); for (int i = 0; i < n; i++) { if (r[i] == ',' || r[i] == '.') { r[i] = '.'; pontos++; } } if (pontos > 1) { r = retiraPontosRepetidos(r); } s = ""; for (int i = 0; i < r.length; i++) { s = s + r[i]; } return (s); } // ----------------------------------------------------------------------------- retiraPontosRepetidos private static char[] retiraPontosRepetidos(char[] s) { int n = s.length; String r = ""; boolean copiou = false; int j = 0; for (int i = 0; i < n; i++) { 193 if (s[i] != '.') { r = r + s[i]; j++; } else { if (!copiou) { r = r + '.'; copiou = true; } } } return (r.toCharArray()); } // ---------------------------------------------------------------------------------- retiraNegativosForaLugar private static String retiraNegativosForaLugar(String s) { String r = ""; int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) != '-' || i == 0) { r = r + s.charAt(i); } } return (r); } // ----------------------------------------------------------------- verificaLimites private static String verificaLimites(String s) { String limiteInferior = "-2147483648"; String limiteSuperior = "2147483647"; if (s.compareTo(limiteInferior) > 0 || s.compareTo(limiteSuperior) > 0) { System.out.println("ERRO: Excedeu o Limite dos Números Inteiros"); return (""); } return (s); } } A seguir uma outra versão utilizando o pacote swing. // -------------------------------------------------------------------------------------- Programa Principal: ProgEntradaDadosSwing.java package progentradadadosswing; import javax.swing.JOptionPane; public class ProgEntradaDadosSwing { public static void main(String[] args) { EntradaDadosSwing entrada = new EntradaDadosSwing(); int inteiro = entrada.leInteiro("Digite um Inteiro: "); JOptionPane.showMessageDialog(null, "Inteiro Digitado: " + inteiro); Double real = entrada.leReal("Digite um Real: "); JOptionPane.showMessageDialog(null, "Real Digitado: " + real); } } // ---------------------------------------------------------------------------------------------------------------------- Classe: EntradaDadosSwing.java package progentradadadosswing; import javax.swing.JOptionPane; public class EntradaDadosSwing { // ----------------------------------------------------- métodos públicos da classe // -------------------------------------------------- leInteiro 194 public int leInteiro(String mensagem) { String s; int n, limite; do { s = JOptionPane.showInputDialog(mensagem); s = s.replaceAll("[^0-9\\-]", ""); // eliminar letras e caracteres não numéricos n = s.length(); if (!(n == 1 && s.charAt(0) == '-')) { if (n > 0) { s = retiraNegativosForaLugar(s); if (s.charAt(0) == '-') { limite = 11; } else { limite = 10; } if (n >= limite) { s = verificaLimites(s); } } } else { s = ""; } } while (s.isEmpty()); int inteiro = Integer.parseInt(s); return (inteiro); } // ----------------------------------------------------------- leReal public double leReal(String mensagem) { String s; do { s = JOptionPane.showInputDialog(mensagem); s = s.replaceAll("[^0-9\\-.,]", ""); // eliminar letras digitadas incorretamente e que não s = verificaVirgulaPonto(s); // podem ser convertidas para double s = retiraNegativosForaLugar(s); int n = s.length(); if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) { s = ""; } } while (s.isEmpty()); double real = Double.parseDouble(s); return (real); } // --------------------------------------------------------------------- métodos privados da classe // --------------------------------------------------------------- verificaVirgulaPonto private String verificaVirgulaPonto(String s) { int pontos = 0; char[] r = s.toCharArray(); int n = s.length(); for (int i = 0; i < n; i++) { if (r[i] == ',' || r[i] == '.') { r[i] = '.'; pontos++; } } if (pontos > 1) { r = retiraPontosRepetidos(r); } s = ""; for (int i = 0; i < r.length; i++) { s = s + r[i]; } return (s); } // -------------------------------------------------------------------------- retiraPontosRepetidos 195 private static char[] retiraPontosRepetidos(char[] s) { int n = s.length; String r = ""; boolean copiou = false; int j = 0; for (int i = 0; i < n; i++) { if (s[i] != '.') { r = r + s[i]; j++; } else { if (!copiou) { r = r + '.'; copiou = true; } } } return (r.toCharArray()); } // ---------------------------------------------------------------------------------- retiraNegativosForaLugar private static String retiraNegativosForaLugar(String s) { String r = ""; int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) != '-' || i == 0) { r = r + s.charAt(i); } } return (r); } // ------------------------------------------------------------------- verificaLimites private static String verificaLimites(String s) { String limiteInferior = "-2147483648"; String limiteSuperior = "2147483647"; if (s.compareTo(limiteInferior) > 0 || s.compareTo(limiteSuperior) > 0) { JOptionPane.showMessageDialog(null, "ERRO: Excedeu o Limite dos Números Inteiros"); return (""); } return (s); } } 196 14. Alguns programas exemplos em Java A seguir são vistos quatro (4) exemplos da utilização das classes existentes do Java vistas no decorrer do livro. 14.1 Torre de Hanoi (Pilha - Stack) A seguir é visto a implementação de uma Torre de Hanoi (Figura 17) em Java usando a classe Stack (Pilha). Figura 17: Jogo Torre de Hanoi Regras do Jogo: a) Não se pode colocar um disco grande sobre um disco pequeno b) Ganha quando trocar todos os três discos de uma torre para outra // ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgTorre.java package progtorre; import java.util.Stack; import java.util.Scanner; 197 public class ProgTorre { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; int in, out; Stack p1 = new Stack(); Stack p2 = new Stack(); Stack p3 = new Stack(); boolean ganhou, moveu = false; p1.push(3); p1.push(2); p1.push(1); exibePilhas(p1, p2, p3); do { do { System.out.print("Move: "); s = entrada.nextLine(); in = Integer.parseInt(s); if (in == 0) { System.exit(0); } } while (in < 1 || in > 3); do { System.out.print("Para: "); s = entrada.nextLine(); out = Integer.parseInt(s); if (in == 0) { System.exit(0); } } while (out < 1 || out > 3); if (testaMovimento(p1, p2, p3, in)) { if (testaMaior(p1, p2, p3, in, out)) { moveu = movePilha(p1, p2, p3, in, out); } } exibePilhas(p1, p2, p3); if (moveu) { ganhou = testaVitoria(p1); if (ganhou) { System.out.println("Status: VENCEDOR (p1)"); System.exit(0); } ganhou = testaVitoria(p2); if (ganhou) { System.out.println("Status: VENCEDOR (p2)"); System.exit(0); } ganhou = testaVitoria(p3); if (ganhou) { System.out.println("Status: VENCEDOR (p3)"); System.exit(0); } } } while (true); } // ------------------------------------------------------ testaVitoria static boolean testaVitoria(Stack p1) { int a, b, c; a = p1.search(1); b = p1.search(2); c = p1.search(3); if (a != -1 && b != -1 && c != -1) { return(true); } 198 else { return(false); } } // ---------------------------------------------------------------------------------------------------- testaMaior static boolean testaMaior(Stack p1, Stack p2, Stack p3, int in, int out) { Object nodo; int a = 0, b = 0; switch (in) { case 1: nodo = p1.peek(); a = nodo.hashCode(); break; case 2: nodo = p2.peek(); a = nodo.hashCode(); break; case 3: nodo = p3.peek(); a = nodo.hashCode(); break; } switch (out) { case 1: if (p1.empty()) { return(true); } else { nodo = p1.peek(); b = nodo.hashCode(); } break; case 2: if (p2.empty()) { return(true); } else { nodo = p2.peek(); b = nodo.hashCode(); } break; case 3: if (p3.empty()) { return(true); } else { nodo = p3.peek(); b = nodo.hashCode(); } break; } if (a < b) return(true); else { return(false); } } // --------------------------------------------------------------------------------------------------- testaMovimento static boolean testaMovimento(Stack p1, Stack p2, Stack p3, int in) { boolean pode = false; switch (in) { case 1: if (p1.empty()) { System.out.println("Status: Impossivel mover (p1)"); } else { pode = true; } break; case 2: if (p2.empty()) { System.out.println("Status: Impossivel mover (p2)"); 199 } else { pode = true; } break; case 3: if (p3.empty()) { System.out.println("Status: Impossivel mover (p3)"); } else { pode = true; } break; } return(pode); } // -------------------------------------------------------------------------------------------------- movePilha static boolean movePilha(Stack p1, Stack p2, Stack p3, int a, int b) { Object nodo; int in = 0; boolean moveu = false; switch (a) { case 1: if (!p1.empty()) { nodo = p1.pop(); in = nodo.hashCode(); } else { in = 0; } break; case 2: if (!p2.empty()) { nodo = p2.pop(); in = nodo.hashCode(); } else { in = 0; } break; case 3: if (!p3.empty()) { nodo = p3.pop(); in = nodo.hashCode(); } else { in = 0; } break; } if (in != 0) { switch (b) { case 1: p1.push(in); moveu = true; break; case 2: p2.push(in); moveu = true; break; case 3: p3.push(in); moveu = true; break; } } return(moveu); } // --------------------------------------------------------------------------------- exibePilhas static void exibePilhas(Stack p1, Stack p2, Stack p3) { System.out.println("p1: " + p1); System.out.println("p2: " + p2); 200 System.out.println("p3: " + p3); } Observação: Substitua o método exibePilhas pelo método abaixo. // ------------------------------------------------------------------------------- exibePilhas static void exibePilhas(Stack p1, Stack p2, Stack p3) { char a1 = '|', a2 = '|', a3 = '|'; char b1 = '|', b2 = '|', b3 = '|'; char c1 = '|', c2 = '|', c3 = '|'; Object nodo; nodo = p1.search(1); a1 = nodo.toString().charAt(0); if (a1 != '-') { a1 = '1'; } nodo = p1.search(2); a2 = nodo.toString().charAt(0); if (a2 != '-') { a2 = '2'; } nodo = p1.search(3); a3 = nodo.toString().charAt(0); if (a3 != '-') { a3 = '3'; } nodo = p2.search(1); b1 = nodo.toString().charAt(0); if (b1 != '-') { b1 = '1'; } nodo = p2.search(2); b2 = nodo.toString().charAt(0); if (b2 != '-') { b2 = '2'; } nodo = p2.search(3); b3 = nodo.toString().charAt(0); if (b3 != '-') { b3 = '3'; } nodo = p3.search(1); c1 = nodo.toString().charAt(0); if (c1 != '-') { c1 = '1'; } nodo = p3.search(2); c2 = nodo.toString().charAt(0); if (c2 != '-') { c2 = '2'; } nodo = p3.search(3); c3 = nodo.toString().charAt(0); if (c3 != '-') { c3 = '3'; } if (c3 == '-' && c2 == '-' && c1 != '-') { c3 = c1; c1 = '-'; } if (c3 == '-' && c2 != '-' && c1 == '-') { c3 = c2; c2 = '-'; } 201 if (c3 == '-' && c2 != '-' && c1 != '-') { c3 = c2; c2 = c1; c1 = '-'; } if (b3 == '-' && b2 == '-' && b1 != '-') { b3 = b1; b1 = '-'; } if (b3 == '-' && b2 != '-' && b1 == '-') { b3 = b2; b2 = '-'; } if (b3 == '-' && b2 != '-' && b1 != '-') { b3 = b2; b2 = b1; b1 = '-'; } if (a3 == '-' && a2 == '-' && a1 != '-') { a3 = a1; a1 = '-'; } if (a3 == '-' && a2 != '-' && a1 == '-') { a3 = a2; a2 = '-'; } if (a3 == '-' && a2 != '-' && a1 != '-') { a3 = a2; a2 = a1; a1 = '-'; } System.out.printf(" %c %c %c \n", a1, b1, c1); System.out.printf(" %c %c %c \n", a2, b2, c2); System.out.printf(" %c %c %c \n", a3, b3, c3); System.out.printf("--------- --------- ---------\n"); System.out.printf(" p1 p2 p3\n\n"); } } 14.2 Analisador de Expressões usando Stack Programa abaixo implementa um Analisador de Expressões utilizando a classe Java Stack. O programa resolve expressões do tipo: (4*(5+(4*3)/(3-1))) ou (3*(4+5)) Exemplo de entrada de dados: Expressão: (4*(5+(4*3)/(3-1))) <enter> // ----------------------------------------------------------------------------------------- Programa Principal: ProgAnalisaExpressao.java package proganalisaexpressao; import java.util.Stack; import java.util.Scanner; public class ProgAnalisaExpressao { public static void main(String[] args) { Stack numeros = new Stack(); Stack operadores = new Stack(); Scanner entrada = new Scanner(System.in); String s; float resp; System.out.print("Expressao: "); 202 s = entrada.nextLine(); int n = s.length(); if (testaExpressao(s)) { for (int i = 0;i < n;i++) { if (s.charAt(i) == '(') { continue; } if ("0123456789".indexOf(s.charAt(i)) != -1) { char ch = s.charAt(i); float t = (float) ch - 48; numeros.push(t); exibePilha(numeros); exibePilha(operadores); System.out.println(); } else { if ("+-*/".indexOf(s.charAt(i)) != -1) { char op = s.charAt(i); operadores.push(op); } } if (s.charAt(i) == ')') { Object nodo = numeros.pop(); String st = nodo.toString(); float y = Float.parseFloat(st); nodo = numeros.pop(); st = nodo.toString(); float x = Float.parseFloat(st); nodo = operadores.pop(); String temp = nodo.toString(); char op = temp.charAt(0); resp = calculaOperacao(x, y, op); numeros.push(resp); exibePilha(numeros); exibePilha(operadores); } } System.out.println(); if (operadores.empty()) { Object nodo = numeros.pop(); String st = nodo.toString(); resp = Float.parseFloat(st); } else { resp = 0; while (!operadores.empty()) { Object nodo = numeros.pop(); String st = nodo.toString(); float y = Float.parseFloat(st); nodo = numeros.pop(); st = nodo.toString(); float x = Float.parseFloat(st); nodo = operadores.pop(); String temp = nodo.toString(); char op = temp.charAt(0); resp = calculaOperacao(x, y, op); numeros.push(resp); exibePilha(numeros); exibePilha(operadores); } } System.out.println("Resposta: " + resp); } else { System.out.println("Erro: Expressao Invalida"); } } 203 // ---------------------------------------- calculaOperacao static float calculaOperacao(float x, float y, char op) { float resp = 0; switch (op) { case '+': resp = x + y; break; case '-': resp = x - y; break; case '*': resp = x * y; break; case '/': if (y != 0) { resp = x / y; } else { System.out.println("Erro Fatal: Divisão por Zero"); System.exit(0); } break; } return(resp); } // ------------------------------------------------------------------ testaExpressao static boolean testaExpressao(String exp) { int abre = 0, fecha = 0; for (int i = 0;i < exp.length();i++) { if (exp.charAt(i) == '(') { abre++; } if (exp.charAt(i) == ')') { fecha++; } } if (abre == fecha) { return(true); } else return(false); } // ------------------------------------------------------- exibePilha static void exibePilha(Stack pilha) { Object [] nodo = pilha.toArray(); System.out.print("Pilha: "); for (int i = 0;i < nodo.length;i++) { System.out.print(nodo[i] + " "); } System.out.println(); } } Exemplo para testar o programa: Expressão: (4*(5+(4*3)/(3-1))) <enter> Pilha: 4 Pilha: Pilha: 5 4 Pilha: * Pilha: 4 5 4 Pilha: + * Pilha: 3 4 5 4 204 Pilha: * + * Pilha: 12 5 4 Pilha: + * Pilha: 3 12 5 4 Pilha: / + * Pilha: 1 3 12 5 4 Pilha: - / + * Pilha: 2 12 5 4 Pilha: / + * Pilha: 6 5 4 Pilha: + * Pilha: 11 4 Pilha: * Pilha: 44 Pilha: Resposta: 44 14.3 Calculadora Polonesa Reversa A seguir, o programa implementa uma calculadora Polonesa Reversa, ou seja, o usuário digita primeiro dois valores e depois o operador. Exemplo para testar o programa: Polonesa Reversa: <enter> abandona 3 <enter> 2 <enter> / <enter> 1.5 2 <enter> * <enter> 3 <enter> by Polonesa Reversa // -------------------------------------------------------------------------------------- Programa Prinicpal: ProgPolonesaReversa.java package progpolonesareversa; public class ProgPolonesaReversa { public static void main(String[] args) { PolonesaReversa polonesa = new PolonesaReversa(); polonesa.calculaPolonesaReversa(); } } // -------------------------------------------------------------------------------------------------------- Classe: PolonesaReversa.java package progpolonesareversa; import java.util.Scanner; public class PolonesaReversa { // --------------------------------------------------- atributos da classe private double x, y, resp = 0; private char op; private int erro; 205 // ----------------------------------------------------- métodos públicos da classe public PolonesaReversa () { // construtor erro = 0; } public void calculaPolonesaReversa() { Scanner entrada = new Scanner(System.in); String s; System.out.println("Polonesa Reversa: <enter> abandonar"); do { if (resp == 0) { s = entrada.nextLine(); if (s.equals("")) { System.out.println("by Polonesa Reversa"); System.exit(0); } s = s.replaceAll("[^0-9\\-.]", ""); // elimina letras digitadas incorretamente x = Double.parseDouble(s); } else { x = resp; } s = entrada.nextLine(); if (s.equals("")) { System.out.println("by Polonesa Reversa"); System.exit(0); } s = s.replaceAll("[^0-9\\-.]", ""); // elimina letras digitadas incorretamente y = Double.parseDouble(s); do { s = entrada.nextLine(); if (s.equals("")) { System.out.println("by Polonesa Reversa"); System.exit(0); } op = s.charAt(0); } while (!strChr("+-*/Pp", op)); operaCalculadora(); exibeCalculadora(); } while (!s.equals("")); } // ---------------------------------------------------- operaCalculadora private void operaCalculadora() { switch (op) { case '+': resp = soma(x, y); break; case '-': resp = subtracao(x, y); break; case '*': resp = multiplicacao(x, y); break; case '/': if (y == 0) erro = 1; // divisão por zero else resp = divisao(x, y); break; case 'P': case 'p': resp = power(x, y); // potência break; } } // ---------------------------------------------------- exibeCalculadora private void exibeCalculadora() { switch (erro) { case 1: System.out.println("Erro: Divisão por Zero"); 206 break; case 2: System.out.println("Erro: Raiz Complexa"); break; case 3: System.out.println("Erro: Tangente Inválida"); break; default: System.out.println(resp); } } // ................................................ métodos privados da classe // ---------------------------- strChr private boolean strChr(String s, char ch) { for (int i = 0; i < s.length(); i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } // ------------------------------------------------------------ soma private double soma(double x, double y) { return(x + y); } // ----------------------------------------------------------------- subtração private double subtracao(double x, double y) { return(x - y); } // ------------------------------------------------------------------------- multiplicação private double multiplicacao(double x, double y) { return(x * y); } // -------------------------------------------------------------- divisão private double divisao(double x, double y) { if (y == 0) { erro = 1; return(-1); } return(x / y); } // ---------------------------------------------------------------- power private double power(double x, double y) { return(Math.pow(x, y)); } } 14.4 Jogo Quebra-Cabeças A seguir é visto a implementação de um jogo chamado Quebra-Cabeças (Figura 18), cujo objetivo é colocar os números de 1 à 8 em ordem crescente, conforme exemplo abaixo: 207 Figura 18: Jogo Quebra-Cabeças // ------------------------------------------------------------------------------------------------ Programa Principal: ProgQuebraCabeca.java package progquebracabeca; public class ProgQuebraCabeca { public static void main(String[] args) { Tabuleiro tabuleiro = new Tabuleiro(); tabuleiro.sorteiaNumeros(); tabuleiro.exibeTabuleiro(); tabuleiro.jogadasJogador(); } } // ---------------------------------------------------------------------------------------------------------------------- Classe: Tabuleiro.java package progcabeca; import java.util.Scanner; public class Tabuleiro { private final int [][] matriz = new int [3][3]; private final int [][] certa = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}}; private int jogadas = 0; // ------------------------------------------------- verificaVitoria private boolean verificaVitoria() { for (int l = 0;l < 3;l++) { for (int c = 0;c < 3;c++) { if (matriz[l][c] != certa[l][c]) { return(false); } } } return(true); } // ---------------------------------------------------------------- verificaDeslocamento private void verificaDeslocamento(int num) { int lin = 0, col = 0; int ll = 0, cc = 0; for (int l = 0;l < 3;l++) { for (int c = 0;c < 3;c++) { if (matriz[l][c] == num) { lin = l; col = c; } } } 208 for (int l = 0;l < 3;l++) { for (int c = 0;c < 3;c++) { if (matriz[l][c] == 0) { ll = l; cc = c; } } } if ((lin == ll || col == cc) && ((ll-lin == 1 || lin-ll == 1) || (cc-col == 1 || col-cc == 1))){ matriz[ll][cc] = num; matriz[lin][col] = 0; exibeTabuleiro(); } else { System.out.println("Status: Movimento Inválido"); } if (verificaVitoria()) { System.out.println("Vitória"); System.exit(0); } } // ----------------------------------------------------- jogadasJogador public void jogadasJogador() { Scanner input = new Scanner(System.in); char tecla; do { System.out.print("Move (" + jogadas + "): "); String s = input.nextLine(); tecla = s.charAt(0); if (strChr("12345678", tecla)) { verificaDeslocamento(tecla-48); jogadas++; if (jogadas == 99) { System.out.println("Game Over"); System.exit(0); } } } while (tecla != '0'); } // --------------------------------------------- exibeTabuleiro public void exibeTabuleiro() { for (int l = 0;l < 3;l++) { for (int c = 0;c < 3;c++) { if (matriz[l][c] != 0) { System.out.printf("%2d ", matriz[l][c]); } else { System.out.printf(" "); } } System.out.println(); } } // ----------------------------------------------- sorteiaNumeros public void sorteiaNumeros() { for (int i = 1;i <= 8;i++) { boolean ok = false; do { int l = (int) (Math.random() * 3); int c = (int) (Math.random() * 3); if (matriz[l][c] == 0) { matriz[l][c] = i; ok = true; 209 } } while (!ok); } } // ------------------------------------------------------------- strChr private boolean strChr(String s, char tecla) { int n = s.length(); for (int i = 0;i < n;i++) { if (s.charAt(i) == tecla) { return(true); } } return(false); } } 210 Anexos: Solução dos problemas propostos no Livro Anexo 1.4 Solução da Lista: Classes 1.4.1 ProgCirculo // ------------------------------------------------------------------------------------------------ Classe: Circulo.java package progcirculo; public class Circulo { // ---------------------------- atributos da classe private double raio; private double area; // --------------------------- construtor // ---------------------------------------------------- métodos públicos da classe public void setRaio(double raio) { this.raio = raio; } public void calculaArea() { area = Math.PI * Math.pow(raio, 2); } public double getArea() { return (area); } // ---------------------- métodos privados da classe // ---------------------- métodos estáticos da classe } // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgCirculo.java package progcirculo; public class ProgCirculo { public static void main(String[] args) { Circulo circ = new Circulo(); circ.setRaio(3); circ.calculaArea(); double area = circ.getArea(); System.out.printf("Área: %.2f\n", area); } } 1.4.2 ProgPeso // ------------------------------------------------------------------------------------------------------------ Classe: PesoIdeal.java package progpeso; public class PesoIdeal { // ---------------------------- atributos de classe private char sexo; private double altura; private double pesoIdeal; // ----------------------------------------------------- construtor da classe PesoIdeal(char sexo, double altura) { 211 this.sexo = sexo; this.altura = altura; } // -------------------------------------------------- métodos públicos da classe public void calculaPesoIdeal() { switch (sexo) { case 'H': case 'h': pesoIdeal = 72.7 * altura - 58.0; break; case 'M': case 'm': pesoIdeal = 62.1 * altura - 44.7; break; default: System.out.println("ERRO: Sexo Inválido"); } } public double getPesoIdeal() { return (pesoIdeal); } // ------------------------ métodos privados da classe // ------------------------ métodos estáticos da classe } // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgPeso.java package progpeso; public class ProgPeso { public static void main(String[] args) { PesoIdeal piHomem = new PesoIdeal('H', 1.67); // sexo, altura PesoIdeal piMulher = new PesoIdeal('m', 1.65); // sexo, altura piHomem.calculaPesoIdeal(); System.out.printf("Peso Ideal Homem: %.2f\n", piHomem.getPesoIdeal()); piMulher.calculaPesoIdeal(); System.out.printf("Peso Ideal Mulher: %.2f\n", piMulher.getPesoIdeal()); } } 1.4.3 ProgValidaCPF // ----------------------------------------------------------------------------------------------------------------------------- Classe: CPF.java package progvalidacpf; public class CPF { // ---------------------------- atributos da classe private String cpf; private int digito; // ------------------------------ construtor da classe CPF(String cpf) { this.cpf = cpf; } // ------------------------------------ métodos públicos da classe public int verificaCPF() { int soma = 0; int x = 10; int n = cpf.length(); 212 for (int i = 0;i < n;i++) { soma = soma + (cpf.charAt(i) - 48) * x; x--; } System.out.println("Soma: " + soma); int digito1 = 11 - soma % 11; if (digito1 == 10 || digito1 == 11) { digito1 = 0; } System.out.println("Digito 1: " + digito1); cpf = cpf + digito1; System.out.println("CPF: " + cpf); soma = 0; x = 11; n = cpf.length(); for (int i = 0;i < n;i++) { soma = soma + (cpf.charAt(i) - 48) * x; x--; } System.out.println("Soma: " + soma); int digito2 = 11 - soma % 11; if (digito2 == 10 || digito2 == 11) { digito2 = 0; } System.out.println("Digito 2: " + digito2); digito = digito1 * 10 + digito2; return(digito); // converte char para int // 48 é o código ascii do zero } // --------------------- métodos privados da classe // --------------------- métodos estáticos da classe } // -------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java package progvalidacpf; public class ProgValidaCPF { public static void main(String[] args) { String s = "123456789"; CPF cpf = new CPF(s); int digitoVerificador = cpf.verificaCPF(); System.out.printf("Digito verificador: %02d\n", digitoVerificador); System.out.printf("CPF: %s-%02d\n", s , digitoVerificador); } } 1.4.4 ProgDiaSemana // --------------------------------------------------------------------------------------------------------------- Classe: DiaSemana.java package progdiasemana; public class DiaSemana { // ------------------------------ atributos da classe private int dia; private int mes; private int ano; private String semana; // ---------------------------------------------------- construtor DiaSemana(int dia, int mes, int ano) { this.dia = dia; this.mes = mes; this.ano = ano; } 213 //------------------------------------------------------- métodos públicos da classe public void verificaDiaSemana() { int numeroDias = (ano - 1901) * 365 + (ano - 1901) / 4 + dia + (mes - 1) * 31 - ((mes * 4 + 23) / 10) * ((mes + 12) / 15) + ((4 - ano % 4) / 4) * ((mes + 12) / 15); int resto = numeroDias % 7; switch (resto) { case 0: semana = "segunda-feira"; break; case 1: semana = "terça-feira"; break; case 2: semana = "quarta-feira"; break; case 3: semana = "quinta-feira"; break; case 4: semana = "sexta-feira"; break; case 5: semana = "sábado"; break; case 7: semana = "domingo"; break; } } public void exibeDiaSemana() { System.out.printf("%02d/%02d/%4d é um(a) %s\n", dia, mes, ano, semana); } } // ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgDiaSemana.java package progdiasemana; public class ProgDiaSemana { public static void main(String[] args) { DiaSemana dia = new DiaSemana(10, 2, 1962); dia.verificaDiaSemana(); dia.exibeDiaSemana(); } } 1.4.5 ProgTestData // ------------------------------------------------------------------------------------------------------------------------- Classe: Data.java package progtestdata; public class Data { // ------------------------------ atributos da classe private int dia; private int mes; private int ano; // ------------------------------ construtor da classe // ---------------------------------------- métodos públicos da classe public void setDia(int dia) { if (dia >= 1 && dia <= 31) { this.dia = dia; } else { this.dia = 1; System.out.println("ERRO: Dia Inválido"); } } 214 public void setMes(int mes) { if (mes >= 1 && mes <= 12) { this.mes = mes; } else { this.mes = 1; System.out.println("ERRO: Mês Inválido"); } } public void setAno(int ano) { this.ano = ano; } public void setData(int dia, int mes, int ano) { setDia(dia); setMes(mes); setAno(ano); } public void extenso() { String [] nomeMes = {"janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"}; System.out.printf("Data: %d de %s de %d\n", dia, nomeMes[mes - 1], ano); } // ------------------------------ métodos privados da classe // ------------------------------ métodos estáticos da classe } // ------------------------------------------------------------------------------------------------ Programa Principal: ProgTestData.java package progtestdata; public class ProgTestData { public static void main(String[] args) { Data data = new Data(); data.setData(25, 8, 2014); data.extenso(); } } 1.4.6 ProgVetorSort // ----------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java package progvetorsort; public class Vetor { // -------------------------- atributos da classe private int[] vetor; private int n; private final int max; // ------------------------------------------- construtor Vetor(int numeroElementos) { max = numeroElementos; vetor = new int[max]; n = 0; } // --------------------------------------- add public void add(int valor) { 215 if (n < max) { vetor[n] = valor; n++; } else { System.out.println("ERRO: Excedeu o Limite do Vetor"); } } // --------------------------- remove public void del() { if (n > 0) { n--; } else { System.out.println("ERRO: Vetor Vazio"); } } // ------------------------------------------------------------ removeElemento public void removeElemento(int valor) { if (n > 0) { for (int i = 0; i < n; i++) { if (valor == vetor[i]) { for (int j = i; j < n - 1; j++) { vetor[j] = vetor[j + 1]; } n--; break; } } } else { System.out.println("ERRO: Vetor Vazio"); } } // ------------------------------------------------------------- removePosicao public void removePosicao(int posicao) { if (n > 0 && posicao > 0 && posicao < n) { for (int j = posicao; j < n - 1; j++) { vetor[j] = vetor[j + 1]; } n--; } else { System.out.println("ERRO: Vetor Vazio"); } } // --------------------------------------- primeiro public int primeiro() { if (n > 0) { return (vetor[0]); } else { return (-1); } } // --------------------------------- ultimo public int ultimo() { if (n > 0) { return (vetor[n - 1]); } else { return (-1); } } // ----------------------------------- exibe public void exibe() { System.out.print("Vetor: ["); for (int i = 0; i < n - 1; i++) { 216 System.out.print(vetor[i] + " "); } System.out.println(vetor[n - 1] + "]"); } // ----------------------------------------- length public int length() { return (n); } // -------------------------------------------------- existe public boolean existe(int valor) { for (int i = 0; i < n; i++) { if (vetor[i] == valor) { return (true); } } return (false); } // -------------------------------------- bubbleSort public void bubbleSort() { int u = n - 1; boolean trocou; int vezes = 0; do { trocou = false; for (int i = 0; i < u; i++) { if (vetor[i] > vetor[i + 1]) { trocou = true; int temp = vetor[i]; vetor[i] = vetor[i + 1]; vetor[i + 1] = temp; } } u--; } while (trocou); } // ------------------------------------ forcaBruta public void forcaBruta() { int u = n - 1; for (int i = 0; i < u; i++) { for (int j = i + 1; j <= u; j++) { if (vetor[i] > vetor[j]) { int temp = vetor[i]; vetor[i] = vetor[j]; vetor[j] = temp; } } } } } // ------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java package progvetorsort; public class ProgVetorSort { public static void main(String[] args) { Vetor vetor = new Vetor(5); vetor.add(40); vetor.add(20); vetor.add(30); 217 vetor.add(50); vetor.add(10); vetor.exibe(); vetor.add(60); vetor.exibe(); vetor.forcaBruta(); vetor.exibe(); vetor.bubbleSort(); vetor.exibe(); } } 1.4.7 ProgPessoa // ------------------------------------------------------------------------------------------------------------------------ Classe: Pessoa.java package progpessoa; import java.util.Date; public class Pessoa { // -------------------------------- atributos da classe private String nome; private int ano; private int idade; private char sexo; // ---------------------- construtor // -------------------------------------------------------- métodos públicos da classe public void setNome(String nome) { this.nome = nome; } public void setAno(int ano) { this.ano = ano; } public void setSexo(char sexo) { this.sexo = sexo; } public void setDados(String nome, int ano, char sexo) { setNome(nome); setAno(ano); setSexo(sexo); } public void calculaIdade() { Date date = new Date(); // carrega a data do sistema String data = date.toString(); // converte para String String [] partes = data.split(" "); // parte a data em pedaços int n = partes.length; // descobre o número de padaços int anoAtual = Integer.parseInt(partes[n-1]); // pega o último pedaço, aonde está o ano atual idade = anoAtual - ano; } public void exibePessoa() { System.out.println("Nome: " + nome); System.out.println("Idade: " + idade + " ano(s)"); switch (sexo) { case 'M': case 'm': System.out.println("Sexo: Masculino"); break; case 'F': case 'f': System.out.println("Sexo: Feminino"); break; 218 } } // ---------------------- métodos privados da classe // ---------------------- métodos estátivos da classe } // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java package progpessoa; public class ProgPessoa { public static void main(String[] args) { Pessoa p1 = new Pessoa(); Pessoa p2 = new Pessoa(); Pessoa p3 = new Pessoa(); p1.setDados("Paulo Roberto", 1962, 'm'); p2.setDados("Renato Luis", 1965, 'm'); p3.setDados("Francisco Carlos", 1959, 'm'); p1.calculaIdade(); p2.calculaIdade(); p3.calculaIdade(); p1.exibePessoa(); p2.exibePessoa(); p3.exibePessoa(); } } 1.4.8 ProgPessoa2 // ----------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package progpessoa2; import java.util.Date; public class Pessoa { // --------------------------------- atributos da classe private String nome; private int ano; private int idade; private char sexo; // ---------------------- construtor // ------------------------------------------------------ métodos públicos da classe public void setNome(String nome) { this.nome = nome; } public void setAno(int ano) { this.ano = ano; } public void setSexo(char sexo) { this.sexo = sexo; } public void setDados(String nome, int ano, char sexo) { setNome(nome); setAno(ano); setSexo(sexo); } public void calculaIdade() { 219 Date date = new Date(); String data = date.toString(); String [] partes = data.split(" "); int n = partes.length; int anoAtual = Integer.parseInt(partes[n-1]); idade = anoAtual - ano; // carrega a data do sistema // converte para String // parte a data em pedaços // descobre o número de pedaços // pega o último pedaço, aonde está o ano atual } public void exibePessoa() { System.out.println("Nome: " + nome); System.out.println("Idade: " + idade + " ano(s)"); switch (sexo) { case 'M': case 'm': System.out.println("Sexo: Masculino"); break; case 'F': case 'f': System.out.println("Sexo: Feminino"); break; } } // ---------------------- métodos privados da classe // ---------------------- métodos estátivos da classe } // -------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa2.java package progpessoa2; public class ProgPessoa2 { public static void main(String[] args) { Pessoa [] pessoa = new Pessoa[3]; pessoa[0] = new Pessoa(); pessoa[0].setDados("Paulo Roberto", 1962, 'm'); pessoa[0].calculaIdade(); pessoa[0].exibePessoa(); pessoa[1] = new Pessoa(); pessoa[1].setDados("Renato Luis", 1960, 'm'); pessoa[1].calculaIdade(); pessoa[1].exibePessoa(); pessoa[2] = new Pessoa(); pessoa[2].setDados("Francisco Carlos", 1959, 'm'); pessoa[2].calculaIdade(); pessoa[2].exibePessoa(); } } 1.4.9 ProgPessoas // ----------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package progpessoas; public class Pessoa { // ---------------------------------- atributos da classe private String[] nome; private int[] idade; private int n; private final int max; // ------------------------------------------ construtor Pessoa(int numeroPessoas) { this.max = numeroPessoas; 220 nome = new String[this.max]; idade = new int[this.max]; this.n = 0; } // ---------------------------------------------------------------------- métodos públicos da classe public void insereDados(String nome, int idade) { if (n < max) { this.nome[n] = nome; this.idade[n] = idade; n++; } else { System.out.println("ERRO: Vetor Lotado"); } } public void exibeDados() { System.out.println("Lista de Pessoas"); for (int i = 0; i < n; i++) { System.out.printf("Nome: %-10s Idade: %d\n", nome[i], idade[i]); } } public void sort() { for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (nome[i].compareTo(nome[j]) > 0) { String temp = nome[i]; nome[i] = nome[j]; nome[j] = temp; int t = idade[i]; idade[i] = idade[j]; idade[j] = t; } } } } // ---------------------- métodos privados da classe // ---------------------- métodos estátivos da classe } // -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java package progpessoas; public class ProgPessoas { public static void main(String[] args) { Pessoa pessoa = new Pessoa(7); pessoa.insereDados("Beatriz", 11); pessoa.insereDados("Debora", 13); pessoa.insereDados("Fátima", 15); pessoa.insereDados("Geni", 16); pessoa.insereDados("Carla", 12); pessoa.insereDados("Eva", 14); pessoa.insereDados("Ana", 10); pessoa.exibeDados(); pessoa.sort(); pessoa.exibeDados(); } } 1.4.10 ProgAgenda // ---------------------------------------------------------------------------------------------------------------------------- Classe: Agenda.java 221 package progagenda; public class Agenda { // ----------------------------- atributos da classe private String [] nome; private String [] fone; private int n; private final int max; // --------------------------------------------- construtor Agenda(int numeroPessoas) { this.max = numeroPessoas; nome = new String[this.max]; fone = new String[this.max]; this.n = 0; } // ----------------------------------------------------------------------------------------- métodos públicos da classe public void insereTelefone(String nome, String fone) { if (n < max) { this.nome[n] = nome; this.fone[n] = fone; n++; } else { System.out.println("ERRO: Agenda Lotada"); } } public String consultaNome(String fone) { String nome; for (int i = 0;i < n;i++) { if (this.fone[i].compareTo(fone) == 0) { return(this.nome[i]); } } return(""); } // ----------------------------- métodos privados da classe // ----------------------------- métodos estáticos da classe } // -------------------------------------------------------------------------------------------------- Programa Principal: ProgAgenda.java package progagenda; public class ProgAgenda { public static void main(String[] args) { Agenda agenda = new Agenda(5); agenda.insereTelefone("Ana", "9981-1234"); agenda.insereTelefone("Beatriz", "9981-2345"); agenda.insereTelefone("Carla", "9981-3456"); agenda.insereTelefone("Debora", "9981-4567"); agenda.insereTelefone("Eva", "9981-5678"); agenda.insereTelefone("Fátima", "9981-6789"); String fone = "99815678"; String nome = agenda.consultaNome(fone); if (nome.compareTo("") != 0) { System.out.println("Nome: " + nome + " - Telefone: " + fone); } else { System.out.println("ERRO: Usuário não Encontrado"); } fone = "9981-0123"; nome = agenda.consultaNome(fone); 222 if (nome.compareTo("") != 0) { System.out.println("Nome: " + nome + " - Telefone: " + fone); } else { System.out.println("ERRO: Usuário não Encontrado"); } } } Anexo 2.3 Solução da Lista: Interface e Polimorfismo 2.3.1 ProgInterface_1 // -------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java package proginterface_1; public class ProgInterface_1 { public static void main(String[] args) { Cardeal cardeal = new Cardeal("Cardeal", "Vermelho", "Cinza"); CardealBanhado cardealBanhado = new CardealBanhado("Cardeal Banhado", "Vermelho", "preto"); cardeal.exibeNome(); cardeal.exibeCores(); cardealBanhado.exibeNome(); cardealBanhado.exibeCores(); } } // ------------------------------------------------------------------------------------------------------------------------ Interface: Passaro.java package proginterface_1; public interface Passaro { public final int numeroPatas = 2; public abstract void exibeNome(); public abstract void exibeCores(); } // ----------------------------------------------------------------------------------------------------------------------- Classe: Cardeal.java package proginterface_1; public class Cardeal implements Passaro { // ---------------------------------------- atributos da classe private final String nome; private final String cor_topete; private final String cor_corpo; Cardeal(String nome, String cor_topete, String cor_corpo) { this.nome = nome; this.cor_topete = cor_topete; this.cor_corpo = cor_corpo; } @Override public void exibeNome() { System.out.println("Nome do Pássaro: " + nome); System.out.println("Número de Patas: " + numeroPatas); } @Override public void exibeCores() { System.out.println("Cor do Topete: " + cor_topete); 223 System.out.println("Cor do Corpo: " + cor_corpo); } } // -------------------------------------------------------------------------------------------------------- Classe: CardealBanhado.java package proginterface_1; public class CardealBanhado implements Passaro { // --------------------------------------- atributos da classe private final String nome; private final String cor_topete; private final String cor_corpo; CardealBanhado(String nome, String cor_topete, String cor_corpo) { this.nome = nome; this.cor_topete = cor_topete; this.cor_corpo = cor_corpo; } @Override public void exibeNome() { System.out.println("Nome do Pássaro: " + nome); System.out.println("Número de Patas: " + numeroPatas); } @Override public void exibeCores() { System.out.println("Cor do Topete: " + cor_topete); System.out.println("Cor do Corpo: " + cor_corpo); } } 2.3.2 ProgInterface_2 // ---------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java package proginterface_2; public class ProgInterface_2 { public static void main(String[] args) { Homem homem = new Homem(); Mulher mulher = new Mulher(); homem.setDados("Paulo Roberto", 52, 'm'); mulher.setDados("Adriane Maria", 45, 'f'); System.out.println(homem); System.out.println(mulher); } } // ----------------------------------------------------------------------------------------------------------------------------- Interface: Pessoa.java package proginterface_2; public interface Pessoa { public abstract void setDados(String nome, int idade, char sexo); public abstract String toString(); } // ------------------------------------------------------------------------------------------------------------------------- Classe: Homem.java package proginterface_2; public class Homem implements Pessoa { private String nome; 224 private int idade; private char sexo; @Override public void setDados(String nome, int idade, char sexo) { setNome(nome); setIdade(idade); setSexo(sexo); } // ----------------------------------------- sobrecarga do método toString public String toString() { return("| Homem: " + nome + " | Idade: " + idade + " | Sexo: MASCULINO |"); } private void setNome(String nome) { this.nome = nome; } private void setIdade(int idade) { this.idade = idade; } private void setSexo(char sexo) { this.sexo = sexo; } } // -------------------------------------------------------------------------------------------------------------------- Classe: Mulher.java package proginterface_2; public class Mulher implements Pessoa { private String nome; private int idade; private char sexo; @Override public void setDados(String nome, int idade, char sexo) { setNome(nome); setIdade(idade); setSexo(sexo); } // ----------------------------------------- sobrecarga do método toString @Override public String toString() { return("| Mulher: " + nome + " | Idade: " + idade + " | Sexo: FEMININO |"); } private void setNome(String nome) { this.nome = nome; } private void setIdade(int idade) { this.idade = idade; } private void setSexo(char sexo) { this.sexo = sexo; } } 2.3.2 ProgInterface_3 225 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java package proginterface_3; public class ProgInterface_3 { public static void main(String[] args) { Pessoa pessoa1 = new Pessoa(); Pessoa pessoa2 = new Pessoa(); pessoa1.set("Paulo Roberto"); pessoa1.set(52); pessoa1.set('m'); System.out.println("Pessoa1: " + pessoa1); pessoa2.set("Adriane Maria"); pessoa2.set(45); pessoa2.set('f'); System.out.println("Pessoa2: " + pessoa2); } } // -------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java package proginterface_3; public class Pessoa { private String nome; private int idade; private char sexo; public void set(String nome) { this.nome = nome; } public void set(int idade) { this.idade = idade; } public void set(char sexo) { this.sexo = sexo; } // ------------------------------- sobrecarga do método toString @Override public String toString() { return("| Nome: " + nome + " | Idade: " + idade + " | Sexo: " + sexo + " |"); } } Anexo 3.4 Solução da Lista: Herança 3.4.1 Herança (Primeiro) // ----------------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java package progtestapessoa; public class Pessoa { protected String nome; protected String cpf; Pessoa() { this.nome = "xxxx"; this.cpf = "xxx.xxx.xxx-xx"; 226 } Pessoa(String nome, String cpf) { this.nome = nome; this.cpf = cpf; } public void imprimePessoa() { System.out.println("Nome: " + nome); System.out.println("CPF: " + cpf); } } // ----------------------------------------------------------------------------------------------------------- Classe Derivada: Cliente.java package progtestapessoa; public class Cliente extends Pessoa { private double conta; Cliente(String nome, String cpf, double conta) { super(nome, cpf); this.conta = conta; } public void imprimeCliente() { System.out.println("Conta: " + conta); } } // ------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaPessoa.java package progtestapessoa; public class ProgTestaHeranca { public static void main(String[] args) { Cliente cliente = new Cliente("Paulo Roberto", "123.456.789-09", 1234.56); cliente.imprimePessoa(); cliente.imprimeCliente(); } } 3.4.2 Herança (Segundo) // ---------------------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java package progtestahomem; public class Pessoa { protected double altura; protected char sexo; Pessoa() { this.altura = 0.0; this.sexo = 'g'; } Pessoa(double altura, char sexo) { this.altura = altura; this.sexo = sexo; } public void imprimePessoa() { 227 System.out.println("Altura: " + altura); System.out.println("Sexo: " + sexo); } } // -------------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java package progtestahomem; public class Homem extends Pessoa { // ------------------------------------------- atributos da classe private double pesoIdeal; // ---------------------------------------------------- construtor Homem(double altura, char sexo) { super(altura, sexo); } // ------------------------------------------------------------ métodos públicos da classe public void calculaPesoIdealHomem() { pesoIdeal = 72.7 * altura - 58.0; } public void imprimePesoIdealHomem() { System.out.printf("Peso Ideal (Homem): %.2f\n", pesoIdeal); } // ------------------------------- métodos privados da classe // ------------------------------- métodos estáticos da classe } // ------------------------------------------------------------------------------------------------------ Classe Derivada: Mulher.java package progtestahomem; public class Mulher extends Pessoa { // --------------------------------------- atributos da classe private double pesoIdeal; // ------------------------------------------------- construtor Mulher(double altura, char sexo) { super(altura, sexo); } // ------------------------------------------------------- métodos públicos da classe public void calculaPesoIdealMulher() { pesoIdeal = 62.1 * altura - 44.7; } public void imprimePesoIdealMulher() { System.out.printf("Peso Ideal (Mulher): %.2f\n", pesoIdeal); } // ------------------------------- métodos privados da classe // ------------------------------- métodos estáticos da classe } // --------------------------------------------------------------------------------------------- Programa Principal: ProgTestaHomem.java package progtestahomem; public class ProgTestaHomem { public static void main(String[] args) { Homem homem = new Homem(1.64, 'm'); Mulher mulher = new Mulher(1.59, 'f'); homem.calculaPesoIdealHomem(); 228 homem.imprimePessoa(); homem.imprimePesoIdealHomem(); mulher.calculaPesoIdealMulher(); mulher.imprimePessoa(); mulher.imprimePesoIdealMulher(); } } 3.4.3 Herança (Terceiro) // ------------------------------------------------------------------------------------------------------------------- Classe Base: Objeto.java package progtestaobjetos; public class Objeto { protected int x; protected int y; Objeto() { x = 0; y = 0; } Objeto(int x, int y) { this.x = x; this.y = y; } public void imprimeObjeto(String mensagem) { System.out.println(mensagem + " -> (" + x + "," + y + ")"); } } // --------------------------------------------------------------------------------------------------------- Classe Derivada: Linha.java package progtestaobjetos; public class Linha extends Objeto { private final Objeto p1; private final Objeto p2; Linha (int xi, int yi, int xf, int yf) { p1 = new Objeto(xi, yi); p2 = new Objeto(xf, yf); } public void imprimeLinha(String mensagem) { System.out.println(mensagem); System.out.println("x: " + p1.x + " | y: " + p1.y); p1.imprimeObjeto("p1"); System.out.println("x: " + p2.x + " | y: " + p2.y); p2.imprimeObjeto("p2"); } } // -------------------------------------------------------------------------------------------------- Classe Derivada: Retangulo.java package progtestaobjetos; public class Retangulo extends Objeto { private final Objeto p1; private final Objeto p2; private final Objeto p3; private final Objeto p4; Retangulo (int xi, int yi, int xf, int yf) { p1 = new Objeto(xi, yi); p2 = new Objeto(xf, yi); 229 p3 = new Objeto(xf, yf); p4 = new Objeto(xi, yf); } public void imprimeRetangulo(String mensagem) { System.out.println(mensagem); System.out.println("x: " + p1.x + " | y: " + p1.y); p1.imprimeObjeto("p1"); System.out.println("x: " + p2.x + " | y: " + p2.y); p2.imprimeObjeto("p2"); System.out.println("x: " + p3.x + " | y: " + p3.y); p3.imprimeObjeto("p3"); System.out.println("x: " + p4.x + " | y: " + p4.y); p4.imprimeObjeto("p4"); } } // ------------------------------------------------------------------------------------------- Programa Principal: ProgTestaObjetos.java package progtestaobjetos; public class ProgTestaObjetos { public static void main(String[] args) { Linha linha = new Linha(1, 2, 3, 4); Retangulo retangulo = new Retangulo(1, 2, 3, 4); linha.imprimeLinha("Linha"); retangulo.imprimeRetangulo("Retângulo"); } } Anexo 4.4 Solução da Lista: Entrada e Saída Bufferizada 4.4.1 ProgBuffer_1 // ---------------------------------------------------------------------------------------------- Programa Principal: ProgBuffer_1.java package progbuffer_1; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; public class ProgBuffer_1 { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out)); String text = in.readLine(); String[] partes = text.split(" "); int n = partes.length; out.write("Quantidade de Valores Digitados: " + n); out.newLine(); int soma = 0; int maior = 0, menor = 9999; for (int i = 0; i < n; i++) { int t = Integer.parseInt(partes[i]); soma = soma + t; if (t > maior) { maior = t; } if (t < menor) { menor = t; } 230 } double media = (double) soma / n; out.write("Média: " + media); out.newLine(); out.write("Maior: " + maior); out.newLine(); out.write("Menor: " + menor); out.newLine(); out.flush(); } } 4.4.2 ProgBuffer_2 // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgBuffer_2.java package progbuffer_2; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.util.Arrays; public class ProgBuffer_2 { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out)); String text = in.readLine(); int n = Integer.parseInt(text); int[] vetor = new int[n]; text = in.readLine(); String[] partes = text.split(" "); int max = partes.length; if (max == n) { for (int i = 0; i < n; i++) { vetor[i] = Integer.parseInt(partes[i]); } Arrays.sort(vetor); for (int i = 0; i < n; i++) { out.write(vetor[i] + " "); } } else { out.write("Erro na Entrada dos valores"); } out.newLine(); out.flush(); } } 231 Anexo 5.6.1 Solução da Lista: Vector, ArrayList e LinkedList 5.6.1.1 ProgVector_1 // ----------------------------------------------------------------------------------------- Programa Principal: ProgVector_1.java package progvector_1; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_1 { public static void main(String[] args) { ArrayList letras = new ArrayList(); ArrayList inverso = new ArrayList(); Scanner input = new Scanner(System.in); char letra; do { System.out.print("Letra: "); String s = input.nextLine(); letra = s.charAt(0); if (letra != 'F' && letra != 'f') { letras.add(letra); } } while (letra != 'F' && letra != 'f'); int n = letras.size(); int u = n - 1; for (int i = u;i >= 0;i--) { inverso.add(letras.get(i)); } System.out.println(letras); System.out.println(inverso); } } 5.6.1.2 ProgVector_2 // ---------------------------------------------------------------------------------------------------- Programa Base: ProgVector_2.java package progvector_2; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_2 { public static void main(String[] args) { ArrayList <Integer> idade = new ArrayList(); Scanner input = new Scanner(System.in); System.out.print("Número de Idades: "); String s = input.nextLine(); int n = Integer.parseInt(s); int u = n - 1; for (int i = 0; i <= u; i++) { System.out.print("Idade: "); s = input.nextLine(); int leIdade = Integer.parseInt(s); idade.add(leIdade); } char ch; do { int antes = 0; System.out.print("Idade para Consulta: "); s = input.nextLine(); 232 int idadeConsulta = Integer.parseInt(s); // antes = idades.indexOf(idadeConsulta); for (int i = 0; i < n; i++) { if (idade.get(i) != idadeConsulta) { antes++; } else { break; } } System.out.println("Antes: " + antes); int depois = n - antes - 1; System.out.println("Depois: " + depois); do { System.out.print("Continua [S/N]? "); s = input.nextLine(); ch = s.charAt(0); } while (!strChr("SsNn", ch)); } while (strChr("Ss", ch)); // Sugestão do Discente: Afrânio Peres da Fonseca } // ------------------------------------------ método estático: strChr static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } } 5.6.1.3 ProgVector_3 // ---------------------------------------------------------------------------------------------------------- Programa Base: ProgVector_3.java package progvector_3; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_3 { public static void main(String[] args) { ArrayList <Integer> numeros = new ArrayList(); Scanner input = new Scanner(System.in); int leNumero, valor; do { System.out.print("Número: "); String s = input.nextLine(); leNumero = Integer.parseInt(s); if (leNumero != 0) { numeros.add(leNumero); } } while (leNumero != 0); int n = numeros.size(); int u = n – 1; do { System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); /* int posicao = numeros.indexOf(valor); if (posicao == -1) { System.out.println("ERRO: Número não encontrado"); } else { System.out.println("Posição: " + posicao); 233 } */ boolean encontrou = false; if (valor != 0) { for (int i = 0; i <= u; i++) { if (numeros.get(i) == valor) { System.out.println("Posição no Vetor: " + i); encontrou = true; break; } } if (!encontrou) { System.out.println("Erro: Número não encontrado"); } } } while (valor != 0); } } 5.6.1.4 ProgVector_4 // -------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_4.java package progvector_4; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_4 { public static void main(String[] args) { ArrayList <Character> conceito = new ArrayList(); Scanner input = new Scanner(System.in); char ch; do { System.out.print("Conceito: "); String s = input.nextLine(); ch = s.charAt(0); if (!strChr("Ff", ch)) { if (strChr("AaBbCcDdEe", ch)) { conceito.add(ch); } } } while (!strChr("Ff", ch)); int aprovados = 0, reprovados = 0, infrequentes = 0; int n = conceito.size(); for (int i = 0; i < n; i++) { if (strChr("AaBbCc", conceitos.get(i))) { aprovados++; } else { if (strChr("Dd", conceitos.get(i))) { reprovados++; } else { infrequentes++; } } } System.out.println(aprovados + " aprovado(s)"); System.out.println(reprovados + " reprovado(s)"); System.out.println(infrequentes + " infrequente(s)"); } // ------------------------------------------ método estático: strChr static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { 234 return (true); } } return (false); } } 5.6.1.5 ProgVector_5 // ---------------------------------------------------------------------------------------------- Programa Prinicpal: ProgVector_5.java package progvector_5; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_5 { public static void main(String[] args) { ArrayList nomes = new ArrayList(); Scanner input = new Scanner(System.in); String s; char letra; do { System.out.print("Nome: "); s = input.nextLine(); if (!s.equals("")) { nomes.add(s); } } while (!s.equals("")); int n = nomes.size(); do { System.out.print("Letra: "); s = input.nextLine(); if (s.equals("")) { System.exit(0); } letra = s.charAt(0); for (int i = 0; i < n; i++) { if (nomes.get(i).toString().charAt(0) == letra) { System.out.println("Nome: " + nomes.get(i).toString()); } } } while (!s.equals("")); System.out.println("Nomes: " + nomes.toString()); } } 5.6.1.6 ProgVector_6 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_6.java package progvector_6; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_6 { public static void main(String[] args) { ArrayList <String> nome = new ArrayList<>(); ArrayList <Integer> idade = new ArrayList(); Scanner input = new Scanner(System.in); String s; char ch; do { 235 System.out.print("Nome: "); s = input.nextLine(); nome.add(s); System.out.print("Idade: "); s = input.nextLine(); int idadeDigitada = Integer.parseInt(s); idade.add(idadeDigitada); do { System.out.print("Continua [S/N]? "); s = input.nextLine(); ch = s.charAt(0); } while (!strChr("SsNn", ch)); } while (strChr("Ss", ch)); Object [] nomes = nome.toArray(); Object [] idades = idade.toArray(); int n = nome.size(); int u = n - 1; for (int i = 0; i < u; i++) { for (int j = i+1; j <= u; j++) { if (idades[i].hashCode() < idades[j].hashCode()) { Object temp = nomes[i]; nomes[i] = nomes[j]; nomes[j] = temp; Object t = idades[i]; idades[i] = idades[j]; idades[j] = t; } } } for (int i = 0; i <= u; i++) { System.out.printf("%-10s %d\n", nomes[i], idades[i]); } } // ------------------------------------------------------------------------------- strChr // Testa se um caracter está presente dentro da string public static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } } 5.6.1.7 ProgVector_7 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_7.java package progvector_7; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class ProgVector_7 { public static void main(String[] args) { ArrayList nome = new ArrayList(); Scanner input = new Scanner(System.in); String s; do { System.out.print("Nome: "); s = input.nextLine(); if (!s.equals("")) { 236 nome.add(s); } } while (!s.equals("")); Object [] vetor = nome.toArray(); Arrays.sort(vetor); System.out.println(Arrays.toString(vetor)); } } 5.6.1.8 ProgVector_8 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_8.java package progvector_8; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class ProgVector_8 { public static void main(String[] args) { ArrayList <Integer> idade = new ArrayList(); Scanner input = new Scanner(System.in); int leIdade; do { System.out.print("Idade: "); String s = input.nextLine(); leIdade = Integer.parseInt(s); if (leIdade != 0) { idade.add(leIdade); } } while (leIdade != 0); Object [] idades = idade.toArray(); Arrays.sort(idades); System.out.print("Idades Ordenadas: "); int n = idades.length; double soma = 0.0; for (int i = 0; i < n; i++) { System.out.print(idades[i] + " "); soma = soma + idades[i].hashCode(); } System.out.println("\nMaior Idade: " + idades[n-1]); System.out.println("Menor Idade: " + idades[0]); double media = soma / n; System.out.println("Média: " + media); } } 5.6.1.9 ProgVector_9 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVector_9.java package progvector_9; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; public class ProgVector_9 { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out)); String text = in.readLine(); 237 String [] partes_1 = text.split(" "); int n1 = partes_1.length; for (int i = 0;i < n1;i++) { int t = Integer.parseInt(partes_1[i]); } text = in.readLine(); String [] partes_2 = text.split(" "); int n2 = partes_2.length; for (int i = 0;i < n2;i++) { int t = Integer.parseInt(partes_2[i]); } int pontos = 0; for (int i = 0; i < n2; i++) { for (int j = 0; j < n1; j++) { if (partes_2[i].equals(partes_1[j])) { pontos++; } } } out.write(pontos + " ponto(s)"); out.newLine(); out.flush(); } } 5.6.1.10 ProgVector_10 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_10.java package progvector_10; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class ProgVector_10 { public static void main(String[] args) { ArrayList megaSena = new ArrayList(); Scanner input = new Scanner(System.in); int numeroPalpites; do { System.out.print("Número de Palpites para a MegaSena: "); String s = input.nextLine(); numeroPalpites = Integer.parseInt(s); } while (numeroPalpites < 0); for (int i = 1; i <= numeroPalpites; i++) { int numeroAleatorio = 1 + (int) (Math.random() * 100); megaSena.add(numeroAleatorio); for (int j = 1; j <= 5; j++) { numeroAleatorio = 1 + (int) (Math.random() * 100); if (!testaRepetido(megaSena, numeroAleatorio)) { megaSena.add(numeroAleatorio); } } Object[] temp = megaSena.toArray(); Arrays.sort(temp); megaSena.removeAll(megaSena); int n = temp.length; for (int k = 0; k < n; k++) { megaSena.add(temp[k]); } System.out.println("Palpite para MegaSena é " + megaSena.toString()); megaSena.removeAll(megaSena); } } 238 static boolean testaRepetido(ArrayList megaSena, int valor) { int n = megaSena.size(); for (int i = 0; i < n; i++) { if (megaSena.get(i).hashCode() == valor) { return(true); } } return (false); } } 5.6.1.11 ProgVector_11 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_11.java package progvector_11; import java.util.LinkedList; import java.util.Scanner; public class ProgVector_11 { public static void main(String[] args) { LinkedList lista = new LinkedList(); Scanner input = new Scanner(System.in); char opcao, lado; Object valor; do { do { System.out.print("[I]ncluir, [C]onsultar, [R]emover ou [F]im: "); String s = input.nextLine(); opcao = s.charAt(0); } while (!strChr("IiCcRrFf", opcao)); if (strChr("Ff", opcao)) { System.exit(0); } do { System.out.print("[E]squerda ou [D]ireita "); String s = input.nextLine(); lado = s.charAt(0); } while (!strChr("EeDd", lado)); switch (opcao) { case 'I': case 'i': System.out.print("Dado: "); String s = input.nextLine(); int dado = Integer.parseInt(s); if (dado != 0) { switch (lado) { case 'E': case 'e': lista.addFirst(dado); break; case 'D': case 'd': lista.addLast(dado); break; } } break; case 'C': case 'c': switch (lado) { case 'E': case 'e': valor = lista.getFirst(); 239 System.out.println("Dado Consultado: " + valor); break; case 'D': case 'd': valor = lista.getLast(); System.out.println("Dado Consultado: " + valor); break; } break; case 'R': case 'r': switch (lado) { case 'E': case 'e': if (!lista.isEmpty()) { valor = lista.removeFirst(); System.out.println("Dado Removido à esquerda: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; case 'D': case 'd': if (!lista.isEmpty()) { valor = lista.removeLast(); System.out.println("Dado Removido à Direita: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; } break; } System.out.println("LinkedList: " + lista); } while (true); } static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 5.6.1.12 ProgVector_12 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVector_12.java package progvector_12; import java.util.LinkedList; import java.util.Scanner; public class ProgVector_12 { public static void main(String[] args) { LinkedList lista = new LinkedList(); Scanner input = new Scanner(System.in); char opcao, lado; Object valor; int posicao; do { do { 240 System.out.print("[I]ncluir, [C]onsultar, [R]emover ou [F]im: "); String s = input.nextLine(); opcao = s.charAt(0); } while (!strChr("IiCcRrFf", opcao)); if (strChr("Ff", opcao)) { System.exit(0); } do { System.out.print("[E]squerda, [P]osição [D]ireita: "); String s = input.nextLine(); lado = s.charAt(0); } while (!strChr("EePpDd", lado)); switch (opcao) { case 'I': case 'i': System.out.print("Dado: "); String s = input.nextLine(); int dado = Integer.parseInt(s); if (dado != 0) { switch (lado) { case 'E': case 'e': lista.addFirst(dado); break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); int n = lista.size(); if (posicao >= 0 && posicao < n) { lista.add(posicao, dado); } else { System.out.println("ERRO: Posição Inválida"); } break; case 'D': case 'd': lista.addLast(dado); break; } } break; case 'C': case 'c': switch (lado) { case 'E': case 'e': valor = lista.getFirst(); System.out.println("Dado Consultado: " + valor); break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); int n = lista.size(); if (posicao >= 0 && posicao < n) { valor = lista.get(posicao); System.out.println("Dado Consultado: " + valor); } else { System.out.println("ERRO: Posição Inválida"); } break; case 'D': case 'd': valor = lista.getLast(); 241 System.out.println("Dado Consultado: " + valor); break; } break; case 'R': case 'r': switch (lado) { case 'E': case 'e': if (!lista.isEmpty()) { valor = lista.removeFirst(); System.out.println("Dado Removido à esquerda: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; case 'P': case 'p': System.out.print("Posição: "); s = input.nextLine(); posicao = Integer.parseInt(s); int n = lista.size(); if (posicao >= 0 && posicao < n) { valor = lista.remove(posicao); System.out.println("Dado Removido da Posição: " + valor); } else { System.out.println("ERRO: Posição Inválida"); } break; case 'D': case 'd': if (!lista.isEmpty()) { valor = lista.removeLast(); System.out.println("Dado Removido à Direita: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; } break; } System.out.println("LinkedList: " + lista); } while (true); } // ------------------------------------------------------- método estático static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 5.6.1.13 ProgVector_13 // -------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_13.java package progvector_13; import java.util.LinkedList; import java.util.Scanner; public class ProgVector_13 { 242 public static void main(String[] args) { LinkedList lista = new LinkedList(); Scanner input = new Scanner(System.in); char opcao, lado = 'E'; Object valor; do { do { System.out.print("[I]ncluir, [E]lemento, [R]emover ou [F]im: "); String s = input.nextLine(); opcao = s.charAt(0); } while (!strChr("IiEeRrFf", opcao)); if (strChr("Ff", opcao)) { System.exit(0); } if (strChr("IiRr", opcao)) { do { System.out.print("[E]squerda ou [D]ireita "); String s = input.nextLine(); lado = s.charAt(0); } while (!strChr("EeDd", lado)); } switch (opcao) { case 'I': case 'i': System.out.print("Dado: "); String s = input.nextLine(); int dado = Integer.parseInt(s); if (dado != 0) { switch (lado) { case 'E': case 'e': lista.addFirst(dado); break; case 'D': case 'd': lista.addLast(dado); break; } } break; case 'E': case 'e': System.out.print("Elemento a Pesquisar: "); s = input.nextLine(); int elemento = Integer.parseInt(s); int indice = lista.indexOf(elemento); if (indice - 1 >= 0) { System.out.println("Antecessor: " + lista.get(indice - 1)); } else { System.out.println("ERRO: SEM ANTECESSOR"); } if (indice + 1 < lista.size()) { System.out.println("Sucessor: " + lista.get(indice + 1)); } else { System.out.println("ERRO: SEM SUCESSOR"); } break; case 'R': case 'r': switch (lado) { case 'E': case 'e': if (!lista.isEmpty()) { valor = lista.removeFirst(); System.out.println("Dado Removido à esquerda: " + valor); } else { System.out.println("ERRO: Lista Vazia"); 243 } break; case 'D': case 'd': if (!lista.isEmpty()) { valor = lista.removeLast(); System.out.println("Dado Removido à Direita: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; } break; } System.out.println("LinkedList: " + lista); } while (true); } static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 5.6.1.14 ProgVector_14 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_14.java package progvector_14; import java.util.LinkedList; import java.util.Scanner; public class ProgVector_14 { public static void main(String[] args) { LinkedList lista = new LinkedList(); Scanner input = new Scanner(System.in); char opcao, lado = 'E'; Object valor; do { do { System.out.print("[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: "); String s = input.nextLine(); opcao = s.charAt(0); } while (!strChr("IiEeRrPpFf", opcao)); if (strChr("Ff", opcao)) { System.exit(0); } if (strChr("IiRr", opcao)) { do { System.out.print("[E]squerda ou [D]ireita: "); String s = input.nextLine(); lado = s.charAt(0); } while (!strChr("EeDd", lado)); } switch (opcao) { case 'I': case 'i': System.out.print("Dado: "); String s = input.nextLine(); int dado = Integer.parseInt(s); 244 if (dado != 0) { switch (lado) { case 'E': case 'e': lista.addFirst(dado); break; case 'D': case 'd': lista.addLast(dado); break; } } break; case 'E': case 'e': System.out.print("Elemento a Pesquisar: "); s = input.nextLine(); int elemento = Integer.parseInt(s); int indice = lista.indexOf(elemento); if (indice - 1 >= 0) { System.out.println("Antecessor: " + lista.get(indice - 1)); } else { System.out.println("ERRO: SEM ANTECESSOR"); } if (indice + 1 < lista.size()) { System.out.println("Sucessor: " + lista.get(indice + 1)); } else { System.out.println("ERRO: SEM SUCESSOR"); } break; case 'R': case 'r': switch (lado) { case 'E': case 'e': if (!lista.isEmpty()) { valor = lista.removeFirst(); System.out.println("Dado Removido à esquerda: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; case 'D': case 'd': if (!lista.isEmpty()) { valor = lista.removeLast(); System.out.println("Dado Removido à Direita: " + valor); } else { System.out.println("ERRO: Lista Vazia"); } break; } break; case 'P': case 'p': System.out.print("Indice: "); s = input.nextLine(); indice = Integer.parseInt(s); if (indice >= 0 && indice < lista.size()) { valor = lista.get(indice); System.out.println("Dado Pesquisado pelo Indice: " + valor); } else { System.out.println("ERRO: Indice Inexistente"); } break; } System.out.print(" Indices: "); for (int i = 0; i < lista.size(); i++) { 245 System.out.printf("%3d ", i); } System.out.println("\nLinkedList: " + lista); } while (true); } static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 5.6.1.15 ProgVector_15 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_15.java package progvector_15; import java.util.Arrays; import java.util.LinkedList; import java.util.Scanner; public class ProgVector_15 { public static void main(String[] args) { LinkedList lista = new LinkedList(); Scanner input = new Scanner(System.in); char opcao, lado = 'E'; Object valor; do { do { System.out.print("[I]ncluir, [S]ort, [C]lear All ou [F]im: "); String s = input.nextLine(); opcao = s.charAt(0); } while (!strChr("IiSsCcFf", opcao)); if (strChr("Ff", opcao)) { System.exit(0); } if (strChr("Ii", opcao)) { do { System.out.print("[E]squerda ou [D]ireita: "); String s = input.nextLine(); lado = s.charAt(0); } while (!strChr("EeDd", lado)); } switch (opcao) { case 'I': case 'i': System.out.print("Dado: "); String s = input.nextLine(); int dado = Integer.parseInt(s); if (dado != 0) { switch (lado) { case 'E': case 'e': lista.addFirst(dado); break; case 'D': case 'd': lista.addLast(dado); break; } 246 } break; case 'S': case 's': Object[] objetos = lista.toArray(); Arrays.sort(objetos); lista.clear(); for (int i = 0; i < objetos.length; i++) { lista.add(objetos[i]); } break; case 'C': case 'c': lista.clear(); break; } System.out.print(" Indices: "); for (int i = 0; i < lista.size(); i++) { System.out.printf("%3d ", i); } System.out.println("\nLinkedList: " + lista); } while (true); } // ------------------------------------------------------- método estático static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 5.6.1.16 ProgVector_16 // ----------------------------------------------------------------------------------------------- Programa Principal: ProgVector_16.java package progvector_16; import java.util.ArrayList; import java.util.Scanner; public class ProgVector_16 { public static void main(String[] args) { ArrayList<Integer> array = new ArrayList(); Scanner input = new Scanner(System.in); Integer info = 999; do { System.out.print("Info: "); String s = input.nextLine(); if (!s.equals("")) { if (info == 999) { array.add(Integer.parseInt(s)); info++; } else { info = Integer.parseInt(s); if (info != 0) { int posicao = verificaPosicao(array, info); if (posicao != -1) { array.add(posicao, info); } else { System.out.println("ERRO: Informação Repetida"); } 247 } } } System.out.println("ArrayList: " + array); } while (info != 0); } // ------------------------------------------------------- método estático public static int verificaPosicao(ArrayList array, Integer info) { int posicao = -1; int n = array.size(); for (int i = 0; i < n; i++) { if (info == array.get(i).hashCode()) { // elimina informação repetida return (-1); } if (info < array.get(i).hashCode()) { // localiza posição da informação menor return (i); } if (info > array.get(i).hashCode()) { // localiza posição da informação maior posicao = i + 1; } } return (posicao); } } 248 Anexo 5.8.2 Solução da Lista: Strings 5.8.2.1 ProgString_1 // ----------------------------------------------------------------------------------------------- Programa Principal: ProgString_1.java package progstring_1; import java.util.Scanner; public class ProgString_1 { public static void main(String[] args) { Scanner input = new Scanner(System.in); int vogais = 0, consoantes, espacos = 0; int maiusculas = 0, minusculas; System.out.print("Nome: "); String nome = input.nextLine(); int totalLetras = nome.length(); for (int i = 0;i < totalLetras;i++) { if ("AaEeIiOoUu".indexOf(nome.charAt(i)) != -1) { vogais++; } if (nome.charAt(i) == 32) { // 32 é o ' ' (espaço em branco) espacos++; } if (nome.charAt(i) >= 'A' && nome.charAt(i) <= 'Z') { maiusculas++; } } System.out.printf("(%d) Vogal(is)\n", vogais); consoantes = totalLetras - vogais - espacos; System.out.printf("(%d) Consoante(s)\n", consoantes); System.out.printf("(%d) Maúscula(s)\n", maiusculas); minusculas = totalLetras - maiusculas - espacos; System.out.printf("(%d) Minúscula(s)\n", minusculas); } } 5.8.2.2 ProgString_2 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_2.java package progstring_2; import java.util.Scanner; public class ProgString_2 { public static void main(String[] args) { Scanner input = new Scanner(System.in); char digito; do { int contaLetras = 0; System.out.print("Palavra: "); String palavra = input.nextLine(); System.out.print("Letra: "); String s = input.nextLine(); char letra = s.charAt(0); int n = palavra.length(); for (int i = 0; i < n; i++) { if (palavra.charAt(i) == letra) { contaLetras++; } 249 } if (contaLetras == 0) { System.out.println("ERRO: Não existe a letra " + letra + " na palavra (" + palavra + ")"); } else { System.out.println(contaLetras + " letra(s)"); } do { System.out.print("Continua [S]im ou [N]ão? "); s = input.nextLine(); digito = s.charAt(0); } while ("SsNn".indexOf(digito) == -1); } while ("Ss".indexOf(digito) != -1); } } 5.8.2.3 ProgString_3 // -------------------------------------------------------------------------------------------------- Programa Principal: ProgString_3.java package progstring_3; import java.util.Scanner; public class ProgString_3 { public static void main(String[] args) { Scanner input = new Scanner(System.in); char antecessora = 'X', sucessora = 'Y'; System.out.print("Palavra: "); String palavra = input.nextLine(); System.out.print("Posição: "); String s = input.nextLine(); int posicao = Integer.parseInt(s); int n = palavra.length(); if (posicao < 0 || posicao > n) { System.out.println("Erro: Posição Inválida"); } else { if (posicao == 0) { System.out.println("Erro: Sem Antecessora"); } else { antecessora = palavra.charAt(posicao - 1); } if (posicao == n - 1) { System.out.println("Erro: Sem Sucessora"); } else { sucessora = palavra.charAt(posicao + 1); } System.out.println("Antecessora: " + antecessora); System.out.println("Letra: " + palavra.charAt(posicao)); System.out.println("Sucessora: " + sucessora); } } } 5.8.2.4 ProgString_4 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_4.java package progstring_4; import java.util.Scanner; public class ProgString_4 { public static void main(String[] args) { Scanner input = new Scanner(System.in); 250 System.out.print("Nome: "); String nome = input.nextLine(); String [] partes = nome.split(" "); int n = partes.length; // número de palavras da String int u = n - 1; // último elemento da String for (int i = u;i >= 0;i--) { System.out.println(partes[i]); } } } 5.8.2.5 ProgString_5 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_5.java package progstring_5; import java.util.Scanner; public class ProgString_5 { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("Nome: "); String nome = input.nextLine(); String[] partes = nome.split(" "); int n = partes.length; int u = n - 1; System.out.println(partes[u].toUpperCase()); } } 5.8.2.6 ProgString_6 // ------------------------------------------------------------------------------------------------ Programa Principal: ProgString_6.java package progstring_6; import java.util.Scanner; public class ProgString_6 { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("Nome: "); String nome = input.nextLine(); nome = corrigeNome(nome); System.out.println("Nome corrigido: " + nome); String[] partes = nome.split(" "); int n = partes.length; System.out.print(partes[n - 1] + ", " + partes[0] + " "); for (int i = 1;i < n-1;i++) { System.out.print(partes[i].charAt(0) + ". "); } System.out.println(); } static String corrigeNome(String nome) { nome = nome.toLowerCase(); int n = nome.length(); String temp = ""; temp = temp + Character.toUpperCase(nome.charAt(0)); for (int i = 1; i < n; i++) { if (nome.charAt(i) == 32) { 251 temp = temp + " " + Character.toUpperCase(nome.charAt(i + 1)); i++; } else { temp = temp + nome.charAt(i); } } return (temp); } } 5.8.2.7 ProgString_7 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_7.java package progstring_7; import java.util.Scanner; public class ProgString_7 { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("Estado: "); String estado = input.nextLine(); estado = converteString(estado); System.out.println("Estado corrigido: " + estado); String [] partes = estado.split(" "); int n = partes.length; if (n >= 2) { System.out.println("Sigla: " + partes[0].charAt(0) + partes[n-1].charAt(0)); } } static String converteString(String s) { String temp = ""; s = s.toLowerCase(); temp = temp + Character.toUpperCase(s.charAt(0)); int n = s.length(); for (int i = 1;i < n;i++) { if (s.charAt(i) == 32) { temp = temp + " " + Character.toUpperCase(s.charAt(i+1)); i++; } else { temp = temp + s.charAt(i); } } return(temp); } } 5.8.2.8 ProgString_8 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgString_8.java package progstring_8; import java.util.Scanner; public class ProgString_8 { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("Palavra: "); String palavra = input.nextLine(); int n = palavra.length(); 252 System.out.print("Início: "); String s = input.nextLine(); int inicio = Integer.parseInt(s); if (inicio < 0) { System.out.println("ERRO: Início Inválido"); System.exit(0); } System.out.print("Fim: "); s = input.nextLine(); int fim = Integer.parseInt(s); if (fim >= n) { System.out.println("ERRO: Fim Inválido"); System.exit(0); } if (fim < inicio) { int temp = inicio; inicio = fim; fim = temp; } for (int i = inicio;i <= fim;i++) { System.out.print(palavra.charAt(i)); } System.out.println(); } } Anexo 6.4 Solução da Lista: Listas Lineares 6.4.1 ProgLista_1 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_1.java package proglista_1; import java.util.Scanner; import java.util.Stack; public class ProgLista_1 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); String s; do { System.out.print("Nome: "); s = input.nextLine(); } while (s.equals("")); String [] partes = s.split(" "); int n = partes.length; for (int i = 0;i < n;i++) { pilha.push(partes[i].charAt(0)); } int totalLetras = 0; System.out.print("Abreviatura: "); do { Character letra = (Character) pilha.pop(); System.out.print(letra); totalLetras++; } while (!pilha.empty()); System.out.println(); System.out.println("Pilha: " + pilha.toString()); System.out.println("Total de Letras: " + totalLetras); // cast } } 253 6.4.2 ProgLista_2 // ------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_2.java package proglista_2; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgLista_2 { public static void main(String[] args) { Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); int espacos = 0; String s; do { System.out.print("Nome: "); s = input.nextLine(); } while (s.equals("")); int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) != 32) { fila.offer(s.charAt(i)); // insere na Fila } else { espacos++; } } System.out.print("Nome Modificado: "); do { Character letra = (Character) fila.poll(); // remove da fila - cast System.out.print(letra); } while (!fila.isEmpty()); System.out.println(); System.out.println("Número de Espaços Eliminados: " + espacos); } } 6.4.3 ProgLista_3 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_3.java package proglista_3; import java.util.Scanner; import java.util.Stack; public class ProgLista_3 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); String nome; int homens = 0, mulheres = 0, indeterminados = 0; do { System.out.print("Nome: "); nome = input.nextLine(); if (nome.compareTo("") != 0) { int n = nome.length(); int u = n - 1; switch (nome.charAt(u)) { case 'A': case 'a': pilha.push('f'); 254 mulheres++; break; case 'O': case 'o': pilha.push('m'); homens++; break; default: pilha.push('i'); indeterminados++; } } } while (nome.compareTo("") != 0); System.out.println("Pilha: " + pilha.toString()); System.out.println(homens + " homens"); System.out.println(mulheres + " mulheres"); System.out.println(indeterminados + " indeterminados"); } } 6.4.4 ProgLista_4 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_4.java package proglista_4; import java.util.Arrays; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgLista_4 { public static void main(String[] args) { Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); String nome; do { System.out.print("Nome: "); nome = input.nextLine(); if (!nome.equals("")) { fila.offer(nome); } } while (!nome.equals("")); Object [] temp = fila.toArray(); Arrays.sort(temp); System.out.println("Fila: " + Arrays.toString(temp)); } } 6.4.5 ProgLista_5 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgLista_5.java package proglista_5; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgLista_5 { public static void main(String[] args) { Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); Integer valor, quantidade; 255 do { System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { System.out.print("Quantidade: "); s = input.nextLine(); quantidade = Integer.parseInt(s); fila.offer(valor); fila.offer(quantidade); } } while (valor != 0); int totalImpresso = 0; System.out.println("Fila: " + fila.toString()); do { valor = (Integer) fila.poll(); // cast quantidade = (Integer) fila.poll(); // cast for (int i = 1;i <= quantidade;i++) { System.out.print(valor + " "); totalImpresso++; } } while (!fila.isEmpty()); System.out.println(); System.out.println("Total de Valores Impressos: " + totalImpresso); } } 6.4.6 ProgLista_6 // ------------------------------------------------------------------------------------------------ Programa Principal: ProgLista_6.java package proglista_6; import java.util.Scanner; import java.util.Stack; public class ProgLista_6 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); String nome; do { System.out.print("Nome: "); nome = input.nextLine(); if (!nome.equals("")) { int n = nome.length(); pilha.push(n); } } while (!nome.equals("")); System.out.println("Pilha: " + pilha.toString()); if (!pilha.isEmpty()) { int i = 0; int totalCaracteres = 0, totalNomes = 0; do { Integer tamanho = (Integer) pilha.pop(); totalCaracteres = totalCaracteres + tamanho; totalNomes++; } while (!pilha.empty()); System.out.println("Total de Caracteres: " + totalCaracteres + " letra(s)"); System.out.println("Total de Nomes: " + totalNomes); System.out.println("Pilha: " + pilha.toString()); } } } 256 6.4.7 ProgLista_7 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_7.java package proglista_7; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; import java.util.Stack; public class ProgLista_7 { public static void main(String[] args) { Stack pilha = new Stack(); Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); System.out.print("Nome: "); String nome = input.nextLine(); int n = nome.length(); for (int i = 0; i < n; i++) { if (strChr("AaEeIiOoUu", nome.charAt(i))) { pilha.push(nome.charAt(i)); } else { if (nome.charAt(i) != 32) { fila.offer(nome.charAt(i)); } } } System.out.println("Fila: " + fila.toString()); System.out.println("Pilha: " + pilha.toString()); } static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) == ch) { return (true); } } return (false); } } 6.4.8 ProgLista_8 // ------------------------------------------------------------------------------------------- Programa Principal: ProgLista_8.java package proglista_8; import java.util.Scanner; import java.util.Stack; public class Lista_8 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); System.out.print("Nome: "); String nome = input.nextLine(); int n = nome.length(); for (int i = 0;i < n;i++) { pilha.push(nome.charAt(i)); } System.out.print("Nome Invertido: "); 257 do { Character letra = (Character) pilha.pop(); System.out.printf("%c", letra); } while (!pilha.empty()); System.out.println(); } } 6.4.9 ProgLista_9 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_9.java package proglista_9; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; import java.util.Stack; public class ProgLista_9 { public static void main(String[] args) { Stack pilha = new Stack(); Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); System.out.print("Nome: "); String nome = input.nextLine(); int n = nome.length(); for (int i = 0;i < n;i++) { if (strChr("AaEeIiOoUu", nome.charAt(i))) { pilha.push(nome.charAt(i)); } else { if (nome.charAt(i) != 32) { fila.offer(nome.charAt(i)); } } } System.out.println("Fila: " + fila.toString()); int consoantes = 0; do { fila.poll(); consoantes++; } while (!fila.isEmpty()); System.out.println("Total de Consoantes: " + consoantes); System.out.println("Fila: " + fila.toString()); System.out.println("Pilha: " + pilha.toString()); int vogais = 0; do { pilha.pop(); vogais++; } while (!pilha.empty()); System.out.println("Total de Vogais: " + vogais); System.out.println("Pilha: " + pilha.toString()); System.out.println("Total de Letras: " + (consoantes + vogais)); } static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0;i < n;i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } } 258 6.4.10 ProgLista_10 // -------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_10.java package proglista_10; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; import java.util.Stack; public class ProgLista_10 { public static void main(String[] args) { Stack pilha = new Stack(); Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); System.out.print("Nome: "); String nome = input.nextLine(); String [] partes = nome.split(" "); int n = partes.length; for (int i = 0;i < n;i++) { fila.offer(partes[i]); pilha.push(partes[i].charAt(0)); } System.out.println("Fila: " + fila.toString()); System.out.println("Pilha: " + pilha.toString()); } } 6.4.11 ProgLista_11 // ------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_11.java package proglista_11; import java.util.Arrays; import java.util.Scanner; import java.util.Stack; public class ProgLista_11 { public static void main(String[] args) { Stack p1 = new Stack(); Stack p2 = new Stack(); Scanner input = new Scanner(System.in); int valor; do { System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { p1.push(valor); p2.push(valor * 2); } } while (valor != 0); System.out.println("p1: " + p1.toString()); System.out.println("p2: " + p2.toString()); int n = p1.size(); Integer [] vetor = new Integer[n * 2]; int i; for (i = 0;i < n;i++) { vetor[i] = (Integer) p1.pop(); } int j; for (j = i;j < n * 2;j++) { 259 vetor[j] = (Integer) p2.pop(); } Arrays.sort(vetor); System.out.print("Pilhas: "); for (i = 0;i < n*2;i++) { System.out.print(vetor[i] + " "); } System.out.println(); } } 6.4.12 ProgLista_12 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_12.java package proglista_12; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgLista_12 { public static void main(String[] args) { Queue f1 = new LinkedList(); Queue f2 = new LinkedList(); Scanner input = new Scanner(System.in); int maior = 0, menor = 999; Integer valor; do { System.out.print("Valor: "); String s = input.nextLine(); valor = Integer.parseInt(s); if (valor != 0) { f1.offer(valor); if (valor > maior) { maior = valor; } if (valor < menor) { menor = valor; } } } while (valor != 0); do { valor = (Integer) f1.poll() * 3; f2.offer(valor); if (valor > maior) { maior = valor; } if (valor < menor) { menor = valor; } } while (!f1.isEmpty()); System.out.println("f1: " + f1.toString()); System.out.println("f2: " + f2.toString()); System.out.println("Maior: " + maior); System.out.println("Menor: " + menor); } } 6.4.13 ProgLista_13 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_13.java package proglista_13; 260 import java.util.Scanner; import java.util.Stack; public class ProgLista_13 { public static void main(String[] args) { Stack pilha = new Stack(); Scanner input = new Scanner(System.in); System.out.print("Palavra: "); String palavra = input.nextLine(); int n = palavra.length(); for (int i = 0;i < n;i++) { pilha.push(palavra.charAt(i)); } int totalLetras = 0; System.out.print("Palavra Invertida: "); do { Character letra = (Character) pilha.pop(); System.out.print(letra); totalLetras++; } while (!pilha.empty()); System.out.println(); System.out.println("Total de Letras: " + totalLetras); } } 6.4.14 ProgLista_14 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_14.java package proglista_14; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class ProgLista_14 { public static void main(String[] args) { Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); do { System.out.print("Valor Inicial: "); String s = input.nextLine(); int valorInicial = Integer.parseInt(s); if (valorInicial == 0) { System.exit(0); } System.out.print("Valor Final: "); s = input.nextLine(); int valorFinal = Integer.parseInt(s); System.out.print("Intervalo: "); s = input.nextLine(); int intervalo = Integer.parseInt(s); if (valorInicial < valorFinal) { for (int i = valorInicial; i <= valorFinal; i = i + intervalo) { fila.offer(i); } } else { for (int i = valorInicial; i >= valorFinal; i = i - intervalo) { fila.offer(i); } } System.out.println("Fila: " + fila.toString()); } while (true); } 261 } 6.4.15 ProgLista_15 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_15.java package proglista_15; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; import java.util.Stack; public class ProgLista_15 { public static void main(String[] args) { Stack pilha = new Stack(); Queue fila = new LinkedList(); Scanner input = new Scanner(System.in); Integer nodo = 0; do { System.out.print("Nodo: "); String s = input.nextLine(); if (!s.equals("")) { nodo = Integer.parseInt(s); if (nodo != 0) { pilha.push(nodo); fila.offer(nodo * 2); } } } while (nodo != 0); int n = pilha.size(); if (n > 0) { System.out.println("Pilha: " + pilha); System.out.println("Topo da Pilha: " + pilha.lastElement()); System.out.println("Base da Pilha: " + pilha.firstElement()); System.out.println("Número de Elementos da Pilha: " + pilha.size()); System.out.println("\nFila: " + fila); System.out.println("Primeiro Elemento da Fila: " + fila.peek()); System.out.println("Número de Elementos da Fila: " + fila.size()); } else { System.out.println("Pilha: " + pilha); System.out.println("Fila: " + fila); } } } Anexo 7.2 Solução da Lista: Mapas 7.2.1 ProgMap_1 // ---------------------------------------------------------------------------------------------- Programa Principal: ProgMap_1.java package progmap_1; import java.util.Arrays; import java.util.LinkedHashMap; public class ProgMap_1 { public static void main(String[] args) { LinkedHashMap pessoa = new LinkedHashMap(); pessoa.put(2, "Carla"); pessoa.put(4, "Eva"); pessoa.put(0, "Ana"); 262 pessoa.put(1, "Beatriz"); pessoa.put(3, "Debora"); for (Object key : pessoa.keySet()) { System.out.printf("%-7s -> (%d)\n", pessoa.get(key), key); } int n = pessoa.size(); String[] partes = new String[n]; String s = ""; for (int i = 0; i < partes.length; i++) { partes[i] = pessoa.get(i).toString(); } Arrays.sort(partes); System.out.print("Mapa: "); for (String parte : partes) { System.out.print(parte + " "); } System.out.println(); } } 7.2.2 ProgMap_2 // ------------------------------------------------------------------------------------------------- Programa Principal: ProgMap_2.java package progmap_2; import java.util.TreeMap; public class ProgMap_2 { public static void main(String[] args) { TreeMap<String, Integer> alunos = new TreeMap<>(); alunos.put("Carla", 67); alunos.put("Debora", 68); alunos.put("Beatriz", 66); alunos.put("Ana", 65); for (String key : alunos.keySet()) { System.out.printf("%-7s -> %c\n",key, alunos.get(key)); } System.out.println("keySet: " + alunos.keySet()); alunos.clear(); } } 7.2.3 ProgMap_3 // ------------------------------------------------------------------------------------------------ Programa Principal: ProgMap_3.java package progmap_3; import java.util.HashMap; import java.util.Map; public class ProgMap_3 { public static void main(String[] args) { Map<Integer, String> mapa = new HashMap<>(); mapa.put(5, "Eva"); mapa.put(2, "Beatriz"); mapa.put(3, "Carla"); mapa.put(1, "Ana"); mapa.put(4, "Debora"); int n = mapa.size(); for (int i = 1; i <= n; i++) { System.out.printf("Chave: %d | Pessoa: %-7s | Bytes: %d\n", i, mapa.get(i), mapa.get(i).length()); } 263 } } 7.2.4 ProgMap_4 // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap_4.java package progmap_4; import java.util.Hashtable; public class ProgMap_4 { public static void main(String[] args) { Hashtable pessoa = new Hashtable(); pessoa.put(20, "Beatriz"); // chave, valor pessoa.put(30, "Carla"); // chave, valor pessoa.put(10, "Ana"); // chave, valor System.out.println("Tamanho da Hashtable: " + pessoa.size()); System.out.println("Chaves: " + pessoa.keySet()); System.out.println("Valor: " + pessoa.values()); } } 7.2.5 ProgMap_5 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgMap_5.java package progmap_5; import java.util.HashMap; import java.util.Map; public class ProgMap_5 { public static void main(String[] args) { Map<String, String> mapa = new HashMap<>(); mapa.put("E", "Eva"); mapa.put("B", "Beatriz"); mapa.put("C", "Carla"); mapa.put("A", "Ana"); mapa.put("D", "Debora"); System.out.println("Número de Elementos do Mapa: " + mapa.size()); System.out.println("Mapa: " + mapa); System.out.println("Chaves: " + mapa.keySet()); System.out.println("Valores: " + mapa.values()); } } Anexo 8.6 Solução da Lista: Arquivos (File) 8.6.1 ProgFile_1 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_1.java package progfile_1; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.Scanner; public class ProgFile_1 { 264 public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); try { long bytes; int linhas; int brancas; try (FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto)) { bytes = 0; linhas = 0; brancas = 0; while ((linha = leitor.readLine()) != null) { System.out.println(linha); bytes = bytes + linha.length(); linhas++; if ("".equals(linha)) { brancas++; } } arqTexto.close(); } System.out.println("(" + bytes + ") Bytes"); System.out.println("(" + linhas + ") Linhas"); System.out.println("(" + brancas + ") Brancas"); } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } } 8.6.2 ProgFile_2 // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_2.java package progfile_2; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.Scanner; public class ProgFile_2 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); try { int nl; do { try (FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto)) { boolean encontrouLinha = false; System.out.print("Linha: "); String s = input.nextLine(); nl = Integer.parseInt(s); int linhas = 0; while ((linha = leitor.readLine()) != null) { linhas++; if (nl == linhas) { System.out.println(nl + ": " + linha); encontrouLinha = true; 265 } } if (!encontrouLinha && nl != 0) { System.out.println("ERRO: Linha não existe"); } if (nl == 0) { arqTexto.close(); } } } while (nl != 0); } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } } 8.6.3 ProgFile_3 // --------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_3.java package progfile_3; import java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class ProgFile_3 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Arquivo Origem: "); String arquivoOrigem = input.nextLine(); System.out.print("Arquivo Destino: "); String arquivoDestino = input.nextLine(); long bytes = 0; try { FileWriter arqDestino; try (FileReader arqOrigem = new FileReader(arquivoOrigem); BufferedReader leitor = new BufferedReader(arqOrigem)) { arqDestino = new FileWriter(arquivoDestino); while ((linha = leitor.readLine()) != null) { bytes = bytes + linha.length(); arqDestino.write(linha + "\n"); } System.out.println("(" + bytes + ") Bytes copiados"); arqOrigem.close(); } arqDestino.close(); } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo Origem"); } } } 8.6.4 ProgFile_4 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_4.java package progfile_4; import java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; 266 import java.util.Scanner; public class ProgFile_4 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Arquivo Origem: "); String arquivoOrigem = input.nextLine(); System.out.print("Arquivo Destino: "); String arquivoDestino = input.nextLine(); System.out.print("[+] Maiúsculo ou [-] Minúsculo: "); String s = input.nextLine(); char tipo = s.charAt(0); long bytes = 0; try { FileWriter arqDestino; try (FileReader arqOrigem = new FileReader(arquivoOrigem); BufferedReader leitor = new BufferedReader(arqOrigem)) { arqDestino = new FileWriter(arquivoDestino); while ((linha = leitor.readLine()) != null) { bytes = bytes + linha.length(); if (tipo == '+') { arqDestino.write(linha.toUpperCase() + "\n"); } else { arqDestino.write(linha.toLowerCase() + "\n"); } } System.out.println("(" + bytes + ") Bytes copiados"); arqOrigem.close(); } arqDestino.close(); } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo Origem"); } } } 8.6.5 ProgFile_5 // ------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_5.java package progfile_5; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.Scanner; public class ProgFile_5 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; boolean existe = false; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); System.out.print("Palavra: "); String palavra = input.nextLine(); try { try (FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto)) { int line = 1; while ((linha = leitor.readLine()) != null) { if (linha.contains(palavra)) { System.out.println(line + ": " + linha); 267 existe = true; } line++; } arqTexto.close(); if (!existe) { System.out.println("Erro: Palavra não existe"); } } } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } } 8.6.6 ProgFile_6 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_6.java package progfile_6; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.Scanner; public class ProgFile_6 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); try { int nli, nlf; try (FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto)) { boolean encontrouLinha = false; System.out.print("Número inicial: "); String s = input.nextLine(); nli = Integer.parseInt(s); System.out.print("Número final: "); s = input.nextLine(); nlf = Integer.parseInt(s); if (nli > nlf) { int temp = nli; nli = nlf; nlf = temp; } int line = 1; while ((linha = leitor.readLine()) != null) { if (line >= nli && line <= nlf) { System.out.println(line + ": " + linha); encontrouLinha = true; } line++; } arqTexto.close(); if (!encontrouLinha) { System.out.println("ERRO: Linha não existe"); } } } catch (IOException e) { 268 System.out.println("Erro: Problema com o Arquivo"); } } } 8.6.7 ProgFile_7 // ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_7.java package progfile_7; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class ProgFile_7 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String palavra; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); try { try (FileWriter arqTexto = new FileWriter(nomeArquivo)) { do { System.out.print("Palavra: "); palavra = input.nextLine(); if (!"".equals(palavra)) { arqTexto.write(palavra + "\n"); } } while (!"".equals(palavra)); arqTexto.close(); } } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } } 8.6.8 ProgFile_8 // ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_8.java package progfile_8; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.Scanner; public class ProgFile_8 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Nome do Arquivo Texto: "); String nomeArquivo = input.nextLine(); try { try (FileReader arqTexto = new FileReader(nomeArquivo); BufferedReader leitor = new BufferedReader(arqTexto)) { while ((linha = leitor.readLine()) != null) { System.out.println(linha); } arqTexto.close(); 269 } } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } } 8.6.9 ProgFile_9 // --------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_9.java package progfile_9; import java.io.FileWriter; import java.io.IOException; import java.io.RandomAccessFile; import java.util.Scanner; public class ProgFile_9 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String linha; System.out.print("Nome do Arquivo Texto Origem: "); String arqOrigem = input.nextLine(); System.out.print("Nome do Arquivo Texto Destino: "); String arqDestino = input.nextLine(); try { FileWriter destino; try (RandomAccessFile origem = new RandomAccessFile(arqOrigem, "r")) { destino = new FileWriter(arqDestino); int numeroLinhas = 0; while (origem.readLine() != null) { numeroLinhas++; } origem.seek(0); // volta ao início do arquivo String[] nome = new String[numeroLinhas]; int n = 0; while ((linha = origem.readLine()) != null) { nome[n] = linha; n++; } sort(numeroLinhas, nome); origem.seek(0); for (int i = 0; i < numeroLinhas; i++) { destino.write(nome[i] + "\n"); } origem.close(); } destino.close(); System.out.println("Ok, arquivo ordenado e copiado"); } catch (IOException e) { System.out.println("Erro: Problema com o Arquivo"); } } static void sort(int n, String[] nome) { for (int i = 0; i < n - 1; i++) { for (int j = i + 1; j < n; j++) { if (nome[i].compareTo(nome[j]) > 0) { String temp = nome[i]; nome[i] = nome[j]; nome[j] = temp; } } } 270 } } 8.6.10 ProgFile_10 // ----------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_10.java package progfile_10; import java.io.File; import java.io.FileWriter; import java.util.Scanner; public class ProgFile_10 { public static void main(String[] args) throws Exception { Scanner input = new Scanner(System.in); String s; System.out.print("Nome do arquivo texto: "); String nomeArquivo = input.nextLine(); File arquivo = new File(nomeArquivo); if (!arquivo.exists()) { FileWriter file = new FileWriter(arquivo); do { System.out.print("Nome: "); String nome = input.nextLine(); file.write(nome); file.write(":"); System.out.print("Idade: "); String idade = input.nextLine(); file.write(idade); file.write(":"); System.out.print("Sexo [M/F]: "); s = input.nextLine(); char sexo = s.charAt(0); file.write(sexo); file.write(":"); System.out.print("Continua [S/N]? "); do { s = input.nextLine(); } while (!"SsNn".contains(s)); } while ("S".equalsIgnoreCase(s)); file.close(); } else { System.out.println("ERRO: Arquivo já existe"); } } } 8.6.11 ProgFile_11 // ---------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_11.java package progfile_11; import java.io.File; import java.io.FileReader; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.Scanner; public class ProgFile_11 { public static void main(String[] args) throws Exception { Scanner input = new Scanner(System.in); 271 System.out.print("Nome do arquivo texto: "); String nomeArquivo = input.nextLine(); File arquivo = new File(nomeArquivo); FileInputStream in = new FileInputStream(arquivo); InputStreamReader conversor = new InputStreamReader(in); BufferedReader buffer = new BufferedReader(conversor); if (arquivo.exists()) { FileReader file = new FileReader(arquivo); String linha = buffer.readLine(); // lê todos os dados, ou seja, carrega toda a linha de dados System.out.println("Buffer: " + linha); // e joga numa String String[] partes = linha.split(":"); int n = partes.length; System.out.println("Partes: " + n); for (int i = 0; i < n; i = i + 3) { System.out.println("Nome: " + partes[i]); System.out.println("Idade: " + Integer.parseInt(partes[i + 1])); if (partes[i+1].equals("M") || partes[i+1].equals("m")) { System.out.println("Sexo: MASCULINO"); } else { System.out.println("Sexo: FEMININO"); } } file.close(); buffer.close(); } else { System.out.println("ERRO: Arquivo não existe"); } } } 8.6.12 ProgFile_12 // ------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_12.java package progfile_12; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Scanner; public class ProgFile_12 { public static void main(String[] args) throws FileNotFoundException, IOException { Scanner input = new Scanner(System.in); System.out.print("Nome do arquivo texto: "); String nomeArquivo = input.nextLine(); File arquivo = new File(nomeArquivo); FileInputStream in = new FileInputStream(arquivo); InputStreamReader conversor = new InputStreamReader(in); BufferedReader buffer = new BufferedReader(conversor); if (arquivo.exists()) { int homens, mulheres; try (FileReader file = new FileReader(arquivo)) { String linha = buffer.readLine(); // lê todos os dados da linha do arquivo texto e joga numa String System.out.println("Buffer: " + linha); String[] partes = linha.split(":"); int n = partes.length; homens = 0; mulheres = 0; for (int i = 0; i < n; i = i + 3) { if ("M".equals(partes[i+2]) || "m".equals(partes[i+2])) { homens++; } else { 272 mulheres++; } } } buffer.close(); in.close(); conversor.close(); System.out.println("(" + homens + ") Homens"); System.out.println("(" + mulheres + ") Mulheres"); } else { System.out.println("ERRO: Arquivo não existe"); } } } 273
