Algoritmos e Programação em Java

Algoritmos e Programao
por
Prof. Dr. Paulo Roberto Gomes Luzzardi
facebook: Paulo Roberto Gomes Luzzardi

WhatsApp: 91648037
e-mail: pluzzardi@gmail.com e pluzzardi@yahoo.com.br
e-mail (Senac): prgomesluzzardi@senacrs.edu.br
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)
Verso 2.07
25-09-2015
Bibliografia recomendada
DEITEL, H. M. and DEITEL, P. J. Java: como programar, 8. ed.: So Paulo: Pearson, 2010 (ISBN
85-363-0123-6).
Pelotas, sexta-feira, 25 de setembro de 2015 (10:15:20 am)
Sumrio
1. Projeto de Classes ........................................................................................................................................ 7
1.1 Escrevendo uma classe em Java (Conceitos bsicos) .................................................................... 7
1.2 Sobrecarga de Mtodos ..................................................................................................................... 24
1.3 Referncia this ...................................................................................................................................... 25
1.4 Lista de exerccios: Classes ................................................................................................................ 28
2. Interface e Polimorfismo ........................................................................................................................... 43
2.1 Interface ................................................................................................................................................. 43
2.2 Polimorfismo ......................................................................................................................................... 46
2.3 Lista de Exerccios: Interface e Polimorfismo ................................................................................. 49
3. Herana em Java ........................................................................................................................................ 51
3.1 Herana simples ................................................................................................................................... 51
3.2 Controle de acesso na definio de uma classe derivada .......................................................... 52
3.3 Tipos de acessos (especificadores de acesso)............................................................................... 54
3.4 Lista de exerccios: Herana .............................................................................................................. 57
4. Mtodos de entrada e sada de dados .................................................................................................. 62
4.1 Entrada de dados via teclado ............................................................................................................ 62
4.2 Sada de dados via tela ....................................................................................................................... 65
4.3 Sada formatada (System.out.printf) ................................................................................................. 67
4.4 Lista de Exerccios: Mtodos de Entrada e Sada .......................................................................... 68
5. Interfaces e Containers (Classes existentes em Java) ......................................................................... 69
5.1 Colees (Collection FrameWork) .................................................................................................... 69
5.2 Interfaces ............................................................................................................................................... 69
5.3 Vector (Vetor) (Classe Obsoleta) ....................................................................................................... 70
5.4 LinkedList (Lista Encadeada Simples) .............................................................................................. 75
5.5 Arrays (array) ......................................................................................................................................... 80
5.6 ArrayList (lista de array) ....................................................................................................................... 85
5.6.1 Lista de exerccios: Vector, ArrayList e LinkedList ...................................................................... 87
5.7 ArrayList bidimensional ...................................................................................................................... 95
5.8 Strings (Cadeia de Caracteres) ........................................................................................................ 101
5.8.1 Mtodos para manipular Strings ................................................................................................. 102
5.8.2 Lista de exerccios: Strings ............................................................................................................ 106
5.9 Classe Object ...................................................................................................................................... 108
5.10 Classe Iterator ................................................................................................................................... 111
5.11 Classe LinkedHashSet ..................................................................................................................... 111
5.12 Classe Genrica em Java ............................................................................................................... 113
5.13 Fila Prioritria (PriorityQueue) ....................................................................................................... 115
6. Listas Lineares: Pilhas, Filas e Deques.................................................................................................. 119
6.1 Implementao de uma Pilha (Stack) ............................................................................................. 120
6.2 Implementao de uma Fila (Queue) ............................................................................................ 125
6.3 Implementao de um Deque (ArrayDeque) ............................................................................... 129
6.4 Lista de Exerccios: Listas Lineares (Pilhas, Filas e Deques)....................................................... 137
7. Mapas (Maps) ............................................................................................................................................ 142
7.1 Conceitos bsicos sobre Mapas ..................................................................................................... 142
7.2 Lista de Exerccios: Mapas ............................................................................................................... 147
8. Processamento de fluxos de dados, caracteres e objetos (Arquivos) ........................................... 149
2
8.1 Mtodos para manipular arquivos em Java ................................................................................. 151

8.2 Abertura de um arquivo texto ......................................................................................................... 154
8.3 Listar um diretrio .............................................................................................................................. 155
8.4 Manipulao de um arquivo de palavras ...................................................................................... 157
8.5 Arquivo Texto ..................................................................................................................................... 160
8.6 Lista de exerccios: Arquivos (Files) ................................................................................................ 168
8.7 Acesso randmico em arquivos texto ........................................................................................... 171
8.8 Arquivo binrio de objetos em Java .............................................................................................. 172
8.9 Leitura e gravao de objetos (registro) em Arquivos ............................................................... 174
8.9.1 Gravao de objetos em um arquivo binrio de objetos ....................................................... 175
8.9.2 Leitura objetos em um arquivo binrio de objetos ................................................................. 179
9. Noes de desenvolvimento de aplicaes em camadas (MVC)................................................... 182
9.1 Conceitos ............................................................................................................................................. 182
9.2 Primeiro exemplo da utilizao do MVC (ProgMVCPessoa) ..................................................... 183
9.3 Segundo exemplo da utilizao do MVC (ProgMVCPessoa2).................................................. 186
10. Conceitos gerais .................................................................................................................................... 192
10.1 Como calculado o hashcode no Java ...................................................................................... 192
11. Lista Encadeada Simples em Java ...................................................................................................... 193
11.1 Lista Encadeada de Inteiros........................................................................................................... 193
11.2 Lista Encadeada Genrica (String, Integer ou Double) ............................................................ 199
12. Lista Duplamente Encadeada em Java.............................................................................................. 203
13. Classe entrada de inteiros e reais em Java sem erro na digitao .............................................. 213
14. Alguns programas exemplos em Java .............................................................................................. 219
14.1 Torre de Hanoi (Pilha - Stack) ........................................................................................................ 219
14.2 Analisador de Expresses usando Stack..................................................................................... 225
14.3 Calculadora Polonesa Reversa ...................................................................................................... 228
14.4 Jogo Quebra-Cabeas ................................................................................................................... 231
Anexos: Soluo dos problemas propostos no Livro............................................................................ 234
Anexo 1.4 Soluo da Lista: Classes ..................................................................................................... 234
1.4.1 ProgCirculo .................................................................................................................................. 234
1.4.2 ProgPeso ...................................................................................................................................... 234
1.4.3 ProgValidaCPF ............................................................................................................................ 235
1.4.4 ProgDiaSemana .......................................................................................................................... 237
1.4.5 ProgTestData ............................................................................................................................... 238
1.4.6 ProgVetorSort .............................................................................................................................. 239
1.4.7 ProgPessoa .................................................................................................................................. 242
1.4.8 ProgPessoa2 ................................................................................................................................ 243
1.4.9 ProgPessoas ................................................................................................................................ 245
1.4.10 ProgAgenda .............................................................................................................................. 246
Anexo 2.3 Soluo da Lista: Interface e Polimorfismo ...................................................................... 248
2.3.1 ProgInterface_1 ........................................................................................................................... 248
2.3.2 ProgInterface_2 ........................................................................................................................... 249
2.3.2 ProgInterface_3 ........................................................................................................................... 251
Anexo 3.4 Soluo da Lista: Herana ................................................................................................... 252
3.4.1 Herana (Primeiro) ...................................................................................................................... 252
3.4.2 Herana (Segundo) .................................................................................................................... 253
3.4.3 Herana (Terceiro) ...................................................................................................................... 254
3
Anexo 4.4 Soluo da Lista: Entrada e Sada Bufferizada ................................................................ 256

4.4.1 ProgBuffer_1 ................................................................................................................................ 256
4.4.2 ProgBuffer_2 ................................................................................................................................ 257
Anexo 5.6.1 Soluo da Lista: Vector, ArrayList e LinkedList ........................................................... 258
5.6.1.1 ProgVector_1 ........................................................................................................................... 258
5.6.1.2 ProgVector_2 ........................................................................................................................... 258
5.6.1.3 ProgVector_3 ........................................................................................................................... 259
5.6.1.4 ProgVector_4 ........................................................................................................................... 260
5.6.1.5 ProgVector_5 ........................................................................................................................... 261
5.6.1.6 ProgVector_6 ........................................................................................................................... 262
5.6.1.7 ProgVector_7 ........................................................................................................................... 263
5.6.1.8 ProgVector_8 ........................................................................................................................... 263
5.6.1.9 ProgVector_9 ........................................................................................................................... 264
5.6.1.10 ProgVector_10 ....................................................................................................................... 265
5.6.1.11 ProgVector_11 ....................................................................................................................... 266
5.6.1.12 ProgVector_12 ....................................................................................................................... 268
5.6.1.13 ProgVector_13 ....................................................................................................................... 270
5.6.1.14 ProgVector_14 ....................................................................................................................... 272
5.6.1.15 ProgVector_15 ....................................................................................................................... 274
5.6.1.16 ProgVector_16 ....................................................................................................................... 275
Anexo 5.8.2 Soluo da Lista: Strings ................................................................................................... 277
5.8.2.1 ProgString_1 ............................................................................................................................ 277
5.8.2.2 ProgString_2 ............................................................................................................................ 277
5.8.2.3 ProgString_3 ............................................................................................................................ 278
5.8.2.4 ProgString_4 ............................................................................................................................ 279
5.8.2.5 ProgString_5 ............................................................................................................................ 279
5.8.2.6 ProgString_6 ............................................................................................................................ 279
5.8.2.7 ProgString_7 ............................................................................................................................ 280
5.8.2.8 ProgString_8 ............................................................................................................................ 281
Anexo 6.4 Soluo da Lista: Listas Lineares ........................................................................................ 282
6.4.1 ProgLista_1 .................................................................................................................................. 282
6.4.2 ProgLista_2 .................................................................................................................................. 282
6.4.3 ProgLista_3 .................................................................................................................................. 283
6.4.4 ProgLista_4 .................................................................................................................................. 284
6.4.5 ProgLista_5 .................................................................................................................................. 284
6.4.6 ProgLista_6 .................................................................................................................................. 285
6.4.7 ProgLista_7 .................................................................................................................................. 286
6.4.8 ProgLista_8 .................................................................................................................................. 287
6.4.9 ProgLista_9 .................................................................................................................................. 287
6.4.10 ProgLista_10 .............................................................................................................................. 288
6.4.11 ProgLista_11 .............................................................................................................................. 289
6.4.12 ProgLista_12 .............................................................................................................................. 289
6.4.13 ProgLista_13 .............................................................................................................................. 290
6.4.14 ProgLista_14 .............................................................................................................................. 291
6.4.15 ProgLista_15 .............................................................................................................................. 292
Anexo 7.2 Soluo da Lista: Mapas ...................................................................................................... 292
7.2.1 ProgMap_1 .................................................................................................................................. 292
4
7.2.2 ProgMap_2 .................................................................................................................................. 293

7.2.3 ProgMap_3 .................................................................................................................................. 293
7.2.4 ProgMap_4 .................................................................................................................................. 294
7.2.5 ProgMap_5 .................................................................................................................................. 294
Anexo 8.6 Soluo da Lista: Arquivos (File) ........................................................................................ 295
8.6.1 ProgFile_1 .................................................................................................................................... 295
8.6.2 ProgFile_2 .................................................................................................................................... 296
8.6.3 ProgFile_3 .................................................................................................................................... 296
8.6.4 ProgFile_4 .................................................................................................................................... 297
8.6.5 ProgFile_5 .................................................................................................................................... 298
8.6.6 ProgFile_6 .................................................................................................................................... 299
8.6.7 ProgFile_7 .................................................................................................................................... 300
8.6.8 ProgFile_8 .................................................................................................................................... 300
8.6.9 ProgFile_9 .................................................................................................................................... 301
8.6.10 ProgFile_10 ............................................................................................................................... 302
8.6.11 ProgFile_11 ............................................................................................................................... 303
8.6.12 ProgFile_12 ............................................................................................................................... 304
Lista de Figuras
Figura 1: Estrutura de dados da classe Vetor .................................................................................... 8
Figura 2: Exemplo de Herana em java .............................................................................................. 40
Figura 3: Objetos grficos: Linha e Retngulo ................................................................................. 50
Figura 4: LinkedList - Lista Encadeada Simples ................................................................................. 65
Figura 5: Representao grfica de uma String ................................................................................ 90
Figura 6: Representao de uma Fila e uma Pilha .......................................................................... 108
Figura 7: Representao visual de um Deque ................................................................................. 118
Figura 8: Representao grfica 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 binrio ........................................................ 139
Figura 12: Exemplo de MVC .............................................................................................................. 172
Figura 13: Exemplo de MVC .............................................................................................................. 176
Figura 14: Lista Encadeada Simples ................................................................................................. 182
Figura 15: Alocao de elementos na Memria RAM .................................................................... 183
Figura 16: Lista Duplamente Encadeada ......................................................................................... 193
Figura 17: Jogo Torre de Hanoi ....................................................................................................... 208
Figura 18: Jogo Quebra-Cabeas ..................................................................................................... 220
Lista de Tabelas
Tabela 1: Tipos de cones .................................................................................................................... 53
Tabela 2: Comandos de formatao .................................................................................................. 53
Tabela 3: Especificadores de largura do campo .............................................................................. 54
Tabela 4: Lista de Container ................................................................................................................ 55
Tabela 5: Tipos de dados do Java ..................................................................................................... 172
5
Legenda de Cores
Vermelho <enter>: Entrada de dados do programa
Azul: Sada do programa (Resultado do teste do Programa)
Verde: Texto em destaque
Marinho: Cdigo em Java
Preto: Texto normal
Preto: Mtodo em destaque
Itlico: Palavra em Ingls
Negrito: Texto em destaque
Sublinado: Observaes
1. Projeto de Classes
A seguir so descritas algumas caractersticas da orientao a objetos em Java.
1.1 Escrevendo uma classe em Java (Conceitos bsicos)
O paradigma orientado objetos possui cinco componentes bsicos: objetos (possuem
atributos e mtodos), mensagens (chamadas aos mtodos), classes (tipo de dado), instncias
(criao de objetos de uma classe especfica new alocao de memria) e mtodos (funes
definidas pelo programador que manipulam os atributos).
Objetos, mensagens, classes, instncias e mtodos
Objetos so entidades lgicas que contm atributos (dados armazenados em variveis)
e mtodos (funes) que manipulam estes dados. Um objeto pode ser definido atravs de um
tipo de dado chamado classe (class).
Resumindo:
a) Atributos: So as variveis definidas/declaradas para cada objeto.
b) Mtodos: So as funes definidas pelo programador que serviro para manipular os
atributos.
c)
Mensagens: So as chamadas dos mtodos.
d) Classe: um tipo de dado definido por class. Uma classe no um objeto, sim uma
descrio do objeto.
e) Instncia: Os objetos so instncias de uma classe, ou seja, criado um objeto
pertencente a uma classe especfica. O objeto pode responder chamadas dos mtodos
e armazenar informaes nos atributos.
Resumidamente, objetos so instncias de classes que respondem as mensagens
atravs dos mtodos escritos pelo programador.
Uma linguagem de programao orientada objetos pode suportar ou implementar seis
propriedades: abstrao, encapsulamento, polimorfismo, herana, associao (quando uma
classe possui atributos do tipo de outra classe - agregao e composio) e classes abstratas e
concretas.
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.
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;
// nmero de elementos no vetor

// vetor que armazena os elementos
// mximo nmero de elementos no vetor
// -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java

package progvetor;
public class Vetor {
// ------------------------------------- atributos da classe
private int n;
// ----------------------------------------- construtor
Vetor(int numeroElementos) {
max = numeroElementos;
vetor = new int[max];
// alocao de max nmero 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 espao em branco e a ltima vrgula

// \b retrocesso ou BackSpace
// ---------------------------------------------------- numeroElementosVetor
public int numeroElementosVetor() {
return(n);
}
}
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor.java
package progvetor;
public class ProgVetor {
public static void main(String[] args) {
Vetor vetor = new Vetor(5);
// 5 o nmero de elementos no vetor esttico 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 mtodos para a classe Vetor:

int valor = vetor.del();
if (valor != -999) {
System.out.println("Valor Excludo: " + 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("No Existe elemento 20");
}
Vetor: [10, 20, 30, 40, 50]
Erro: Excedeu Limite do Vetor
Vetor: [10, 20, 30, 40, 50]
Valor Excludo: 50
Vetor: [10, 20, 30, 40]
Primeiro: 10
ltimo: 40
Existe elemento: 20
Exemplo de classe (Lista) aonde os elementos so inseridos a partir da posio zero

do vetor e h uma varivel n que controla o nmero de elementos da lista.
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgLista.java
package testalista;
import java.util.Scanner;
public class TestaLista {
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());
10
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: ");
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':
valor = Integer.parseInt(s);
int posicao = lista.procuraLista(valor);
if (posicao != -5) {
System.out.println("Posio: " + posicao);
} else {
ImprimeErro(POSICAO);
}
break;
case 'P':
case 'p':
System.out.print("Posio: ");
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;
11
}
} while (true);
// -------------------------------------------------------- mtodo esttico

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, operao 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 Mximo"; // -3
final String POSICAO = "Erro: Posio Invlida"; // -4
final String VALOR = "Erro: Valor no 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);
break;
default:
System.out.println("Ateno: Erro Desconhecido");
break;
}
}
}
// Pesquisa -> Posio: 3 ----> Resultado: Valor: 30 ou ERRO: No Encontrado
// Procura -> Valor: 30 ---> Resultado: Posio: ?? ou ERRO: No Encontrado
// removeAll ---> Eliminar todos os valores
// ---------------------------------------------------------------------------------------------------------- Classe: Lista.java
package testalista;
12
import java.util.Arrays;
public class Lista {
// ----------------------- atributos da classe
private int n;
// ----------------------- construtor
Lista(int numeroMaxElementos) {
n = 0;
max = numeroMaxElementos;
vetor = new int[max + 1];
}
// ----------------------- mtodos
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 no encontrado
}
public int pesquisaLista(int posicao) {
if (posicao >= 0 && posicao < n) {
return (vetor[posicao]);
} else {
13
return (-4);
}
// Posio Invlida
public void sort() {

Arrays.sort(vetor, 0, n); // incio 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);
}
}
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, operao realizada com sucesso
Lista: (1) 100
Valor: 200 <enter>
Lista: (2) 100 200
Valor: 300 <enter>
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 so inseridos a partir da metade do vetor,

podendo ser inserido pela esquerda ou direita. Note que a lista centralizada sempre que
necessrio.
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgListaMetade.java
package testalistametade;
public class TestaListaMetade {
final int SUCESSO = 0;
final int CHEIA = -1;
final int VAZIA = -2;
final int EXCEDEU = -3;
14
final int POSICAO = -4;

final int VALOR = -5;
System.out.print("Nmero de Elementos: ");
String s = input.nextLine();
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: ");
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':
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 {
15
ImprimeErro(VAZIA);
}
break;
case 'D':
case 'd':
valor = lista.removeListaDireita();
if (valor != VAZIA) {
System.out.println("Valor Removido: " + valor);
} else {
ImprimeErro(VAZIA);
}
break;
}
break;
case 'A':
case 'a':
lista.removeallLista();
break;
case 'O':
case 'o':
int posicao = lista.procuraLista(valor);
} else {
ImprimeErro(POSICAO);
}
break;
case 'P':
case 'p':
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);
} // -------------------------------------------------------- mtodo esttico

static void ExibeLista(int n, int inic, int fim, int[] valores) {
if (n == 0) {
16
} else {
System.out.print("(" + n + ") ");
for (int i = inic; i <= fim; i++) {
System.out.print(valores[i] + " ");
}
}
static void ImprimeErro(int erro) {

final String SUCESSO = "Okay, operao 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 Mximo"; // -3
final String POSICAO = "Erro: Posio Invlida"; // -4
final String VALOR = "Erro: Valor no 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);
break;
default:
System.out.println("Ateno: Erro Desconhecido");
break;
}
}
}
// Pesquisa -> Posio: 3 ----> Resultado: Valor: 30 ou ERRO: No Encontrado
// Procura -> Valor: 30 ---> Resultado: Posio: ?? ou ERRO: No Encontrado
// removeAll ---> Eliminar todos os valores
// ---------------------------------------------------------------------------------------------------------- Classe: Lista.java
package testalistametade;
public class Lista {
// ----------------------- atributos da classe
private int n = 0;
private int inic;
private int fim;
17

// ----------------------- construtor
Lista(int numeroMaxElementos) {
n = 0;
max = numeroMaxElementos;
inic = max / 2;
fim = max / 2;
}
// ----------------------- mtodos
public int[] exibeLista() {
//-------------------------- retirar depois
if (n == 0) {
} else {
System.out.print("(" + inic + " | " + fim + ") ");
for (int i = 0; i < max; i++) {
System.out.print(vetor[i] + " ");
}
}
// ---------------------------------------------------return (vetor);
}
public int insereListaDireita(int valor) {
if (fim < max - 1) {
if (n > 0) {
fim++;
}
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;
18
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) {
return (i);
}
}
}
return (-5);
}
public int pesquisaLista(int posicao) {
if (posicao >= inic && posicao <= fim) {
return (vetor[posicao]);
} else {
return (-4);
}
}
Arrays.sort(vetor, inic, fim+1); // incio e fim
}
public void inverteLista() {
19
int i = inic;
for (int j = fim; j >= inic + (fim - inic) / 2; 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;
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);
}
Lista: (5 | 6) 0 0 0 0 0 100 200 0 0 0 0

Lista: (2) 100 200
[E]squerda ou [D]ireita: d <enter>
Valor: 300 <enter>
Lista: (5 | 7) 0 0 0 0 0 100 200 300 0 0 0
20
Lista: (3) 100 200 300

Valor: 400 <enter>
Lista: (5 | 8) 0 0 0 0 0 100 200 300 400 0 0
Lista: (4) 100 200 300 400
Valor: 500 <enter>
Lista: (5 | 9) 0 0 0 0 0 100 200 300 400 500 0
Lista: (5) 100 200 300 400 500
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
Valor: 700 <enter>
Lista: (2 | 8) 0 0 100 200 300 400 500 600 700 500 600 // Note, lista centralizada
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 programao orientada objetos pode suportar e/ou implementar

seis (6) propriedades: abstrao, encapsulamento, polimorfismo, herana, associao
(agregao e composio) e classes abstratas e concretas.
Abstrao
Objetos devem representar dados do mundo real.
Encapsulamento (encapsulao)
Os objetos possuem internamente atributos e mtodos agrupados no mesmo local,
onde os mtodos manipulam os atributos. Esta caracterstica protege os dados (atributos) de
alteraes 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 funo a uma ordem
padro. Significa que o nome de um objeto pode ser utilizado para vrios propsitos
ligeiramente diferentes, ou seja, ... uma interface, vrios mtodos ... . A caracterstica de
21
polimorfismo utilizada principalmente em sobrecarga de mtodos e operadores e classes

abstratas, onde os mtodos so declarados mas no definidos. Como tipos de polimorfismo
tem-se: (a) Universal (incluso [como em Java, por exemplo, List lista = new LinkedList();] e
paramtrico [templates como em C++]) e (b) ad-hoc (sobrecarga de mtodos e operadores).
Java no possui sobrecarga de operadores.
Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes

tipos de operaes;
Sobrecarga de Mtodo: Permite que um mtodo retorne diferentes tipos de

informaes e aceite argumentos de vrios 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 no permite ser instanciada, a classe
abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma
implementao incompleta que herdada pelas classes derivadas. Cada classe derivada
implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir
mtodos abstratos, mas os mtodos so escritos nas classes derivadas concretas.
Mtodos abstratos definem apenas a forma do mtodo no contendo nenhum tipo de
cdigo. Classes concretas implementam todos os mtodos e podem ser instanciadas.
Herana
o processo pelo qual uma classe de objetos pode adquirir as propriedades de outra
classe de objetos, em outras palavras, um objeto herda as caractersticas de outro (herana
simples) ou vrios objetos (herana mltipla). A classe base chamada de superclasse,
enquanto a classe derivada pode ser chamada de subclasse.
Associao
um vnculo que permite que objetos de uma ou mais classes se relacionem entre si.
Esta associao pode ser: unria (o vnculo entre objetos da mesma classe), binria (vnculo
ocorre entre dois objetos de classes diferentes) ou mltipla (vnculo ocorre entre mais de 2
22
objetos de classes diferentes). Cada associao pode possuir caractersticas de (a)

cardinalidade ou multiplicidade (indica quantos objetos so possveis em cada associao) e
(b) navegao (existe a possibilidade dos objetos acessarem outros objetos da mesma
associao).
Uma associao pode ser de duas formas: agregao (relacionamento com
caractersticas onde existe um grau menos intenso de coeso entre os elementos, pode haver
um certo grau de independncia) ou composio (relacionamento com caractersticas onde
existe um alto grau de coeso e total grau de dependncia entre os elementos).
Classes Abstratas e Concretas
criada para representar entidades e conceitos abstratos. Uma classe abstrata sempre
uma superclasse ou classe base que no possui instncias. Ela define apenas o modelo (como
um template em C++) para uma funcionalidade e fornece uma implementao incompleta
chamada de parte genrica sendo compartilhada por um conjunto de classes derivadas ou
subclasses. Classes derivadas completam as funcionalida-des da classe abstrata anexando um
comportamento especfico. Classes abstratas possuem mtodos abstratos. Esses mtodos so
implementados nas suas classes derivadas concretas com o objetivo de definir o
comportamento especfico. O mtodo abstrato define apenas a assinatura do mtodo no
contendo nenhum cdigo. Classes concretas implementam seus mtodos e permitem
instanciar objetos. Classes concretas no possuem mtodos abstratos quando so classes
derivadas de uma classe abstrata.
Vantagens da Orientao Objetos: (a) reutilizao de cdigo, (b) proteo aos dados; (c)
organizao ou estruturao dos dados em forma de classes e objetos; (d) sobrecarga de
mtodos e de operadores; (e) criao de pacotes de classes; (f) ter um conjunto de pacotes prdefinidos (apis: java2d, java3d, swing, awt, etc) e (g) permitir ao desenvolvedor criar seus
prprios pacotes.
API: Application Programming Interface ou Interface de Programao de Aplicativos. um
conjunto de padres de programao que permitem a construo de aplicativos.
Em Java, o programador pode criar suas prprias classes. Uma classe possui duas partes
distintas: atributos (variveis) e mtodos (funes ou procedimentos) que manipulam estes
atributos.
23
1.2 Sobrecarga de Mtodos

Java permite que mtodos estticos (e construtores) sejam sobrecarregados, desta
forma, o retorno, nmero de argumentos ou mesmo o tipo de dados dos argumentos
podem ser diferentes. Dependendo da chamada do mtodo, o Java identifica qual mtodo (ou
construtor) sobrecarregado deve ser executado. Teoricamente, uma especificao que pode
ter vrias implementaes com caractersticas diferentes.
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgSobreCarga.java
package progsobrecarga;
public class ProgSobreCarga {
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);
}
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);
}
String: Senac-RS
Double: 123.45
Float: 123.45
Inteiro: 123
Caracter: A
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java
package progpolimorfismo;
24
public class ProgPolimorfismo {

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);
}
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.3 Referncia this

Em Java, quando um mtodo de uma classe chamado, passado automaticamente
um argumento que uma referncia para o objeto que gerou a chamada. Esta referncia
chamada this, ou seja, a referncia this referencia o objeto que chamou o mtodo.
Cada objeto tem acesso a uma referncia a ele prprio, chamada this. Esta referncia faz
referncias aos atributos e mtodos de um objeto.
Programa exemplo: Utilizao da referncia this em uma classe.
// ------------------------------------------------------------------------------------------------------------------------------------- Classe: Data.java
package progdata;
import java.text.DecimalFormat;
public class Data {
// ------------------------------------- atributos da classe
private int dia, mes, ano;
25
// ------------------------------------------------ construtor
Data(int dia, int mes, int ano) {
this.dia = dia;
this.mes = mes;
this.ano = ano;
}
// ------------------------------------------- sobrecarga do mtodo 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 {
Data data = new Data(5, 8, 2014);
System.out.println(data);
}
Data: 05/08/2014
Soluo do programa proposto acima: Classe Vetor e seus mtodos.

// -------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java
package progvetor1;
// --------------------------------------------- atributos da classe
private int n;
// ---------------------------------------------- construtor
n = 0;
}
// ----------------------------------------------- add
if (n < max) {
vetor[n] = valor;
n++;
} else {
26
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
for (int i = 0; i < n; i++) {
}
}
27
// ------------------------------------------------------ numeroElementosVetor
public int numeroElementosVetor() {
return (n);
}
}
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor1.java
package progvetor1;
public class ProgVetor1 {
// 5 o nmero de elementos do vetor esttico 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 Excludo: " + valor);
} else {
}
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("No Existe elemento 20");
}
1.4 Lista de exerccios: Classes

1.4.1 Dado o seguinte programa principal, implemente a classe Circulo e seus mtodos:
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgCirculo.java
package progcirculo;
public class ProgCirculo {
Circulo circ = new Circulo();
28
circ.setRaio(3);
circ.calculaArea();
double area = circ.getArea();
System.out.printf("rea: %.2f\n", area);
}
Observao: area = pi . raio
onde pi 3.1416
Crculo
double area, raio
setRaio
calculaArea
getArea
Diagrama de classe
rea: 28,27
1.4.2 Dado o seguinte programa principal, implemente a classe PesoIdeal e seus mtodos:
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgPeso.java
package progpeso;
public class ProgPeso {
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());
}
Peso Ideal Homem: 63,41

Peso Ideal Mulher: 57,77
Clculo do Peso Ideal:
PIH = 72,7 x altura 58
PIM = 62,1 x altura 44,7
PesoIdeal
double altura, pesoIdeal
char sexo
calculaPesoIdeal
getPesoIdeal
Diagrama de classe
1.4.3
Dado o seguinte programa principal, implemente a classe CPF e seus mtodos:
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java
29
package progvalidacpf;
public class ProgValidaCPF {
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);
}
Digito verificador: 09
CPF: 123456789-09
CPF
String cpf
int digito
verificaCPF
Diagrama de classe
Como calcular os Dgitos do CPF:
Entrada: CPF: 123456789
1) Primeiramente pega-se os dgitos da base do CPF e se faz a soma da multiplicao individual dos dgitos, 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 dgito o resultado da subtrao de 11 pelo resto da diviso da soma acima por 11. Se este valor
for 10 ou 11, o dgito 0 (zero), do contrrio o prprio valor. No exemplo em questo o dgito encontrado calculado
conforme v-se a seguir:
11 - (210 % 11) = 10
3) O clculo do segundo dgito feito da mesma forma que o primeiro, porm com os 9 dgitos da base do CPF e o
primeiro dgito verificador encontrado, iniciando por 11 e indo at 2.
1
x
11
-11
2 3 4 5 6 7 8 9 0
x x x x x x x x x
10 9 8 7 6 5 4 3 2
-- -- -- -- -- -- -- -- -+ 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0 = 255
4) O valor do segundo dgito o resultado da subtrao de 11 pelo resto da diviso da soma acima por 11. Se este valor
for 10 ou 11, o dgito 0 (zero), do contrrio o prprio valor. No exemplo em questo o dgito encontrado calculado
conforme v-se a seguir:
11 - (255 % 11) = 9
Sada: CPF vlido 123.456.789-09 ou 123456789-09
30
1.4.4
Dado o seguinte programa, implemente a classe DiaSemana e seus mtodos:
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgDiaSemana.java

package progdiasemana;
public class ProgDiaSemana {
DiaSemana dia = new DiaSemana(10, 2, 1962);
dia.verificaDiaSemana();
dia.exibeDiaSemana();
}
Dia da Semana: Sbado
DiaSemana
int dia, mes, ano
String semama
verificaDiaSemana
exibeDiaSemana
Diagrama de classe
Como calcular o Dia da Semana:
Deve-se calcular o Dia do Sculo:
Para qualquer clculo com datas essencial que se disponha do Dia do Sculo para a(s) data(s) em questo. O Dia do
Sculo o nmero de dias decorridos desde o incio do sculo (1 de janeiro de 1901) at a data em questo. Se usa
como referncia 1901 porque a maioria das datas com as quais se trabalha ainda so do sculo passado. L por 2040 ou
mais poder se mudar para 2001.
A frmula (vlida para datas entre 1901 e 2099) a seguinte:
numeroDias = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (ms - 1) * 31 - [(ms * 4 + 23) DIV 10] * [(ms + 12) DIV 15]
+ [(4 - ano MOD 4) DIV 4] * [(ms + 12) DIV 15]
Dados de Teste:
Dia: 10
Ms: 2
Ano: 1962
numeroDias = 22321 (para a data acima)
Onde: DIV a diviso inteira e MOD o resto inteiro da diviso

Verificao do Dia da Semana: Para saber o diaSemana basta dividir o numeroDias por 7 e entrar com o resto inteiro
da diviso na tabela abaixo:
0
Segunda
Tera
Quarta
Quinta
Sexta
Sbado
Domingo
31
Resultado do Programa: (Sada)

10/02/1962 um(a) Sbado
Observao: DIV diviso inteira de dois nmeros e MOD o resto inteiro da diviso de dois nmeros.
1.4.5
Dado o seguinte programa principal, implemente a classe Data e seus mtodos:
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestData.java

package progtestdata;
public class ProgTestData {
Data data = new Data();
data.setData(25, 8, 2014);
data.extenso();
}
Data: 25 de agosto de 2014
Data
int dia, mes, ano
setData
extenso
Diagrama de classe
1.4.6
Implemente os mtodos forcaBruta e bubleSort na classe Vetor vista anteriormente

(Fonte: ProgVetor).
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java

package progvetorsort;
public class ProgVetorSort {
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();
}
32
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.4.7
Dado o seguinte programa principal, implemente a classe Pessoa e seus mtodos.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java

package progpessoa;
public class ProgPessoa {
Pessoa p1 = 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();
}
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
1.4.8

33
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa2.java

package progpessoa2;
public class ProgPessoa2 {
Pessoa [] pessoa = new Pessoa[3];
pessoa[0] = new Pessoa();
pessoa[0].setDados("Paulo Roberto", 1962, 'm');
pessoa[0].calculaIdade();
pessoa[0].exibePessoa();
pessoa[1].setDados("Renato Luis", 1965, 'm');
pessoa[2].setDados("Francisco Carlos", 1959, 'm');
}
Nome: Paulo Roberto
Idade: 52 ano(s)
Sexo: Masculino
Nome: Renato Luis
Idade: 49 ano(s)
Sexo: Masculino
Idade: 55 ano(s)
Sexo: Masculino
Pessoa
String nome
int ano
int idade
char sexo
setDados
calculaIdade
exibePessoa
Diagrama de classe
1.4.9
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java

package progpessoas;
public class ProgPessoas {
Pessoa pessoa = new Pessoa(7);
34
pessoa.insereDados("Beatriz", 11);
pessoa.insereDados("Debora", 13);
pessoa.insereDados("Ftima", 15);
pessoa.insereDados("Geni", 16);
pessoa.insereDados("Carla", 12);
pessoa.insereDados("Eva", 14);
pessoa.insereDados("Ana", 10);
pessoa.exibeDados();
pessoa.sort();
}
Lista de Pessoas
Nome: Beatriz
Nome: Debora
Nome: Ftima
Nome: Geni
Nome: Carla
Nome: Eva
Nome: Ana
Lista de Pessoas
Nome: Ana
Nome: Beatriz
Nome: Carla
Nome: Debora
Nome: Eva
Nome: Ftima
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.4.10 Dado o seguinte programa principal, implemente a classe Agenda e seus mtodos.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgAgenda.java
package progagenda;
public class ProgAgenda {
Agenda agenda = new Agenda(5);
agenda.insereTelefone("Ana", "99811234");
agenda.insereTelefone("Beatriz", "99812345");
agenda.insereTelefone("Carla", "99813456");
agenda.insereTelefone("Debora", "99814567");
agenda.insereTelefone("Eva", "99815678");
35
agenda.insereTelefone("Ftima", "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: Usurio no Encontrado");
}
fone = "99810123";
nome = agenda.consultaNome(fone);
} else {
}
}
ERRO: Excedeu limite da Agenda
Nome: Eva - Telefone: 99815678
ERRO: Usurio no Encontrado
Agenda
String [] nome
String [] fone
int n
int max
insereTelefone
consultaNome
Diagrama de classe
1.4.11 Dado o seguinte programa principal, implemente a classe Calculadora e seus

mtodos.
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgCalculadora.java
package progcalculadora;
public class ProgCalculadora {
Calculadora calc = new Calculadora();
calc.entradaDados();
calc.operaCalculadora();
calc.exibeResultadoCalculadora();
Observao: A calculadora deve ter as seguintes operaes:
[+] adio
[-] subtrao
[*] multiplicao
[/] diviso
[R] Raiz Quadrada
36
[P] Potncia
[S] Seno
[C] Cosseno
[T] Tangente
Calculadora
double x
double y
char operador
double resposta
entradaDados
operaCalculadora
exibeResultadoCalculadora
Diagrama de classe
Exemplo para testar o programa:
Digite um Valor: 3 <enter>
Operao [+-*/RrPpSsCcTt]: + <enter>
Digite outro Valor: 4 <enter>
Primeiro Valor: 3.0
Operador: [Adio]
Segundo Valor : 4.0
Resultado da Operao: 7.0
Exemplo da definio 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 mtodo toString
@Override
// mtodo toString sobrecarregado
return("Data: " + this.dia + "/" + this.mes + "/" + this.ano);
}
}
Programa exemplo: Programa que utiliza a classe Data definida anteriormente:

// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaData.java
package progtestadata;
37
public class ProgTestaData {

Data data = new Data(16, 3, 2010);
// construtor ir receber 3 argumentos
System.out.println(data);
}
Data: 16/3/2010
Exemplo da definio de uma classe Calculadora:

// -------------------------------------------------------------------------------------------------------------------- Classe: Calculadora.java
public class Calculadora {
// ------------------------ atributos da classe
private double x;
private double y;
private double resultado;
private char operador;
// ------------------------ construtor
// --------------------------------------- mtodos pblicos da classe
public void entradaDados() {
System.out.print("Digite um Valor: ");
s = s.replaceAll("[^0-9\\-.]", "");
// eliminao de letras digitadas de forma indevida
x = Double.parseDouble(s);
// que no podem ser convertidas para double
do {
System.out.print("Operao [+-*/RrPpSsCcTt]: ");
operador = s.charAt(0);
} while (!strChr("+-*/RrPpSsCcTt", operador));
if (strChr("+-*/Pp", operador)) {
System.out.print("Digite outro Valor: ");
s = s.replaceAll("[^0-9\\-.]", "");
// eliminao de letras digitadas de forma indevida
y = Double.parseDouble(s);
// que no podem ser convertidas para double
}
}
public void operaCalculadora() {
switch (operador) {
case '+':
resultado = add();
break;
case '-':
resultado = sub();
break;
case '*':
38
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();
break;
}
public void exibeResultadoCalculadora() {

String nomeOperador;
System.out.println("Primeiro Valor: " + x);
switch (operador) {
case '+': nomeOperador = "Adio";
break;
case '-': nomeOperador = "Subtrao";
break;
case '*': nomeOperador = "Multiplicao";
break;
case '/': nomeOperador = ("Diviso");
break;
case 'R':
case 'r': nomeOperador = "Raiz Quadrada";
break;
case 'P':
case 'p': nomeOperador = "Potncia";
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 Invlido";
}
System.out.printf("Operao realizada: [%s]\n", nomeOperador);
39
System.out.println("Segundo Valor : " + y);

System.out.println("Resultado da Operao: " + resultado);
// ------------------------------- mtodos 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));
}
private double cos() {
return (Math.cos(rads));
}
private double tan() {
return (Math.tan(rads));
}
// ----------------------------------------------------------------------- mtodos estticos 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);
}
40
Programa exemplo: Utiliza a classe Calculadora e seus mtodos definidos acima:

// -------------------------------------------------------------------------------------------------- Programa Principal: ProgCalculadora.java
public class ProgCalculadora {
Calculadora calc = new Calculadora();
// classe no recebe argumentos, no necessrio ela ter construtor
calc.entradaDados();
calc.operaCalculadora();
calc.exibeCalculadora();
Programa exemplo: Mostra outra forma de utilizar a funo strChr oriunda da linguagem de
programao C e C++ utilizando o mtodo indexOf do Java.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgstrChr.java
package progstrchr;
public class ProgstrChr {
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 {
System.out.print("Continua [S/N]? " );
s = entrada.nextLine();
} while ("SsNn".indexOf(s) == -1);
} while ("Nn".indexOf(s) == -1);
// ou ... } while ("S".equalsIgnoreCase(s));
}

Nome: Paulo Roberto Gomes Luzzardi <enter>
Paulo Roberto Gomes Luzzardi seu nome tem 28 caracteres
Continua [S/N]? N <enter>
41
Modificadores de Acesso:
public: Os atributos e mtodos tornam-se pblicos, ou seja, qualquer outro mtodo

pode chamar ou utilizar estes atributos e/ou mtodos.
private: Somente os mtodos da classe (membros) da classe podem chamar ou utilizar

atributos ou mtodos privados.
protected: Utilizado em herana simples de classe (construo de subclasses), ou seja,

uma subclasse herda todos os atributos e mtodos da classe base (superclasse). Deixa
acessvel os atributos e/ou mtodos para todas as outras classes (classe base) e
subclasses (classe derivada).
42
2. Interface e Polimorfismo
2.1 Interface
Uma interface uma especificao que define um determinado conjunto de mtodos
que sero implementados nas classes desta interface. Para uma interface ser integralmente
abstrata, seus mtodos devem ser definidos como abstract e as variveis por padro so
sempre constantes (static final).
Uma interface definida atravs da palavra reservada interface e uma classe para
implementar uma interface usa a palavra reservada implements.
Como Java no possui herana mltipla, a implementao de interfaces supram esta
carncia, como uma classe s pode herdar apenas uma vez, pode-se implementar inmeras
interfaces. As classes que implementam uma interface tero obrigatoriamente que ter todos os
mtodos da interface ou se transformar em uma classe abstrata.
// ------------------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface.java
package proginterface;
public class ProgInterface {
Homem homem = new Homem("Paulo Roberto");
Mulher mulher = new Mulher("Adriane Maria");
homem.exibeNome();
homem.exibeSexo();
mulher.exibeNome();
mulher.exibeSexo();
}
// ------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java

public interface Pessoa {
public abstract void exibeNome();
public abstract void exibeSexo();
}
// ------------------------------------------------------------------------------------------------------------------------------ Classe: Homem.java
public class Homem implements Pessoa {
43
// --------------------------------------------- atributos da classe

private final String nome;
private static final char sexo = 'm';
Homem(String nome) {
this.nome = nome;
}
@Override
// mtodo exibeNome sobrecarregado
public void exibeNome() {
System.out.println("Homem: " + nome);
}
@Override
// mtodo exibeSexo sobrecarregado
public void exibeSexo() {
System.out.println("Sexo: Masculino -> " + sexo);
}
// --------------------------------------------------------------------------------------------------------------------------------------- Classe: Mulher.java

public class Mulher implements Pessoa{
// ------------------------------------------------- atributos da classe
private static final char sexo = 'f';
Mulher(String nome) {
this.nome = nome;
}
@Override
// mtodo exibeNome sobrecarregado
System.out.println("Mulher: " + nome);
}
@Override
// mtodo exibeSexo sobrecarregado
public void exibeSexo() {
System.out.println("Sexo: Feminino -> " + sexo);
}
Homem: Paulo Roberto
Sexo: Masculino -> m
Mulher: Adriane Maria
Sexo: Feminino -> f
// --------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPixel.java
package progpixel;
public class ProgPixel {
Pixel2D pixel2D = new Pixel2D(3, 4);
Pixel3D pixel3D = new Pixel3D(5, 6, 7);
44
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 {
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
System.out.printf("x = %d | y = %d\n", x, y);
}
// ---------------------------------------------------------------------------------------------------------------------------------------- Classe: Pixel3D.java
45
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;
}
@Override
System.out.printf("x = %d | y = %d | z = %d\n", x, y, z);
}
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 funo a uma ordem padro. Significa que o
nome de um objeto pode ser utilizado para vrios propsitos ligeiramente diferentes, ou seja,
... uma interface, vrios mtodos ... . A caracterstica de polimorfismo utilizada principalmente
em sobrecarga de mtodos e operadores e classes abstratas, onde os mtodos so
declarados abstratos mas no definidos. Como tipos de polimorfismo tem-se: (a) Universal
(incluso [como em Java, por exemplo, List lista = new LinkedList();] e paramtrico [templates
46
como em C++]) e (b)
ad-hoc (sobrecarga de mtodos e operadores). Java no possui
sobrecarga de operadores.
Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes

tipos de operaes;
Sobrecarga de Mtodo: Permite que um mtodo retorne diferentes tipos de

informaes e aceite argumentos de vrios 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 no permite ser instanciada, a classe
abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma
implementao incompleta que herdada pelas classes derivadas. Cada classe derivada
implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir
mtodos abstratos, mas os mtodos so escritos nas classes derivadas concretas.
Mtodos abstratos definem apenas a forma do mtodo no contendo nenhum tipo de
cdigo. Classes concretas implementam todos os mtodos e podem ser instanciadas.
Polimorfismo o princpio no qual duas ou mais classes derivadas de uma mesma classe
base podem implementar mtodos que tm a mesma especificao, mas tem comportamentos
diferentes, especializadas para cada uma das classes derivadas, utilizando uma referncia a cada
um dos objetos da classe base.
Polimorfismo significa vrias formas, onde um objeto pode se comportar de formas
ligeiramente diferentes ao receber uma mensagem. Atravs do mecanismo de sobrecarga, dois
mtodos de uma classe podem ter o mesmo nome, desde que suas implementaes sejam
diferentes, entretanto isso no considerado polimorfismo em Java.
No polimorfismo necessrio que os mtodos tenham exatamente a mesma especificao,
sendo utilizado um mecanismo de redefinio de mtodos nas classes derivadas.
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java
47
public class ProgPolimorfismo {

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
abstract class Pessoa {
protected Double altura;
protected Character sexo;
public abstract Double calculaPesoIdeal();
public abstract String getSexo();
}
// ------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java
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

class Mulher extends Pessoa{
Mulher(Double altura, Character sexo) {
this.sexo = sexo;
}
@Override
public Double calculaPesoIdeal() {
Double pesoIdeal = 62.1 * altura - 44.7;
return (pesoIdeal);
48
}
@Override
public String getSexo() {
return("Feminino");
}
}
Peso Ideal: 61,23 (Masculino)
Peso Ideal: 57,14 (Feminino)
2.3 Lista de Exerccios: Interface e Polimorfismo

2.3.1 Dado o seguinte programa principal:
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
package proginterface_1;
public class ProgInterface_1 {
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
public interface Passaro {
public final int patas = 2;
// no pode ser private
public abstract void exibeCores();
}
Complemente o cdigo do programa criando as classes Cardeal e CardealBanhado

para que o programa tenha o seguinte resultado na sua execuo:
Nome do Pssaro: Cardeal
Nmero de Patas: 2
Cor do Topete: Vermelho
49
Cor do Corpo: Cinza

Nome do Pssaro: Cardeal Banhado
Nmero de Patas: 2
Cor do Topete: Vermelho
Cor do Corpo: preto
2.3.2 Dado o seguinte programa principal:

// -------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_2.java
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
public abstract void setDados(String nome, int idade, char sexo);
public abstract String toString();
}
| Homem: Paulo Roberto | Idade: 52 | Sexo: MASCULINO |
| Mulher: Adriane Maria | Idade: 45 | Sexo: FEMININO |
50
3. Herana em Java
A ideia bsica da herana que uma classe herde as caractersticas de outra classe. Java
possui apenas herana simples, ou seja, no permite herana mltipla.
3.1 Herana simples
A herana simples permite que uma classe incorpore os atributos e mtodos
(caractersticas) de outra classe, ou seja, permite a construo de uma hierarquia de classes.
Lembre: Java no possui herana mltipla, ou seja, tipo de herana em que uma classe
derivada herda caractersticas de vrias classes Base.
O primeiro passo envolve a definio de uma classe base (superclasse) que define as
caractersticas comuns todos os objetos derivados desta classe. As classes oriundas da classe
base so chamadas classes derivadas ou extenso da classe (subclasse) (Figura 2).
Figura 2: Exemplo de Herana em Java

Uma classe derivada herda todas as caractersticas da classe base e pode ter novas
caractersticas adicionadas a ela. Uma classe derivada segue a seguinte diretriz em relao a
classe base:
classe_derivada um(a) classe_base;
Como verificar um caso de Herana: um cardial um pssaro
51
// classe base: pssaro

// classe derivada: cardial
Especificadores de acesso:
public (pblico)
private (privado)
Quem tem acesso classe tem acesso tambm a qualquer membro pblico.
raro ter atributos pblicos, mas comum ter mtodos pblicos.
Qualquer mtodo tem acesso.
Um membro privado no acessvel fora da classe, somente pelos membros da classe.

A inteno permitir que apenas quem escreve a classe possa usar esse membro.
protected (protegido)
O membro protegido acessvel classe e a suas sub-classes (classes derivadas).

A inteno dar acesso aos programadores que estendero sua classe.
3.2 Controle de acesso na definio de uma classe derivada

Quando uma classe derivada definida, ou seja, na definio de herana simples, seus
membros (atributos e mtodos) so declarados internamente e o acesso a estes pode ser
pblico (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 herana simples :
Especificador_de_acesso class nome_classe_derivada extends nomeclasse_base {
// atributos da classe derivada
// mtodos da classe derivada
}
Quando uma classe herda as caractersticas de outra classe, todos os membros da classe
base tornam-se 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 no podem ser acessados por classes derivadas.
Quando o especificador de acesso public, todos os membros pblicos da classe base
tornam-se membros pblicos da classe derivada, e os membros protegidos da classe base
tornam-se membros protegidos da classe derivada. Esta a diferena que existe entre membros
privativos e membros protegidos.
52
Quando o especificador de acesso private, todos os membros pblicos e protegidos

da classe base tornam-se membros privativos da classe derivada, ou seja, a classe derivada no
pode transferir seus privilgios de acesso a outras classes.
Quando o especificador de acesso protected, todos os membros pblicos e
protegidos da classe base tornam-se membros protegidos da classe derivada.
Programa exemplo: O objetivo deste programa, a seguir, demonstrar a utilizao de herana
simples onde os atributos da classe base so privados.
// ------------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca.java
package progheranca;
public class ProgHeranca {
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
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
public class Derivada extends Base {
private int z;
53
Derivada(int x) {
z = x;
System.out.println("z = " + z);
}
public int somador(int soma) {
return(soma + z);
}
// no possvel acessar x e y pois so privados da classe base
z=3
x=1
y=2
Soma (x + y): 3
Somador (x + y + z): 6
Responda: Porque o atributo z exibido primeiro?

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 (pblico): Todos os atributos da classe base so pblicos na classe derivada.
private (privado): Os atributos s podem ser acessados pelos mtodos que fazem parte
da classe.
protected (protegido): Os atributos podem ser acessados pelos mtodos de classes

derivadas.
Programa exemplo: O objetivo do prximo programa demonstrar a utilizao de herana

simples tendo os atributos da classe base como protegidos.
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca2.java
package progheranca2;
public class ProgHeranca2 {
54

int resp;
}
// --------------------------------------------------------------------------------------------------------------------------- Classe Base: base.java

public class Base {
protected int x, y;
// atributos protegidos

x = a;
y = b;
}
public int soma() {
return(x + y);
}
}
private int z;
Derivada(int x) {
z = x;
}
return(x + y + z);
}
// possvel acessar x e y pois so protegidos na classe base
}
z=3
x=1
y=2
Soma (x + y): 3
O comando Super faz uma chamada formal ao construtor padro da classe-pai. A seguir,
o programa exemplo mostra a utilizao do comando Super.
55

private int z;
Derivada(int x) {
super(10, 20);
// chamada formal ao construtor da classe pai
//super();
z = x;
}
return(x + y + z);
// possvel acessar x e y pois so 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 no houver, no construtor da
subclasse, nenhuma chamada explicita ao construtor da superclasse, o construtor sem argumento chamado por
default. Se for includa uma chamada ao construtor da superclasse, ela deve ser o primeiro comando executado no
construtor da subclasse.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
public class Base {
protected int x, y;
// atributos protegidos
Base() {
// construtor default
this.x = 0;
this.y = 0;
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);
}
x = a;
y = b;
}
protected int soma() {
56
return(x + y);
}
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca3.java

public class ProgHeranca3 {
int resp;
}
x = 10 - y = 20
z=3
x=1
y=2
Soma (x + y): 3
3.4 Lista de exerccios: Herana

3.4.1 Herana (primeiro)
Dado os seguintes cdigos em Java:
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaHeranca.java
package progtestaheranca;
public class ProgTestaHeranca {
Cliente cliente = new Cliente("Paulo Roberto", "123.456.789-09", 1234.56);
cliente.imprimePessoa();
cliente.imprimeCliente();
}
// -------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java

public class Pessoa {
protected String nome;
57
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
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 modificaes devem ser feitas no cdigo fonte para que o resultado do programa
seja o esperado?
3.4.2 Herana (segundo)
Dado a classe base Pessoa e o programa principal TestaHomem, construa as classes
derivadas Homem e Mulher que contenha os atributos e mtodos abaixo descritos:
58
// -------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java

package progtestahomem;
protected double altura;
protected char sexo;
Pessoa() {
this.altura = 0.0;
this.sexo = 'g';
}
Pessoa(double altura, char sexo) {
this.sexo = sexo;
}
System.out.println("Altura: " + altura);
System.out.println("Sexo: " + sexo);
}
}
Pessoa
double altura
char sexo
imprimePessoa
Classe base (superclasse)
Homem
double pesoIdealHomem
calculaPesoIdealHomem
imprimePesoIdealHomem
Mulher
double pesoIdealMulher
calculaPesoIdealMulher
imprimePesoIdealMulher
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestaHomem.java

public class ProgTestaHomem {
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();
}
59
Altura: 1.64
Sexo: m
Peso Ideal (Homem): 61,23
Altura: 1.59
Sexo: f
Peso Ideal (Mulher): 54,04
3.4.3 Herana (terceiro)

Dados os seguintes cdigos em Java:
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestaObjetos.java
package progtestaobjetos;
public class ProgTestaObjetos {
Linha linha = new Linha(1, 2, 3, 4);
Retangulo retangulo = new Retangulo(1, 2, 3, 4);
linha.imprimeLinha("Linha");
retangulo.imprimeRetangulo("Retngulo");
}
// -------------------------------------------------------------------------------------------------------------------------- Classe Base: Objeto.java
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

public class Linha extends Objeto {
private final Objeto p1;
60

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");
}
}
Implemente a classe derivada Retangulo (Figura 3) para que o programa funcione

conforme o resultado do programa abaixo:
Linha:
x=1-y=2
x=3-y=4
Retngulo:
x=1-y=2
x=3-y=2
x=3-y=4
x=1-y=4
Figura 3: Objetos grficos: Linha e Retngulo
61
4. Mtodos de entrada e sada de dados

A seguir, so mostrados basicamente trs (3) mtodos (maneiras/formas) que permitem
fazer entrada de dados via teclado e sada 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 mtodos.
Programa exemplo: Mostra a entrada de dados, via teclado, em terminal de texto, utilizando a
classe Scanner e alguns de seus mtodos.
// -------------------------------------------------------------------------------------------------------------- Programa Principal: ProgScanner.java
package progscanner;
public class ProgScanner {
Scanner input = new Scanner (System.in);
System.out.print("Inteiro: ");
Integer x = Integer.parseInt(s);
System.out.println("Valor: " + x);
}
// l uma string via teclado

// converte a String para inteiro

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;
public class ProgEntradaDados {
62
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();
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)");
}
// ------------------------------------------------ mtodos estticos 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);
}
}
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)
63
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 mtodos.
Programa exemplo: A entrada de dados, via teclado, feita em caixa de dilogo grfica
sobreposta a interface utilizando a classe swing e alguns dos seus mtodos.
// -------------------------------------------------------------------------------------------------------------- Programa Principal: ProgSwing.java
package progswing;
import javax.swing.*;
// carrega toda o pacote swing
public class ProgSwing {

String s = JOptionPane.showInputDialog("Digite um Nmero: ");
int x = Integer.parseInt(s);
JOptionPane.showMessageDialog(null, "Inteiro: " + x, "Resultado", JOptionPane.PLAIN_MESSAGE);
// JOptionPane.showMessageDialog(null, "Inteiro: " + x);
// funciona tambm, 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
mtodos.
Programa exemplo: Entrada de dados via teclado em terminal de texto utilizando as bibliotecas
BufferedReader e InputStreamReader e alguns dos seus mtodos 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));
String nome = userInput.readLine();
Integer n = nome.length();
64
System.out.println("Nome: " + nome + " tem " + nome.length() + " caracteres");

}
Nome: Paulo Roberto <enter>
Nome: Paulo Roberto tem 13 caracteres
Observao: O programa, a seguir, serve para o pessoal que vai para a Maratona de
Programao e precisa ler vrios dados em apenas uma linha.
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgBufferReader.java
package progbufferreader;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
public class ProgBufferReader {
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;
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>
Sada:
Valor: 10
Valor: 20
Valor: 30
4.2 Sada de dados via tela

A seguir visto um programa exemplo de sada de dados na tela utilizando o mtodo
System.out.print.
Programa exemplo: Mostrando a sada de dados, via tela, utilizando os mtodos
System.out.print, System.out.println ou System.out.printf.
65
// ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPrint.java

package progprint;
public class ProgPrint {
Scanner entrada = new Scanner (System.in);
String s;
int x;
System.out.print("Inteiro: ");
x = Integer.parseInt(s);
System.out.println("Valor: " + x);
System.out.printf("Valor: %03d\n ", x);
}
}
Entrada:
Inteiro: 16 <enter>
Sada:
Valor: 16
Valor: 016
A seguir visto um exemplo de sada de dados na tela utilizando a classe swing e seus
principais mtodos.
Programa exemplo: Mostra a sada de dados, via tela, em caixa de dilogo grfica sobreposta a
interface usando a classe swing e alguns dos seus mtodos.
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgSwingSaida.java
package progswingsaida;
import javax.swing.*;
// carrega toda a biblioteca swing
public class ProgSwingSaida {

String s;
s = JOptionPane.showInputDialog("Digite um Nmero: ");

int x = Integer.parseInt(s);
JOptionPane.showMessageDialog(null, "Inteiro: " + x, "Resultado", JOptionPane.PLAIN_MESSAGE);
}
Sintaxe: JOptionPane.showMessageDialog(null, x = + x, Ttulo, JOptionPane.PLAIN_MESSAGE);
null significa que a mensagem ser centralizada
x = + x significa que sair na caixa de dialogo x = 5 (por exemplo)
Ttulo significa o ttulo da caixa de dilogo
JOptionPane.PLAIN_MESSAGE significa caixa sem cone
66
Tabela 1: Tipos de cones

Tipo de cone
cone de erro
cone de informao i
cone de advertncia !
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 Sada formatada (System.out.printf)

Como na linguagem de programao C, as sadas (impresses) na tela podem ser
formatadas em Java utizando-se o mtodo System.out.printf.
Sintaxe: System.out.printf ("string de controle", lista de variveis);
String de controle: Formada pelos caracteres que o mtodo imprime na tela, e pelos comandos
de formatao (%c, %s, %d, %f) que definem a maneira como as variveis sero impressas e
caracteres especiais (\n, \t, ...).
Tabela 2: Comandos de formatao
Cdigo
%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 preciso 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 no colocado, alinha o
resultado direita e preenche o restante esquerda com zeros ou brancos.
(+) O resultado sempre comea 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
67
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 Exerccios: Mtodos de Entrada e Sada

4.4.1 Escreva um programa em Java que l n valores inteiros (todos na mesma linha separados
por um espao em branco + <enter>). Imprima a quantidade de valores digitados, a mdia
dos valores, o maior e o menor valor (conforme exemplo abaixo).
Entrada:
10 20 30 40 50 60 70 80 90 <enter>
Sada:
Quantidade de Valores Digitados: 9

Mdia: 50.0
Maior: 90
Menor: 10
4.4.2 Escreva um programa em Java que recebe via teclado: nmero 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>
Sada:
10 20 30 40 50 60 70
Entrada:
7 <enter>
20 40 60 <enter>
Sada:
Erro na Entrada dos valores
ou
68
5. Interfaces e Containers (Classes existentes em Java)

Java possui diversas classes pr-existentes chamadas container. Um container ou
coleo simplesmente um objeto que agrupa mltiplos elementos em uma nica unidade. As
colees so utilizadas para armazenar, recuperar e manipular dados agregados.
A seguir pode-se ver algumas classes, colees ou implementaes existentes em Java
(Tabela 4):
Tabela 4: Lista de Container
Container
Descrio
Array
DList
SList
HashMap
OrderedMap
HashSet
OrderedSet
PriorityQueue
Queue
Stack
Deque
Array expansvel
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 sadas)
5.1 Colees (Collection FrameWork)

Pacote: import java.util.*;
Uma coleo um objeto que representa um grupo de objetos. Uma Collection
Framework uma arquitetura para representar e manipular colees independentes dos
detalhes de sua implementao. Uma coleo composta de Interfaces e Implementaes.
5.2 Interfaces
Uma interface uma especificao de uma classe, ou seja, um modelo para classes
desta interface. Cada classe de uma interface implementa os mtodos de uma forma diferente
do modelo da interface.
69
Interfaces e suas Implementaes (apenas as principais implementaes)
Sets (Conjuntos): No aceitam valores repetidos, ou seja, os valores armazenados no

conjunto so nicos:
o
HashSet: o mais rpido, usando uma HashTable, onde seus elementos no so

ordenados;
LinkedHashSet: Os elementos continuam na ordem que so inseridos;
TreeSet: Implementa um algoritmo conhecido por red-black tree, ou seja, uma

rvore rubro-negra.
Lists (Listas):
o
Vector: Classe obsoleta que implementa um vetor dinmico, ou seja, no

necessrio especificar o tamanho do vetor (usa uma lista encadeada simples);
Stack: Implementa uma pilha dinmica;
LinkedList: Implementa uma lista encadeada simples, ou seja, uma lista

dinmica;
ArrayList: Implementa um vetor dinmico, ou seja, no necessrio especificar

o tamanho do vetor (usa uma lista encadeada simples).
Queue (Filas): Implementa uma fila dinmica atravs de uma lista encadeada simples.
o
LinkedList: Lista encadeada simples.
Maps (Mapas):
o
HashTable: Mapa em ordem ascendente;
HashMap: Mapa em ordem ascendente;
LinkedHashMap: Mapa em ordem de incluso;
TreeMap: Mapa em ordem ascendente.
A seguir so 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
70
sem limite de tamanho pr-definido. O nico tamanho a ser respeitado a rea de memria
livre na memria RAM.
A seguir so descritos os principais mtodos da classe Vector.
Sintaxe: void add(int posio, Object objeto);
Insere o objeto na posio do Vetor.
Sintaxe: boolean add(Object objeto);
Anexa o objeto no final do Vetor.
Sintaxe: boolean addAll(Collection coleo);
Anexa todos os elementos da coleo no final do Vetor, na ordem que eles so retornados pelo iterador da coleo.
Sintaxe: boolean addAll(int posio, Collection coleo);
Insere todos os elementos na coleo no Vetor na posio.
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 cpia do Vetor.
Sintaxe: boolean contains(Object objeto);
Testa se um objeto um componente do Vetor.
Sintaxe: boolean containsAll(Collection coleo);
Retorna true se o Vetor contm todos os elementos da coleo.
Sintaxe: void copyInto(Object[] array);
Copia os componentes do Vetor para o array.
Sintaxe: Object elementAt(int posio);
Retorna o componente armazenado na posio.
Sintaxe: Enumeration elements();
Retorna uma enumerao dos componentes do Vetor.
Sintaxe: void ensureCapacity(int capacidadeMinima);
Aumenta a capacidade do Vetor para armazenar o nmero 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 posio 0) do Vetor.
Sintaxe: Object get(int posicao);
Retorna o elemento armazenado na posio do Vetor.
71
Sintaxe: int hashCode();

Retorna o cdigo hash do Vetor.
Sintaxe: int indexOf(Object objeto);
Procura e retorna a posio da primeira ocorrncia de um elemento, testando a igualdade pelo mtodo equals.
Retorna -1 se no houver o objeto.
Sintaxe: int indexOf(Object objeto, int posicao);
Procura e retorna a posio da primeira ocorrncia do objeto, comeando a busca pela posio, e testando pela
igualdade usando o mtodo equals.
Sintaxe: void insertElementAt(Object objeto, int posicao);
Insere o objeto como um componente no Vetor na posio.
Sintaxe: boolean isEmpty();
Testa se o Vetor no tem componentes, ou seja, se est vazia (true) ou no (false).
Sintaxe: Object lastElement();
Retorna o ltimo componente do Vetor.
Sintaxe: int lastIndexOf(Object objeto);
Retorna a posio da ltima ocorrncia do objeto no Vetor.
Sintaxe: int lastIndexOf(Object objeto, int posio);
Retorna a posio da ltima ocorrncia do objeto no Vetor, comeando na posio.
Sintaxe: Object remove(int posio);
Remove o elemento da posio no Vetor.
Sintaxe: boolean remove(Object objeto);
Remove a primeira ocorrncia do objeto no Vetor, se o Vetor no contm o elemento, ele no alterado.
Sintaxe: boolean removeAll(Collection coleo);
Remove do Vetor todos os elementos que contm a coleo.
Sintaxe: void removeAllElements();
Remove todos os elementos do Vetor e seta o tamanho em zero.
Sintaxe: boolean removeElement(Object objeto);
Remove a primeira ocorrncia do objeto do Vetor.
Sintaxe: void removeElementAt(int posio);
Deleta o elemento na posio.
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 coleo);
Mantm somente os elementos do Vetor que contm a coleo.
Sintaxe: Object set(int posio, Object objeto);
Troca o elemento da posio do Vetor com o elemento.
Sintaxe: void setElementAt(Object objeto, int posio);
Seta o objeto na posio do Vetor pelo objeto especificado.
Sintaxe: void setSize(int newSize);
Seta o tamanho do Vetor.
72
Sintaxe: int size();

Retorna o nmero de elementos do Vetor.
Sintaxe: List subList(int fromIndex, int toIndex);
Retorna uma lista da poro 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 representao de cada elemento.
Sintaxe: void trimToSize();
Ajusta a capacidade do Vetor para a atual dimenso do Vetor.
Programa Exemplo: Mostra a utilizao de vetor utilizando a classe Vector e alguns dos seus
mtodos.
// ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgVector.java
package progvector;
public class ProgVector {
Vector vetor = new Vector();
int u = -1, nodo;
do {
u++;
System.out.print("Nodo: ");
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("Nmero de Elementos: " + n);
System.out.println("Vector: " + vetor);
}

Nodo: 10 <enter>
Nodo: 20 <enter>
Nodo: 30 <enter>
73
Nodo: 40 <enter>
Nodo: 50 <enter>
Nodo: 60 <enter>
Nodo: 0 <enter>
Elemento: 10
Elemento: 20
Elemento: 30
Elemento: 40
Elemento: 50
Elemento: 60
Nmero de Elementos: 6
Vector: [10, 20, 30, 40, 50, 60]
Programa Exemplo: Mostra um vetor utilizando a classe Vector, inserindo em uma determinada
posio escolhida pelo usurio (note que os elementos tem que ser inseridos numa ordem
crescente de 0 n, sem pular nenhuma posio).
// --------------------------------------------------------------------------------------------------------------- Programa Principal: ProgVector2.java
package progvector2;
public class ProgVector2 {
int nodo, pos;
do {
if (nodo != 0) {
pos = Integer.parseInt(s);
if (pos >= 0 && pos <= vetor.size()) {
vetor.add(pos, nodo);
}
else {
System.out.println("ERRO: Posio Invlida ");
}
}
exibeVector(vetor);
int n = vetor.size();
for (int i = 0; i < n;i++) {
System.out.println("Elemento: "+ vetor.get(i) + " ");
}
System.out.println("Nmero de Elementos: " + n);
74
// ------------------------------------------------------- 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) {
}
}

Nodo: 10 <enter>
Posio: 0 <enter>
Indice: 0
Vetor: 10
Nodo: 20 <enter>
Posio: 1 <enter>
Indice: 0 1
Vetor: 10 20
Nodo: 30 <enter>
Posio: 2 <enter>
Indice: 0 1 2
Vetor: 10 20 30
Nodo: 40 <enter>
Posio: 6 <enter>
ERRO: Posio Invlida
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
Nmero 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
memria livre.
75
Figura 4: LinkedList - Lista Encadeada Simples

A seguir so descritos os principais mtodos de uma LinkedList.
Sintaxe: void add (int posio, Object objeto);
Insere o objeto na posio da lista.
Sintaxe: boolean add (Objetc objeto);
Anexa o objeto no final da lista.
Sintaxe: boolean addAll (Collection coleo);
Anexa todos os elementos da coleo no final da lista, na ordem que eles so retornados do iterador da coleo.
Sintaxe: boolean addAll (int posio, Collection coleo);
Insere todos os elementos da coleo dentro da lista, comeando na posio.
Sintaxe: void addFirst (Object objeto);
Insere o objeto no comeo 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 cpia da lista.
Sintaxe: boolean contains (Object objeto);
Retorna verdadeiro (true) se a lista contm o objeto.
Sintaxe: Object get (int posio);
Retorna o objeto da posio 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 posio do objeto na lista ou (-1) se a lista no contm este objeto.
Sintaxe: int lastIndexOf (Object objeto);
Retorna a ltima posio do objeto na lista ou (-1) se a lista no contm este objeto.
76
Sintaxe: ListIterator listIterator (int posio);

Retorna um iterador da lista dos elementos da lista, comeando na posio na lista.
Sintaxe: Object remove (int posio);
Remove o objeto da posio na lista.
Sintaxe: boolean remove (Object objeto);
Remove a primeira ocorrncia 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 posio, Object objeto);
Troca o objeto da posio na lista pelo o objeto especificado.
Sintaxe: int size ();
Retorna o nmero 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 mtodos inserindo inteiros.
// ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedList.java
package proglinkedlist;
public class ProgLinkedList {
LinkedList lista = new LinkedList();
int valor;
char op;
do {
exibeLista(lista);
if (valor != 0) {
do {
System.out.print("[F]irst, [L]ast ou [A]dd: ");
op = s.charAt(0);
} while ("FfLlAa".indexOf(op) == -1);
switch (op) {
case 'F':
case 'f': lista.addFirst(valor);
77
break;
case 'L':
case 'l': lista.addLast(valor);
break;
case 'A':
case 'a': lista.add(valor);
break;
}
}
} 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("]");
}
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 mtodos inserindo inteiros e
ordenando-os.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedList2.java
package proglinkedlist2;
public class ProgLinkedList2 {
lista.add(40);
78
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) {
// olhe a explicao abaixo
System.out.print(i + " ");
}
System.out.printf("\b\b]\n");
}
LinkedList Ordenada: [10, 20, 30, 40, 50, 60]
Observao: O comando for acima chamado de foreach. A sintaxe descrita abaixo:

Foreach (para cada )
Sintaxe: for (Tipo_dado varivelControle : coleo ) {
System.out.println(varivelControle);
}
Diferenas entre Classe e Interface

Uma interface em Java uma classe abstrata onde todos os mtodos so abstratos
(abstract) e pblicos (public), e todos os atributos so estticos (static) e constantes tipadas
(final). Ela semelhante a especificao de uma classe abstrata pura, com uma diferena: os
mtodos das classes abstratas podem ou no ser implementados nas classes que a estendem, j
os mtodos das interfaces tem que ser obrigatoriamente implementados nas classes que as
implementam.
Uma interface permite estabelecer uma padronizao 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 estaro presentes na classe.
A sintaxe da declarao de uma interface parecida na definio de classes, porm seu
corpo define apenas as assinaturas dos mtodos e constantes contidos na interface.
79
5.5 Arrays (array)

A classe Arrays pode ser utilizada em variveis do tipo vetor e permite copiar,
ordenar, buscar e manipular vetores. Note que no se declara vetores do tipo Arrays.
Programa Exemplo: Demonstra a utilizao da classe Arrays e alguns de seus mtodos.
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgArraysTeste.java
package progarraysteste;
public class ProgArraysTeste {
int[] vetor = {60, 30, 50, 20, 40, 10};
System.out.println("Nmero 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);
}
Nmero 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 so descritos os principais mtodos da classe Arrays.

Sintaxe: static int binarySearch(byte[] vetor, byte chave);
Procura em um vetor de byte pela chave utilizando algoritmo de busca binria.
Sintaxe: static int binarySearch(char[] vetor, char chave);
Procura em um vetor de char pela chave utilizando algoritmo de busca binria.
Sintaxe: static int binarySearch(double[] vetor, double chave);
Procura em um vetor de double pela chave utilizando algoritmo de busca binria.
Sintaxe: static int binarySearch(float[] vetor, float chave);
Procura em um vetor de float pela chave utilizando algoritmo de busca binria.
80
Sintaxe: static int binarySearch(int[] vetor, int chave);

Procura em um vetor de int pela chave utilizando algoritmo de busca binria.
Sintaxe: static int binarySearch(long[] vetor, long chave);
Procura em um vetor de long pela chave utilizando algoritmo de busca binria.
Sintaxe: static int binarySearch(Object[] vetor, Object chave);
Procura em um vetor de Object pela chave utilizando algoritmo de busca binria.
Sintaxe: static int binarySearch(short[] vetor, short chave);
Procura em um vetor de short pela chave utilizando algoritmo de busca binria.
Sintaxe: static boolean deepEquals(Object[] obj1, Object[] obj2);
Retorna true se os dois arrays de objetos so iguais.
Sintaxe: static int deepHashCode(Object[] objeto);
Retorna o cdigo hash baseado na localizao do array de objetos.
Sintaxe: static String deepToString(Object[] objeto);
Retorna em forma de string a localizao do array de objetos.
Sintaxe: static boolean equals(boolean[] vetor1, boolean[] vetor2);
Retorna true se os dois arrays de boolean so iguais.
Sintaxe: static boolean equals(byte[] vetor1, byte[] vetor2);
Retorna true se os dois arrays de byte so iguais.
Sintaxe: static boolean equals(char[] vetor1, char[] vetor2);
Retorna true se os dois arrays de char so iguais.
Sintaxe: static boolean equals(double[] vetor1, double[] vetor2);
Retorna true se os dois arrays de double so iguais.
Sintaxe: static boolean equals(float[] vetor1, float[] vetor2);
Retorna true se os dois arrays de float so iguais.
Sintaxe: static boolean equals(int[] vetor1, int[] vetor2);
Retorna true se os dois arrays de int so iguais.
Sintaxe: static boolean equals(long[] vetor1, long[] vetor2);
Retorna true se os dois arrays de long so iguais.
Sintaxe: static boolean equals(Object[] vetor1, Object[] vetor2);
Retorna true se os dois arrays de Object so iguais.
Sintaxe: static boolean equals(short[] vetor1, short[] vetor2);
Retorna true se os dois arrays de short so 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.
81
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.
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 cdigo hash com base no contedo do vetor de booleanos.
Sintaxe: static int hashCode(byte[] vetor);
Retorna o cdigo hash com base no contedo do vetor de byte.
Sintaxe: static int hashCode(char[] vetor);
Retorna o cdigo hash com base no contedo do vetor de caracteres.
Sintaxe: static int hashCode(double[] vetor);
Retorna o cdigo hash com base no contedo do vetor de double.
Sintaxe: static int hashCode(float[] vetor);
Retorna o cdigo hash com base no contedo do vetor de float.
82
Sintaxe: static int hashCode(int[] vetor);

Retorna o cdigo hash com base no contedo do vetor de inteiros.
Sintaxe: static int hashCode(long[] vetor);
Retorna o cdigo hash com base no contedo do vetor de inteiros longos.
Sintaxe: static int hashCode(Object[] vetor);
Retorna o cdigo hash com base no contedo do vetor de objetos.
Sintaxe: static int hashCode(short[] vetor);
Retorna o cdigo hash com base no contedo do vetor inteiros curtos.
Sintaxe: static void sort(byte[] vetor);
Ordena o vetor de byte em ordem ascendente numrica.
Sintaxe: static void sort(byte[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de byte em ordem ascendente numrica.
Sintaxe: static void sort(char[] vetor);
Ordena o vetor de char em ordem ascendente numrica.
Sintaxe: static void sort(char[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de char em ordem ascendente numrica.
Sintaxe: static void sort(double[] vetor);
Ordena o vetor de double em ordem ascendente numrica.
Sintaxe: static void sort(double[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de double em ordem ascendente numrica.
Sintaxe: static void sort(float[] vetor);
Ordena o vetor de float em ordem ascendente numrica.
Sintaxe: static void sort(float[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de float em ordem ascendente numrica.
Sintaxe: static void sort(int[] vetor);
Ordena o vetor de int em ordem ascende numrica.
Sintaxe: static void sort(int[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de int em ordem ascendente numrica.
Sintaxe: static void sort(long[] vetor);
Ordena o vetor de long em ordem ascendente numrica.
Sintaxe: static void sort(long[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de long em ordem ascendente numrica.
Sintaxe: static void sort(Object[] vetor);
Ordena o vetor de Object em ordem ascendente numrica, 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 numrica.
Sintaxe: static void sort(short[] vetor);
Ordena o vetor de short em ordem ascendente numrica.
Sintaxe: static void sort(short[] vetor, int fromIndex, int toIndex);
Ordena a faixa do vetor de short em ordem ascendente numrica.
83
Sintaxe: static String toString(boolean[] vetor)

Retorna uma string com o contedo do vetor de boleanos.
Sintaxe: static String toString(byte[] vetor);
Retorna uma string com o contedo do vetor de byte.
Sintaxe: static String toString(char[] vetor);
Retorna uma string com o contedo do vetor de char.
Sintaxe: static String toString(double[] vetor);
Retorna uma string com o contedo do vetor de double.
Sintaxe: static String toString(float[] vetor);
Retorna uma string com o contedo do vetor de float.
Sintaxe: static String toString(int[] vetor);
Retorna uma string com o contedo do vetor de int.
Sintaxe: static String toString(long[] vetor);
Retorna uma string com o contedo do vetor de inteiros longos.
Sintaxe: static String toString(Object[] vetor);
Retorna uma string com o contedo do vetor de objetos.
Sintaxe: static String toString(short[] vetor);
Retorna uma string com o contedo do vetor de inteiros curtos.
Programa Exemplo: Utiliza a classe Arrays e alguns mtodos que permitem ordenar (sort) e
listar um vetor.
// ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgArrays.java
package progarrays;
public class ProgArrays {
final int MAX = 10;
int [] vetor = new int[MAX];
int u = -1, n = 0, valor;
do {
u++;
n++;
if (valor != 0) {
vetor[u] = valor;
}
else {
u--;
}
// ltimo elemento
// nmero de elementos
84
} while (valor != 0 && n < MAX);

Arrays.sort(vetor, 0, u);
// vetor, incio, fim
String extenso = Arrays.toString(vetor);

System.out.println("Array: " + extenso);
}

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]
5.6 ArrayList (lista de array)

A classe ArrayList possui os mesmos mtodos da classe Vector e permite armazenar
elementos como se fosse um vetor dinmico, ou seja, sem limite da quantidade de elementos.
Programa Exemplo: Mostra dois arrays que armazenam respectivamente: nomes e idades,
note que no h ligao fsica entre eles, somente uma ligao lgica.
// ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgArrayList.java
package progarraylist;
import java.util.ArrayList;
public class ProgArrayList {
ArrayList <String> nome = new ArrayList <> ();
// ArrayList nome = new ArrayList();
// funciona assim tambm
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();
85
for (int i = 0;i < n;i++) {

System.out.printf("Nome: %-20s Idade: %d\n", nome.get(i), idade.get(i));
}
}
Nome: Paulo Roberto
Nome: Renato Luis
Nome: Ana Maria
Nome: Julia Helena
Idade: 48
Idade: 46
Idade: 50
Idade: 53
Idade: 52
Programa Exemplo: Mostra uma forma abreviada de listar um ArrayList, chamada foreach.
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgArrayListView.java
package progarraylistview;
public class ProgArrayListView {
ArrayList lista = new ArrayList();
lista.add("Ana");
lista.add("Beatriz");
lista.add("Carla");
lista.add("Dbora");
for (Object i : lista) {
System.out.println(i);
}
// foreach ... para cada ...
}
Ana
Beatriz
Carla
Dbora
Programa Exemplo: Um vetor utilizando a classe Vector e a classe ArrayList, inserindo inteiros
e caracteres. O programa utiliza o mtodo toArray para criar um array de objetos (Object).
// -------------------------------------------------------------------------------------------------------------- Programa Principal: ProgtoArray.java
package progtoarray;
86
public class ProgtoArray {

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] + " ");
}
vetor.add('A');
vetor.add('C');
vetor.add('D');
vetor.add(1, 'B');
Object [] objet = vetor.toArray();
System.out.print("Objetos: ");
for(int i = 0;i < vetor.size();i++) {
System.out.print(objet[i] + " ");
}
}
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 exerccios: 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 usurio digite um F ou f.
Logo aps 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>
87
Sada:
[L, I, M, A]
[A, M, I, L]
5.6.1.2 Escreva um programa em Java que recebe via teclado: nmero de idades e as
respectivas idades. Armazene todas as idades em um vetor de idades (Vector ou ArrayList).
Logo aps a entrada de todas as idades, o programa deve receber via teclado: idade para
consulta. O programa deve imprimir na tela, o nmero de idades antes da idade de consulta e o
nmero de idades depois da idade de consulta.
Nmero 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 nmeros
inteiros. Armazene todos os nmeros inteiros em um vetor (Vector ou ArrayList) at que o
usurio digite 0 (zero). Logo aps permita ao usurio consultar um nmero informando o seu
valor. O programa deve imprimir na tela a posio do nmero no vetor ou ERRO: Nmero
no encontrado (O programa termina quando o usurio digitar 0 (zero) na entrada) (veja o
exemplo abaixo):
Nmero: 50 <enter>
Nmero: 30 <enter>
Nmero: 20 <enter>
Nmero: 10 <enter>
Nmero: 40 <enter>
Nmero: 0 <enter>
Valor: 20 <enter>
Posio no vetor: 2
Valor: 40 <enter>
Posio no vetor: 4
Valor: 60 <enter>
ERRO: Nmero no encontrado
Valor: 0 <enter>
5.6.1.4 Escreva um programa em Java que recebe via teclado "n" conceitos (A, B, C, D e E) at
que o usurio digite F ou f. Armazene todos os conceitos em um vetor de conceitos (Vector ou
ArrayList). Imprima na tela o nmero de alunos: aprovados (A, B e C), reprovados (D) e os
infreqentes (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>
88
Conceito: f <enter>
Sada:
5 Aprovado(s)
1 Reprovado(s)
2 Infreqente (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 usurio digitar apenas
<enter>. Logo aps 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 comeam com a
letra especificada pelo usurio. O programa termina quanto o usurio digitar (nada) na
entrada da letra (conforme exemplos abaixo):
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
usurio digitar 'N' ou 'n' na pergunta "Continua [S/N]?". Logo aps 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>
Nome: Carla <enter>
Idade: 14 <enter>
Sada:
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 usurio digitar
apenas "enter". Logo aps a entrada de todos os dados, o programa deve imprimir na tela todos
os nomes em ordem alfabtica de A Z (conforme exemplo abaixo).
Entrada:

Nome: Ana <enter>
Nome: Debora <enter>
89
Nome: Carla <enter>

Nome: Eva <enter>
Nome: Geni <enter>
Nome: Fernanda <enter>
Nome: <enter>
Sada:
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 usurio digite 0 (zero). O programa deve ento
imprimir na tela: (a) as idades em ordem crescente; (b) maior idade; (c) menor idade e (d) a
mdia de idades(conforme exemplo abaixo).
Entrada:
Idade: 49 <enter>
Idade: 51 <enter>
Idade: 48 <enter>
Idade: 50 <enter>
Idade: 0 <enter>
Sada:
Idades Ordenadas: 48 49 50 51
Maior Idade: 51
Menor Idade: 48
Mdia 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)
Sada:
3 ponto(s)
5.6.1.10 Escreva um programa em Java que l o nmero de palpites para a megaSena. O

programa deve ento gerar n palpites para o Jogo da MegaSena (sem repetio em cada
palpite e ordenados em ordem crescente). O programa deve exibir na tela estes palpites
(conforme exemplo abaixo).
Entrada:
Nmero de Palpites para a MegaSena: 4 <enter>
Sada:
Palpite para MegaSena [4, 22, 43, 55, 93, 99]

Observao: Note que cada palpite deve estar armazenado em um Vector ou ArrayList
5.6.1.11 Escreva um programa em Java que armazena n nmeros inteiros em uma Lista
Encadeada Simples (LinkedList). O programa possui trs funes bsicas: [I]ncluir, [C]onsultar e
[R]emover, todas elas em ambos os lados da lista encadeada: [E]squerda e [D]ireita (conforme
exemplo abaixo).
90

[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita e <enter>
Dado: 10
LinkedList: [10]
[E]squerda ou [D]ireita d <enter>
Dado: 20
LinkedList: [10, 20]
Dado: 30
LinkedList: [10, 20, 30]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
Dado Removido esquerda: 10
LinkedList: [30]
LinkedList: []
ERRO: Lista Vazia
LinkedList: []
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 funo de Incluir, consultar e remover

em uma posio escolhida pelo usurio, ou seja, [E]squerda, [P]osio ou [D]ireita (conforme
exemplo abaixo).
[E]squerda, [P]osio [D]ireita: e <enter>
Dado: 10 <enter>
LinkedList: [10]
[E]squerda, [P]osio [D]ireita: d <enter>
Dado: 20
[E]squerda, [P]osio [D]ireita: d <enter>
Dado: 40
[E]squerda, [P]osio [D]ireita: p <enter>
Dado: 30 <enter>
Posio: 2 <enter>
91
LinkedList: [10, 20, 30, 40]

[I]ncluir, [C]onsultar, [R]emover ou [F]im: c <enter>
Posio: 2 <enter>
Dado Consultado: 30
LinkedList: [10, 20, 30, 40]
Posio: 3 <enter>
Dado Removido da Posio: 40
Posio: 6 <enter>
ERRO: Posio Invlida
[I]ncluir, [C]onsultar, [R]emover ou [F]im: f <enter>
Encadeada Simples (LinkedList). O programa possui trs funes bsicas: [I]ncluir, [E]lemento e
[R]emover, as funes Incluir e Remover em ambos os lados da lista encadeada: [E]squerda
ou [D]ireita e a funo Elemento deve listar o ANTECESSOR e o SUCESSOR deste elemento
(ou SEM ANTECESSOR e/ou SEM SUCESSOR) (conforme exemplo abaixo).
[I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter>
Dado: 10 <enter>
LinkedList: [10]
Dado: 20 <enter>
Dado: 30 <enter>
[I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter>
Elemento a Pesquisar: 20 <enter>
Antecessor: 10
Sucessor: 30
ERRO: SEM ANTECESSOR
Sucessor: 20
Antecessor: 20
ERRO: SEm SUCESSOR
[I]ncluir, [E]lemento, [R]emover ou [F]im: f <enter>
92
Encadeada Simples (LinkedList). O programa possui quatro funes bsicas: [I]ncluir,
[E]lemento, [P]esquisar e [R]emover. As funes Incluir e Remover em ambos os lados da lista
encadeada: [E]squerda e [D]ireita. A funo Elemento verifica o Antecessor e o Sucessor de um
determinado elemento. A funo Pesquisar pesquisa um determinado elemento pelo
ndice(conforme exemplo abaixo).
[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]
Dado: 20 <enter>
Indices: 0 1
Dado: 30 <enter>
Indices: 0 1 2
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>
Encadeada Simples (LinkedList). O programa possui trs funes bsicas: [I]ncluir, [S]ort e
[C]lear All. A funo Incluir inclui em ambos os lados da lista encadeada: [E]squerda e [D]ireita.
A funo Sort ordena a lista encadeada. A funo Clear All remove todos os
elementos(conforme exemplo abaixo).
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
Dado: 10 <enter>
Indices: 0
LinkedList: [10]
93
Dado: 40 <enter>
Indices: 0 1
Dado: 50 <enter>
Indices: 0 1 2
Dado: 30 <enter>
Indices: 0 1 2 3
LinkedList: [10, 40, 50, 30]
Dado: 20 <enter>
Indices: 0 1 2 3 4
LinkedList: [10, 40, 50, 30, 20]
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 nmeros inteiros em um vetor

(Vector, ArrayList ou LinkedList), mantendo-os ordenados conforme a entrada das informaes
(conforme exemplo abaixo). O programa deve ir exibindo os elementos na tela a cada nova
entrada. A entrada das informaes termina quando o usurio digitar zero (0).
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: Informao Repetida
ArrayList: [5, 10, 20, 30, 40, 50, 60]
Info: 0 <enter>
ArrayList: [5, 10, 20, 30, 40, 50, 60]
94
5.7 ArrayList bidimensional

Em Java possvel criar um array bidimensional usando a classe ArrayList.
Programa Exemplo: Mostra a utilizao de um ArrayList bidimensional.
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgArrayList2D.java
package progarraylist2d;
public class ProgArrayList2D {
final int numeroLinhas = 7;
final int numeroColunas = 5;
ArrayList[][] tabela = new ArrayList[numeroLinhas][numeroColunas];
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 j = 0; j < numeroColunas; j++) {
System.out.print(tabela[i][j]);
}
}
}
[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 multiplicao da matriz A com a matriz B. Todas as matrizes devem ser
ArrayLists.
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgMultMatriz.java
package progmultmatriz;
95
public class ProgMultMatriz {
int ma, na, mb, nb;
String s;
System.out.print("Nmero de Linhas da Matriz A (mA): ");
ma = Integer.parseInt(s);
System.out.print("Nmero de Colunas da Matriz A(nA): ");
na = Integer.parseInt(s);
System.out.print("Nmero de Linhas da Matriz B(mB): ");
mb = Integer.parseInt(s);
System.out.print("Nmero de Colunas da Matriz B(nB): ");
nb = Integer.parseInt(s);
if (na != mb) {
System.out.println("Erro Fatal: Multiplicao Impossvel");
System.out.println("Nmero de Colunas de A (nA) tem que ser igual nmero de linhas de B (mB)");
System.exit(0);
}
ArrayList[][] a = new ArrayList[ma][na];
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) + "]: ");
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) + "]: ");
b[lin][col].add(Integer.parseInt(s));
}
}
System.out.println("Matriz C = A x B");
int soma = 0;
for (int k = 0; k < na; k++) {
c[lin][col] = new ArrayList();
String A = "";
96
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);
}

System.out.println("C[" + (lin + 1) + ", " + (col + 1) + "]: " + c[lin][col]);
}
}
}
Nmero de Linhas da Matriz A (mA): 2 <enter>
Nmero de Colunas da Matriz A(nA): 2 <enter>
Nmero de Linhas da Matriz B(mB): 2 <enter>
Nmero 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]
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;
public class ProgArrayList2D_2 {
final int numeroLinhas = 3, numeroColunas = 4;
97
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;
int soma = 0;
soma = soma + a[l][c].get(0).hashCode();
sl[k] = new ArrayList();
sl[k].add(soma);
}
k++;
}
for (k = 0; k < numeroLinhas; k++) {
System.out.println("sl[" + (k + 1) + "]: " + sl[k]);
}
k = 0;
int soma = 0;
soma = soma + a[l][c].get(0).hashCode();
sc[k] = new ArrayList();
sc[k].add(soma);
}
k++;
}
for (k = 0; k < numeroColunas; k++) {
System.out.println("sc[" + (k + 1) + "]: " + sc[k]);
}
}
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>
98
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;
public class ProgArrayList2D_3 {
final int numeroLinhas = 12, numeroColunas = 13;
ArrayList<Double>[][] a = new ArrayList[numeroLinhas][numeroColunas];
double x = 1.0;
// gera matriz A
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: ");
System.out.printf("%4.1f ", a[l][c].get(0));
}
}
ArrayList<Double>[] maior = new ArrayList[numeroLinhas];
System.out.println("\nMatriz Modificada: ");
99
// ArrayList 1D
// ArrayList 2D

maior[l] = new ArrayList();
maior[l].add(0.0);
if (a[l][c].get(0) > maior[l].get(0)) {
maior[l].remove(0);
maior[l].add(a[l][c].get(0));
}
}
}
double div = a[l][c].get(0) / maior[l].get(0);
a[l][c].add(div);
}
}

System.out.printf("%4.1f -> ", maior[l].get(0));
System.out.printf("%.2f ", a[l][c].get(0));
}
}
}
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
100
5.8 Strings (Cadeia de Caracteres)

Java possui um classe que permite a manipulao de Strings (cadeia de caracteres)
chamada String.
Uma string um tipo de dado que permite armazenar e manipular um conjunto de
caracteres, nmeros e caracteres especiais (Figura 5).
Declarao e inicializao:
String s = Pelotas;
String r = null;
String str = ;
Figura 5: Representao grfica de uma String

Onde:
p o ndice do primeiro caracter (ou seja, zero)
Character primeiroCaracter = s.charAt(0);
n o nmero 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);
Observao: Note que igualmente a um vetor (array), Vector, ArrayList, LinkedList, o primeiro
caracter da String encontra-se na posio 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++) {
101
System.out.println("Cdigo ASCII: " + string.codePointAt(i));

}
for (char ch : string.toCharArray()) {
// foreach
System.out.println("Caracter: " + ch);
}
Pelotas
[P, e, l, o, t, a, s]
string: ABCDEF
Cdigo ASCII: 65
Cdigo ASCII: 66
Cdigo ASCII: 67
Cdigo ASCII: 68
Cdigo ASCII: 69
Cdigo ASCII: 70
Caracter: A
Caracter: B
Caracter: C
Caracter: D
Caracter: E
Caracter: F
5.8.1 Mtodos para manipular Strings

A seguir so descritos os principais mtodos que permitem manipular objetos do tipo
String.
Sintaxe: char charAt(int posio);
Retorna o caracter contido na posio.
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 diferenas entre mausculas e minsculas.
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 sequncia de caracteres do que a stringBuffer.
Sintaxe: static String copyValueOf(char[] vetor);
Retorna uma string que representa a sequncia de caracteres do vetor de careacteres.
Sintaxe: static String copyValueOf(char[] vetor, int offset, int count);
Retorna uma string que representa uma sequncia de caracteres do vetor.
Sintaxe: boolean endsWith(String sufixo);
102
Testa se a string termina com o sufixo especificado.

Compara a string com o objeto.
Sintaxe: boolean equalsIgnoreCase(String outraString);
Compara a string com a outraString, ignorando maisculas e minsculas.
Sintaxe: byte[] getBytes();
Codifica a string em uma sequncia 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 sequncia 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);
Cpia a seqncia de caracteres para um vetor de caracteres destino.
Retorna o cdigo hash da string.
Sintaxe: int indexOf(int caracter);
Retorna o ndice dentro da string da primeira ocorrncia do caracter especificado ou -1 se no encontrar.
Sintaxe: int indexOf(int caracter, int fromIndex);
Retorna o ndice dentro da string da primeira ocorrncia do caracter, iniciando a busca no ndice.
Sintaxe: int indexOf(String string);
Retorna o ndice dentro da string da primeira ocorrncia da substring.
Sintaxe: int indexOf(String string, int fromIndex);
Retorna o ndice dentro da string da primeira ocorrncia da substring, iniciando a busca no ndice.
Sintaxe: String intern();
Retorna uma representao cannica da string objeto (forma mais simples).
Sintaxe: int lastIndexOf(int caracter);
Retorna o ndice dentro da string da ltima ocorrncia do caracter.
Sintaxe: int lastIndexOf(int caracter, int fromIndex);
Retorna o ndice dentro da string da ltima ocurrncia do caracter, pesquisando para trs comeando no ndice.
Sintaxe: int lastIndexOf(String string);
Retorna o ndice dentro da string da ocorrncia mais direita da subseqncia.
Sintaxe: int lastIndexOf(String string, int fromIndex);
Retorna o ndice dentro da string da ltima ocorrncia da substring, buscando para trs comeando o ndice.
Sintaxe: int length();
Retorna o comprimento da string, ou seja, o nmero de caracteres presentes na string no momento.
Sintaxe: boolean matches(String expressaoRegular);
Diz se a string corresponde a uma expresso regular ou no.
Sintaxe: boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len);
Testa se duas regies das strings so iguais.
Sintaxe: boolean regionMatches(int toffset, String other, int ooffset, int len);
103
Testa se duas regies das strings so iguais.

Sintaxe: String replace(char velhoCaracter, char novoCaracter);
Retorna uma nova string resultante da troca de todas as ocorrncias do velhoCaracter nesta string com novoCaracter.
Sintaxe: String replaceAll(String expressaoRegular, String replacement);
Substitui cada subseqncia da seqncia de caracteres que corresponde a expresso regular com a substituio dada.
Sintaxe: String replaceFirst(String expressaoRegular, String replacement);
Substitui as primeiras substrings dessa string que corresponde expresso regular com a substituio dada.
Sintaxe: String[] split(String expressaoRegular);
Divide a string em pedaos (substrings) em torno da expresso regular.
Sintaxe: String[] split(String expressaoRegular, int limite);
Divide a string em pedaos em torno da expresso regular.
Sintaxe: boolean startsWith(String prefixo);
Testa se esta string comea com o prefixo.
Sintaxe: boolean startsWith(String prefixo, int toffset);
Testa se a string comea com o prefixo comeando pelo ndice.
Sintaxe: CharSequence subSequence(int beginIndex, int endIndex);
Retorna uma nova string de caracteres que uma subseqncia desta seqncia.
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();
Converte todos os caracteres da string para minsculos.
Retorna o objeto como string.
Sintaxe: String toUpperCase();
Converte todos os caracteres da string para maisculos.
Sintaxe: String trim();
Retorna uma cpia da string.
Sintaxe: static String valueOf(boolean flag);
Retorna uma representao string do argumento boolean.
Sintaxe: static String valueOf(char caracter);
Retorna uma representao string do argumento char.
Sintaxe: static String valueOf(char[] vetor);
Retorna uma representao string do argumento char [].
Sintaxe: static String valueOf(char[] vetor, int offset, int count);
Retorna uma representao string do argumento char [].
104
Sintaxe: static String valueOf(double realDouble);

Retorna uma representao string do argumento double.
Sintaxe: static String valueOf(float realFloat);
Retorna uma representao string do argumento float.
Sintaxe: static String valueOf(int inteiro);
Retorna uma representao string do argumento int.
Sintaxe: static String valueOf(long longo);
Retorna uma representao string do argumento long.
Sintaxe: static String valueOf(Object objeto);
Retorna uma representao string do argumento Object.
Exemplos:
a) Exemplo do uso dos mtodos toUpperCase e toLowerCase:
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgToUpperCase.java
package progtouppercase;
public class ProgToUpperCase {
String s = "Paulo Roberto Gomes Luzzardi";
System.out.println("Nome: " + s);

System.out.println("Nome: " + s.toUpperCase());
System.out.println("Nome: " + s.toLowerCase());
}
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
package proginverte;
public class ProgInverte {
String s;
int n;
char op;
do {
105
System.out.print("Invertido: ");
n = s.length();
for (int i = n-1;i >= 0;i--) {
System.out.print(s.charAt(i));
}
do {
System.out.print("Continua [S/N]? ");
op = s.charAt(0);
} while ("SsNn".indexOf(op) == -1);
} while ("Ss".indexOf(op) != -1);
}
// nmero de caracteres da String s

// acesso a cada caracter da String s
// verifica se op SsNn
// } while ("S".equalsIgnoreCase(s));
Exemplo para testar o orograma:

Nome: pelotas <enter>
Invertido: satolep
Nome: satolep <enter>
Invertido: pelotas
c)
Exemplo do uso de String.format:
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgStringFormat.java

package progstringformat;
public class ProgStringFormat {
float numero = 123.456789f;
String formato = String.format("%.3f", numero);
//JOptionPane.showMessageDialog(null, "numero: " + formato);
System.out.printf("Nmero: %.4f\n", numero);
System.out.println("Nmero Formatado: " + formato);
}
Nmero: 123,4568
Nmero Formatado: 123,457
5.8.2 Lista de exerccios: Strings

5.8.2.1 Escreva um programa em Java que recebe via teclado um nome. Logo aps a entrada
do nome imprima: nmero de letras maisculas, nmero de letras minsculas, nmero de
vogais e o nmero de consoantes, conforme exemplo abaixo:
Entrada:
Nome: Faculdade de Tecnologia Senac <enter>
Sada:
(3) maiscula(s)
(23) minscula(s)
106
(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
aps a entrada do nome e da letra imprima o nmero de letras que existe no nome ou ERRO:
No existe a letra (?) na palavra (?), conforme exemplo abaixo:
Palavra: Luzzardi <enter>

Letra: z <enter>
2 letra(s)
Continua [S]im ou [N]o? S <enter>
Palavra: Luzzardi <enter>
Letra: w <enter>
ERRO: No existe a letra (w) na palavra (Luzzardi)
Continua [S]im ou [N]o? N <enter>
Observao: O programa deve ser encerrado quando o usurio 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 posio. O
programa deve imprimir na tela, a letra antecessora, a letra (da referida posio) e a letra
sucessora, conforme exemplo abaixo:
Entrada:
Palavra: Universidade <enter>

Posio: 7 <enter>
Sada:
Antecessora: s
Letra: i
Sucessora: d
Observao: O programa deve imprimir na tela as seguintes mensagens de erro, se for o caso: Letra antecessora no
existe, Letra sucessora no existe ou Posio invlida.
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:
Sada:
Luzzardi
Gomes
Roberto
Paulo
do nome o programa deve imprimir (EM LETRA MAISCULA) o sobrenome da pessoa,
conforme exemplos abaixo:
Sobrenome: LUZZARDI
Sair [S/N]? N <enter>
Nome: Renato Souza <enter>
Sobrenome: SOUZA
Sair [S/N]? s <enter>
Observao: O programa termina quando o usurio digitar S ou s na pergunta: Sair [S/N]?
107
do nome o programa deve imprimir na tela: sobrenome, primeiro nome e demais nomes
abreviados, conforme exemplos abaixo:

Autor: Luzzardi, Paulo R. G.
Sair [S/N]? N <enter>
Nome: Renato Lima Souza <enter>
Autor: Souza, Renato L.
Sair [S/N]? s <enter>
Observao: O programa termina quando o usurio 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
aps a entrada do nome do estado imprima: a sigla do estado (2 letras maisculas), conforme
exemplos abaixo:
Estado: Rio Grande do Sul <enter>

Sigla: RS
Estado: so paulo <enter>
Sigla: SP
Estado: rio de janeiro <enter>
Sigla: RJ
Estado: <enter>
Observao: O programa encerra quando o usurio digitar apenas <enter> na entrada do nome do estado.
5.8.2.8 Escreva um programa em Java que recebe via teclado uma palavra, incio e fim. Logo
aps a entrada de todos os dados imprima a string resultante ou ERRO: Fim invlido ou Incio
invlido, conforme exemplos abaixo:
Palavra: universidade <enter>

Incio: 7 <enter>
Fim: 11 <enter>
String resultante: idade
Palavra: eletricidade <enter>
Incio: 7 <enter>
Fim: 15 <enter>
ERRO: Fim Invlido
Observao: O programa termina quando o usurio digitar N ou n na pergunta: Continua [S/N]?.
5.9 Classe Object

Em Java, todas as classes, sem nenhuma exceo, herdam direta ou indiretamente todos
os mtodos da classe Object, pois ela a superclasse de qualquer outra classe.
A seguir so descritos os mtodos da classe Object.
108
Sintaxe: protected Object clone();

Cria e retorna uma cpia do 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 no h mais referncias ao
objeto.
Sintaxe: Class getClass();
Retorna a classe runtime do objeto.
Retorna o valor do cdigo hash do objeto.
Sintaxe: void notify();
Aguarda uma thread que est esperando o monitor do objeto.
Sintaxe: void notifyAll();
Aguarda todas as threads que esto esperando o monitor do objeto.
Retorna uma string do objeto.
Sintaxe: void wait();
Faz a thread corrente esperar at que outra thread invoque os mtodos notify() ou notifyAll() deste objeto.
Sintaxe: void wait(long timeout);
Faz a thread corrente esperar at que outra thread invoque os mtodos notify() ou notifyAll() deste objeto ou um perodo
especificado de tempo tiver decorrido.
Sintaxe: void wait(long timeout, int nanos);
Faz a thread corrente esperar at que outra thread invoque os mtodos notify() ou notifyAll() deste objeto, ou outra
thread interrompa a corrente thread, ou um perodo especificado de tempo tiver decorrido.
Pacote: java.lang.Object (no necessrio fazer a chamada implcita 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);
}
Objeto: Paulo Roberto
Objeto: 48
109
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgObjeto.java

package progobjeto;
import java.util.Stack;
public class ProgObjeto {
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);
}
}
Objeto String: Paulo Roberto
Objeto Inteiro: 48
Objeto Pilha: 123
Valor: 123
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgNovoObjeto.java
package prognovoobjeto;
public class ProgNovoObjeto {
String s;
int n;
System.out.print("Numero de Objetos: ");

n = Integer.parseInt(s);
Object [] objeto = new Object[n];
// vetor de objetos
for (int i = 0;i < n;i++) {
objeto[i] = s;
}
for (int i = n-1;i >= 0;i--) {
System.out.println("String: " + objeto[i]);
}
110

Nmero 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 padro de projeto que permite simplificar a iterao com um conjunto de
objetos, tendo como funo encapsular a iterao sobre objetos, simplificando desta forma, a
manipulao de uma coleo de objetos.
A seguir so descritos os mtodos da classe Iterator.
Sintaxe: boolean hasNext();
Retorna true se a iterao possui mais elementos.
Sintaxe: E next();
Retorna o prximo elemento da iterao.
Sintaxe: void remove();
Remove da coleo o ltimo elemento retornado pelo iterador.
Observao: Olhe o exemplo de utilizao do Iterator da prxima seo (5.11).
5.11 Classe LinkedHashSet

LinkedHashSet uma das implementaes da interface Set (conjunto). Esta
implementao estende a implementao HashSet, adicionando uma ordem de iterao nos
elementos, usando o Iterator. A ordem de insero a ordem dos elementos do conjunto.
Utiliza uma lista duplamente encadeada para manter a ordem.
A seguir so descritos os principais mtodos da classe LinkedHashSet (HashSet,

AbstractSet, AbstractCollection, Object e Set).
Sintaxe: boolean add(E elemento);
Adiciona o elemento no conjunto, se ele ainda no existir.
Remove o objeto especificado do conjunto.
111

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 contrrio retorna false.
Retorna o nmero 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 so iguais ou false se so diferentes.
Sintaxe: int hashCode ();
Retorna o hashcode do conjunto.
Sintaxe: boolean removeAll (Collection <?> coleo);
Remove todos os elementos da coleo.
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashSet1.java
package proglinkedhashset1;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class ProgLinkedHashSet1 {
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() + ", ");
}
System.out.println(\b\b]);
}
}
LinkedHashSet: [Ana, Beatriz, Carla, Debora, Eva]
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashSet2.java
package proglinkedhashset2;
import java.util.Iterator;
import java.util.LinkedHashSet;
112
public class ProgLinkedHashSet2 {

LinkedHashSet<Integer> lista = new LinkedHashSet<>();
lista.add(100);
lista.add(200);
lista.add(300);
lista.add(400);
lista.add(500);
System.out.println("Nmero 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("Soma Total dos Elementos do Conjunto: " + somaTotal);
double media = (double) somaTotal / n;
System.out.println("Mdia do Conjunto: " + media);
}
}
Nmero de Elementos do Conjunto: 5
LinkedHashSet: [100, 200, 300, 400, 500]
Mdia do Conjunto: 300.0
5.12 Classe Genrica em Java

possvel em Java definir e utilizar uma classe genrica. Veja o exemplo a seguir aonde
h uma classe genrica Nodo:
// -------------------------------------------------------------------------------------------------------------------- Classe Genrica: Nodo.java
package progclassegenerico_1;
public class Nodo <E> {
private E element;
public void add(E element) {
this.element = element;
}
public E get() {
return element;
}
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgClasseGenerica_1.java
113
package progclassegenerico_1;
public class ProgClasseGenerico {
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());
}
Inteiro: 123
Double: 123.45
String: Paulo
Caracter: A
Float: 1.23
// ------------------------------------------------------------------------------------------------------------------ Classe Genrica: 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() {
114
return this.cor;
}
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgClasseGenerica_2.java

package progclassegenerica_2;
public class ProgClasseGenerica_2 {
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());
}
x: 100
y: 200
Cor: 3
x: 50.7
y: 100.8
Cor: 4
5.13 Fila Prioritria (PriorityQueue)

possvel em Java definir e utilizar uma Fila com Prioridade atravs da classe
PriorityQueue, ou seja, definir a ordem de retirada da Fila.
PriorityQueue uma Fila que possui uma forma prioritria na remoo dos seus
elementos, ou seja, esta forma pode ser ascendente (crescente) ou descendente (decrescente)
Veja exemplo ProgPriorityQueue abaixo.
A seguir so descritos os principais construtores e mtodos 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 coleo.
115
PriorityQueue(Comparator <? Super E> comparator)

Cria uma PriorityQueue com capacidade inicial padro e cujos elementos so 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)
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.
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
ordenao natural de seus elementos.
Retorna true se a Fila contm 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 no 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 instncia do objeto especificado desta Fila, se ele existir na Fila.
Retorna o nmero de elementos desta coleo.
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.
116
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgFilaPrioridade.java

package progfilaprioridade;
import java.util.PriorityQueue;
public class ProgFilaPrioridade {
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 Prioritrio: " + (Integer) fila.poll());
System.out.print("PriorityQueue: [");
while (!fila.isEmpty()) {
Integer nodo = (Integer) fila.poll();
System.out.print(nodo + ", ");
}
}
// remove o menor elemento
}
Fila: [10, 30, 20, 40]
Menor Elemento Prioritrio: 10
PriorityQueue: [20, 30, 40]
A seguir, o programa exemplo, mostra uma Fila de Prioridade com prioridade do mais
VELHO ao mais MOO.
// ----------------------------------------------------------------------------------------------- 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
return("[" + nome + " tem " + idade + " anos]");
}
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgPriorityQueue.java
117
package progpriorityqueue;
import java.util.PriorityQueue;
public class ProgPriorityQueue {
// 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 Prioritria: " + fila);
while (!fila.isEmpty()) {
System.out.println(fila.poll());
}
}
Fila Prioritria: [[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]
[Francisco Carlos, 54 anos]
[Paulo Roberto, 52 anos]
[Renato Luis, 49 anos]
118
6. Listas Lineares: Pilhas, Filas e Deques

A seguir visto a implementao 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 sada 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 sada, 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: Representao de uma Fila e uma Pilha

Funcionamento da Pilha acima:
Funcionamento da Fila acima:
Entrada: 10, 20 e 30 (push)

Sada: 30, 20 e 10 (pop)
Entrada: 10, 20 e 30 (insereFila)

Sada: 10, 20 e 30 (removeFila)
119
6.1 Implementao de uma Pilha (Stack)

A seguir mostrado a implementao de Pilha usando a classe Pilha e Stack (escrita
pelo programador).
Programa exemplo: Permite inserir nmeros inteiros em uma Pilha usando uma classe Pilha
implementada pelo programador. Quando o nmero digitado for igual zero (0), todos os
nmeros da pilha so 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] + ", ");
120
}
if (topo == -1) {
} else {
}
}
// ----------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPilha.java

package progpilha;
public class ProgPilha {
Pilha pilha = new Pilha(5);
String s;
int nodo;
do {
pilha.exibePilha();
System.out.print("Elemento: ");
if (nodo != 0)
pilha.push(nodo);
pilha.exibePilha();
}
Pilha: []
Elemento: 10 <enter>
Pilha: [10]
Pilha: [10, 20]
Pilha: [10, 20, 30]
Pilha: [10, 20, 30, 40]
Pilha: [10, 20, 30, 40, 50]
Erro: Pilha Cheia
Pilha: [10, 20, 30, 40, 50]
Elemento: 0
Pilha: [10, 20, 30, 40, 50]
121
Stack (Pilha)
A classe Stack utilizada para armazenar elementos em uma Pilha.
A seguir so descritos os principais mtodos da classe Stack.
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 posio que o objeto se encontra da pilha.
Programa Exemplo: Mostra uma pilha utilizando a classe Stack e seus principais mtodos de
manipulao.
// ---------------------------------------------------------------------------------------------------------------- Programa Principal: ProgStack2.java
package progstack2;
public class ProgStack2 {
int nodo, n = 0;
do {
if (nodo != 0) {
pilha.push(nodo);
n++;
}
System.out.println("Stack: " + pilha);
String extenso = "";
while (!pilha.empty()) {
extenso = extenso + pilha.pop() + ", ";
}
if (n == 0) {
extenso = "]";
122
} else {
extenso = extenso + "\b\b]";
}
System.out.println("Pilha: [" + extenso);
}

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 mtodos de
manipulao. A diferena 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;
public class ProgStack3 {
int nodo, n = 0;
do {
if (nodo != 0) {
pilha.push(nodo);
n++;
}
System.out.println("Stack: " + pilha);
System.out.print("Pilha: [");
while (!pilha.empty()) {
Integer info = (Integer) pilha.pop();
System.out.print(info + ", ");
}
}
// cast para Integer
123

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 mtodos, permitindo
procurar um elemento na pilha e retornando sua posio. Considere que a primeira posio
zero (0).
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgStack.java
package progstack;
public class ProgStack {
int valor;
do {
if (valor != 0) {
pilha.push(valor);
}
do {
System.out.print("Procurar: ");
if (valor != 0) {
int posicao = pilha.search(valor);
// procura elemento que contm o valor
if (posicao == -1) {
System.out.println("ERRO: Elemento no encontrado");
} else {
}
}
}
124

Valor: 10 <enter>
Valor: 20 <enter>
Valor: 30 <enter>
Valor: 40 <enter>
Valor: 50 <enter>
Valor: 0 <enter>
Procurar: 30 <enter>
Posio: 3
Procurar: 80 <enter>
ERRO: Elemento no encontrado
Procurar: 0 <enter>
6.2 Implementao de uma Fila (Queue)

A seguir visto uma implementao de uma Fila usando a classe Fila e Queue
(LinkedList).
Programa exemplo: Permite inserir nmeros inteiros em uma Fila utilizando uma classe Fila
implementada pelo programador. Quando o nmero digitado for igual zero (0), todos os
nmeros da fila so 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() {
125
if (n != 0) {
inic++;
n--;
return(dados[inic]);
}
else
return(0);
// ------------------------------------------------ isEmptyFila
public boolean isEmptyFila() {
if (n != 0) {
return(false);
} else {
return(true);
}
}
// ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgFila.java

package progfila;
public class ProgFila {
Fila fila = new Fila(5);
int nodo, nodos = 0;
do {
if (nodo != 0) {
fila.insereFila(nodo);
nodos++;
}
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");
}
126

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 so descritos os principais mtodos da interface Queue.
Sintaxe: E element();
Recupera, mas no remove, o primeiro da fila.
Sintaxe: boolean offer(E elemento);
Insere o elemento dentro desta fila, se possvel.
Sintaxe: E peek();
Recupera, mas no 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 no est vazia
Programa Exemplo: Mostra uma fila utilizando a classe Queue e LinkedList e seus principais
mtodos.
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgQueue.java
package progqueue;
public class ProgQueue {
Queue fila = new LinkedList();
// Fila implementada como uma Lista Encadeada Simples (LinkedList)
127
int nodo;
do {
if (nodo != 0) {
fila.offer(nodo);
}
System.out.println("Queue: " + fila);
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]");
}
}

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
mtodos. A diferena do ProgQueue que neste os elementos so retirados da Fila usando-se
um cast para Integer e no usando uma String temporria.
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgQueue2.java
package progqueue2;
public class ProgQueue2 {
// Fila implementada com uma Lista Encadeada Simples
Integer nodo;
do {
128
if (nodo != 0) {
fila.offer(nodo);
}
System.out.println("Queue: " + fila);
System.out.print("Fila: [");
if (!fila.isEmpty()) {
do {
nodo = (Integer) fila.poll();
System.out.print(nodo + ", ");
} else {
}
// cast para Integer
}
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]
Observao: No programa exemplo acima, a Fila (Queue) foi implementada como uma lista
encadeada simples (LinkedList).
6.3 Implementao de um Deque (ArrayDeque)
A seguir visto uma implementao de um Deque (Figura 7) utilizando a classe Deque
e ArrayDeque.
Figura 7: Representao visual de um Deque

129
Programa exemplo: Permite inserir nmeros 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 int inic;
private int fim;
private int n;
// --------------------------------------------------------- construtor
public Deque(int numeroElementos) {
inic = -1;
fim = 0;
n = 0;
vetor = new int[numeroElementos];
}
// ------------------------------------------------------------ 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--;
130
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) {
} else {
for (int i = 0; i < n; i++) {
}
}
}
}
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgDeque.java
package progdeque;
public class ProgDeque {
Deque deque = new Deque(5);
int nodo;
char op;
do {
deque.exibeDeque();
131
if (nodo != 0) {
do {
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;
}
}
}
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());
}

Deque: []
Deque: [10]
Deque: [10, 20]
Deque: [10, 20, 30]
Deque: [10, 20, 30, 40]
Deque: [10, 20, 30, 40, 50]
132
Erro: Deque Cheia Direita

Deque: [10, 20, 30, 40, 50]
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
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 so descritos os mtodos da classe ArrayDeque.

Sintaxe: boolean add(E elemento);
Insere o elemento no fim do deque.
Sintaxe: void addFirst(E elemento);
Insere o elemento no incio do deque.
Sintaxe: void addLast(E elemento);
Insere o elemento do final do deque.
Remove todos os elementos do deque.
Sintaxe: ArrayDeque<E> clone();
Retorna uma cpia do deque.
Retorna true se o deque contm o objeto.
Sintaxe: Iterator<E> descendingIterator();
Retorna um iterator sobre os elementos no deque em ordem sequencial reversa.
Sintaxe: E element();
Recupera, mas no remove, o elemento corrente da fila representada pelo deque.
Sintaxe: E getFirst();
Recupera, mas no remove, o primeiro elemento do deque.
Sintaxe: E getLast();
Recupera, mas no remove, o ltimo elemento do deque.
133
com
Deque:
ArrayDeque,

Retorna true se o deque no contm 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 incio do deque.
Sintaxe: boolean offerLast(E elemento);
Insere o elemento no final do deque.
Sintaxe: E peek();
Recupera, mas no remove, o elemento corrente da fila representada pelo deque ou retorna null se o deque est vazio.
Sintaxe: E peekFirst();
Recupera, mas no remove, o primeiro elemento do deque, ou retorna null se o deque est vazio.
Sintaxe: E peekLast();
Recupera, mas no 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 cabea da fila representado por este deque.
Remove a instncia de um objeto deste deque.
Sintaxe: E removeFirst();
Recupera e remove o primeiro elemento do deque.
Sintaxe: boolean removeFirstOccurrence(Object objeto);
Remove a primeira ocorrncia 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 ocorrncia do objeto do deque (quando percorre o deque do primeiro ao ltimo).
Sintaxe: int size();
134
Retorna o nmero de elementos do deque.

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 utilizao de um Deque atravs da classe ArrayDeque e seus

principais mtodos.
Pacote: import java.util.ArrayDeque;
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgArrayDeque.java
package progarraydeque;
import java.util.ArrayDeque;
public class ProgArrayDeque {
ArrayDeque deque = new ArrayDeque();
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 {
if (!s.equals("")) {
tecla = s.charAt(0);
}
} while (!strChr("IiCcEeFf", tecla));
if (!strChr("Ff", tecla)) {
do {
op = s.charAt(0);
}
} while (!strChr("EeDd", op));
switch (tecla) {
case 'I':
case 'i': System.out.print("Nodo: ");
if (strChr("Ee", op)) {
deque.addFirst(nodo);
}
135
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()) {
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()) {
nodo = (Integer) deque.pollFirst();
}
else {
nodo = (Integer) deque.pollLast();
}
System.out.println("Excluiu: " + nodo);
n--;
}
else {
System.out.println("ERRO: Deque Vazio");
}
break;
}
}
} 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);
}

Deque: []
136
// cast
// cast
[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i <enter>

Nodo: 10 <enter>
Deque: [10]
Nodo: 20 <enter>
Deque: [10, 20]
Nodo: 30 <enter>
Deque: [10, 20, 30]
[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: f <enter>
6.4 Lista de Exerccios: Listas Lineares (Pilhas, Filas e Deques)

6.4.1 Escreva um programa em Java que leia um nome via teclado. Logo aps a entrada utilize
uma Pilha (caracteres) para armazenar as letras da abreviatura deste nome. Exiba a abreviatura
invertida do nome extrada da pilha, a pilha vazia e ainda o nmero de letras da abreviatura,
conforme exemplo abaixo.
Entrada:
Nome: paulo roberto gomes luzzardi <enter>
Sada:
Abreviatura: LGRP
Pilha: []
Total de Letras: 4
6.4.2 Escreva um programa em Java que leia um nome via teclado. Logo aps a entrada utilize
uma Fila (caracteres) para armazenar e exibir (na tela do computador) todos os carateres deste
nome SEM ESPAOS EM BRANCO e ainda o nmero de espaos eliminados na exibio,
conforme exemplo abaixo.
Entrada:
Sada:
Nome Modificado: paulorobertogomesluzzardi

Nmero de Espaos eliminados: 3
6.4.3 Escreva um programa em Java que l nomes via teclado. Para cada nome digitado pelo
usurio, 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: Carla <enter>
Nome: Paulo <enter>
Nome: <enter>
Sada:
Pilha: [m, m, i, f, f]
2 homens
2 mulheres
1 indeterminados
137
6.4.4 Escreva um programa em Java que recebe n nomes via teclado (at que o usurio 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
alfabtica (a sada dos dados deve ser exatamente igual ao exemplo abaixo).
Entrada:

Nome: Carla <enter>
Nome: Eva <enter>
Nome: Ana <enter>
Nome: <enter>
Sada:
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 aps extrair todos os valores e quantidades imprimindo-os na tela conforme suas
quantidades (conforme exemplo abaixo) e ainda o total de valores impressos.
Entrada:
Sada:
Valor: 10 <enter>
Quantidade: 3 <enter>
Valor: 20 <enter>
Valor: 30 <enter>
Valor: 0 <enter>
// sada do programa
Fila: [10, 3, 20, 4, 30, 2]

Sada: 10 10 10 20 20 20 20 30 30
Total de Valores Impressos: 9
6.4.6 Escreva um programa em Java que recebe n nomes via teclado (at que o usurio 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 usurio e a pilha vazia aps as contagens (a
sada dos dados deve ser exatamente igual ao exemplo abaixo).
Entrada:
Nome: Paulo <enter>

Nome: Roberto <enter>
Nome: Gomes <enter>
Nome: Luzzardi <enter>
Nome: <enter>
Sada:
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 aps 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.
138
Entrada:
Sada:
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 aps a entrada
utilize uma pilha ou uma fila (caracteres) para exibir o nome invertido, conforme exemplo
abaixo.
Entrada:
Sada:
Nome Invertido: idrazzul semog otrebor oluap
6.4.9 Escreva um programa em Java que l um nome via teclado. Logo aps 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:
Sada:
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 aps 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:
Sada:
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 nmeros
na pilha (p1), para cada valor inserido na pilha (p1), duplique e armazene o valor na segunda
pilha (p2). Quando o usurio digitar 0 (zero), o programa deve imprimir ambas as pilhas e o
contedo das duas pilhas em ordem crescente.
Entrada:
Valor: 10 <enter>
Valor: 20 <enter>
Valor: 30 <enter>
Valor: 0 <enter>
Sada:
p1: [10, 20, 30]

p2: [20, 40, 60]
Pilhas: 10 20 20 30 40 60
30
20
10
p1
139
60
40
20
p2
6.4.12 Implemente um programa em Java que possui duas filas: f1 e f2. Insira n nmeros na
fila (f1) at que o usurio digite 0 (zero). O programa deve ento 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>
Sada:
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 aps a entrada
utilize uma pilha para inverter e exibir esta palavra na tela e ainda o nmero de letras da
palavra (conforme exemplo abaixo).
Entrada:
Palavra: pelotas <enter>
Sada:
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 considerao 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.
Valor Inicial: 10 <enter>
Valor Final: 70 <enter>
Intervalo: 10 <enter>
Fila: [10, 20, 30, 40, 50, 60, 70]
Valor Final: 20 <enter>
Intervalo: 5 <enter>
Fila: [60, 55, 50, 45, 40, 35, 30, 25, 20]
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 informaes contidas no exemplo abaixo. O
programa termina quando o usurio digitar zero (0) na entrada das informaes.
Entrada:
Nodo: 100 <enter>

Nodo: 200 <enter>
Nodo: 300 <enter>
Nodo: 0 <enter>
140
Sada:
Pilha: [100, 200, 300]

Topo da Pilha: 300
Base da Pilha: 100
Nmero de Elementos da Pilha: 3
Fila: [200, 400, 600]
Primeiro Elemento da Fila: 200
Nmero de Elementos da Fila: 3
ou
Entrada:
Nodo: 0 <enter>
Sada:
Pilha: []
Fila: []
141
7. Mapas (Maps)
7.1 Conceitos bsicos sobre Mapas
Maps associam chaves valores, onde as chaves devem ser nicas, mas os valores no.
Maps utilizam o conceito de Tabelas Hash (Figura 8), onde as Tabelas Hash so estruturas que
permitem associar uma chave a um valor. Elas permitem acesso aos valores atravs de sua chave
associada. Uma chave calculada atravs de uma funo em uma posio na Tabela Hash.
Tanto a localizao (armazenamento) e a recuperao da chave feita da mesma forma, ou seja,
atravs de um clculo matemtico.
Figura 8: Representao grfica 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, so usados os seguintes mtodos:
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 nmero de pares de elementos na tabela.
Alguns tipos de Maps: HashTable (ordem ascendente), HashMap (ordem ascendente), TreeMap
(ordem ascendente) e LinkedHashMap (ordem de incluso).
Exemplos de Mapas com HashTable: (Observao: pacote obsoleto)
142
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgHashTable.java

package proghashtable;
import java.util.Hashtable;
public class ProgHashTable {
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("Tabela Hash: " + pessoa.toString());
pessoa.clear();
}
}
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 {

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());
}
Mapa: {1=Ana, 2=Beatriz, 3=Carla, 4=Debora, 5=Eva}
// ---------------------------------------------------------------------------------------------------------- Programa principal: ProgMap2.java
package progmap2;
143

Map <Integer, String> mapa = new HashMap<>();
mapa.put(5, "Eva");
mapa.put(1, "Ana");
System.out.println("Chaves: " + mapa.keySet());
System.out.println("Valores: " + mapa.values());
}
}
Chaves: [1, 2, 3, 4, 5]
Valores: [Ana, Beatriz, Carla, Debora, Eva]
// ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap3.java
package progmap3;
import java.util.Set;
import java.util.TreeSet;

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);
}
}
Chave: 1 | Pessoa: Ana
Chave: 2 | Pessoa: Beatriz
Chave: 3 | Pessoa: Carla
Chave: 4 | Pessoa: Debora
Chave: 5 | Pessoa: Eva
package progmap4;
144

Map<Integer, String> mapa = new HashMap<>();
mapa.put(5, "Eva");
mapa.put(1, "Ana");
int n = mapa.size();
for (int i = 1; i <= n; i++) {
System.out.println("Chave: " + i + " | Pessoa: " + mapa.get(i));
}
}
Chave: 1 | Pessoa: Ana
Chave: 2 | Pessoa: Beatriz
Chave: 3 | Pessoa: Carla
Chave: 4 | Pessoa: Debora
Chave: 5 | Pessoa: Eva
package progmap_5;
public class ProgMap_5 {
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("Nmero de Elementos do Mapa: " + mapa.size());
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 + " ");
}
}
}
Nmero de Elementos do Mapa: 5
145
// listando o nmero de elementos do mapa
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 {
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();
}
Ana -> 20
Beatriz -> 19
Carla -> 17
Debora -> 18
keySet: [Ana, Beatriz, Carla, Debora]
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashMap.java
package proglinkedhashmap;
import java.util.LinkedHashMap;
public class ProgLinkedHashMap {
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));
}
146
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 Exerccios: Mapas

7.2.1 Escreva um programa em Java que utiliza uma LinkedHashMap e tenha o seguinte
resultado:
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:
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:
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
7.2.4 Escreva um programa em Java que utiliza uma HashTable e tenha o seguinte resultado:
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:
147
Nmero 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]
148
8. Processamento de fluxos de dados, caracteres e objetos (Arquivos)

Fluxos de dados ou streams so utilizados para manipulao de arquivos em Java.
Arquivos so abstraes utilizadas para que um programa interaja com os dispositivos
de sada, conectados ao computador, atravs de operaes de gravao e leitura de dados. Este
conceito virtual foi extrado do conceito real da utilizao de arquivos fsicos (armrios 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 nmero total de bytes).
H dois tipos de arquivos em Java:
Binrio: 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

so armazenados e recuperados como uma sequncia 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

149
Figura 10: Editor hexadecimal mostrando o arquivo texto

Note que num arquivo texto possvel distinguir e interpretar os caracteres
presentes no arquivo, ou seja, eles so codificados na linguagem natural das pessoas (texto
legvel visto acima direita da Figura 10), onde cada caracter ocupa um byte na memria (8
bits).
Figura 11: Editor hexadecimal mostrando o arquivo binrio

Note que num arquivo binrio no possvel distinguir e interpretar os caracteres
presentes no arquivo, ou seja, eles no so codificados na linguagem natural das pessoas
150
(texto ilegvel visto acima direita da Figura 11) e sim como um conjunto de bytes
representando cada caracter.
Observao: Os cdigos acima esto em hexadecimal, onde 0x41 65 em decimal (ou letra A),
por exemplo.
Em Java possvel manipular arquivos atravs da classe File (Arquivo).
8.1 Mtodos para manipular arquivos em Java

A seguir so descritos os principais mtodos 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 no existe.
Sintaxe: static File createTempFile(String prefixo, String sufixo);
Cria um arquivo vazio no diretrio de arquivos temporrios, usando o prefixo e o sufixo dado para gerar o seu nome.
Sintaxe: static File createTempFile(String prefixo, String sufixo, File diretrio);
Cria um novo arquivo vazio no diretrio especificado, usando o prefixo e o sufixo dado pela string para gerar o seu
nome.
Sintaxe: boolean delete();
Deleta o arquivo ou diretrio informado no pathname.
Sintaxe: void deleteOnExit();
Solicita que o arquivo ou diretrio indicado por este pathname seja excludo quando a mquina virtual termina.
Testa se o pathname igual ao objeto indicado.
Sintaxe: boolean exists();
Testa se o arquivo ou diretrio 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 cannica do pathname.
Sintaxe: String getCanonicalPath();
151
Retorna uma string cannica do pathname.
152
Sintaxe: String getName();

Retorna o nome do arquivo ou diretrio indicado pelo pathname.
Sintaxe: String getParent();
Retorna uma string do caminho pai, o caminho abstrato, ou nulo se este caminho no nome de um diretrio pai.
Sintaxe: File getParentFile();
Retorna o caminho abstrato pai do caminho, ou nulo se este caminho no nome de um diretrio pai.
Sintaxe: String getPath();
Converte este pathname em uma string do pathname.
Calcula o cdigo 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 diretrio.
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 diretrios no diretrio indicado por este caminho.
Sintaxe: String[] list(FilenameFilter filtro);
Retorna um vetor de strings com os nomes de arquivos e diretrios no diretrio indicado por este caminho que
satisfaam o filtro.
Sintaxe: File[] listFiles();
Retorna um vetor de pathname indicando os arquivos no diretrio indicado por este caminho.
Sintaxe: File[] listFiles(FileFilter filtro);
Retorna um vetor de pathname indicando os arquivos e diretrios no diretrio indicado por este caminho que
satisfaam o filtro.
Sintaxe: File[] listFiles(FilenameFilter filtro);
Retorna um vetor de pathname indicando os arquivos e diretrios no diretrio indicado por este caminho que
satisfaam o filtro.
Sintaxe: static File[] listRoots();
Lista o sistema de arquivos disponveis principais (root).
Sintaxe: boolean mkdir();
Cria o diretrio chamado por este caminho.
Sintaxe: boolean mkdirs();
Cria o diretrio chamado por este pathname, incluindo os diretrios pai necessrios, mas inexistentes.
153
Sintaxe: boolean renameTo(File dest);

Renomeia o arquivo indicado pelo pathname.
Sintaxe: boolean setLastModified(long time);
Define o tempo da ltima modificao do arquivo ou diretrio chamado por este caminho.
Sintaxe: boolean setReadOnly();
Marca o arquivo ou diretrio chamado por este caminho que s so permitidas operaes de leitura.
Retorna uma string pathname deste caminho.
Sintaxe: URI toURI();
Constri 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 so vistos alguns programas exemplos mostrando a manipulao de arquivos
em Java.
Programa exemplo: Abre um arquivo texto e exibe o nmero de bytes do referido arquivo.
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgAbreTexto.java
package progabretexto;
import java.io.File;
public class ProgAbreTexto {
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 no existe");
}
}
Arquivo: /Users/pluzzardi/luzzardi.txt
Bytes: 131
154
8.3 Listar um diretrio

Programa exemplo: Exibe na tela (lista) os arquivos e diretrios do pathname (caminho)
especificado.
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgListaDiretorio.java
package proglistadiretorio;
public class ProgListaDiretorio {
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());
}
}
/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
155
/Users/pluzzardi/Pictures
/Users/pluzzardi/Projects
/Users/pluzzardi/Public
Programa exemplo: Exibe na tela (lista) os arquivos e diretrios do pathname especificado

pelo usurio.
// ------------------------------------------------------------------------------------- Programa Principal: ProgListaDiretorioUsuario.java
package proglistadiretoriousuario;
public class ProgListaDiretorioUsuario {
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());
}
}
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
156
/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 Manipulao de um arquivo de palavras

A seguir so mostrados alguns programas exemplos que manipulam um arquivo
contendo palavras (palavras.dat). Veja o formato no exemplo abaixo:
5
carambola
beringela
abacate
ervilha
damasco
Programa exemplo: Permite criar um arquivo de palavras (palavras.dat) permitindo a gravao

destas palavras no arquivo.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgCriaPalavras.java
package progcriapalavras;
import java.io.FileWriter;
public class ProgCriaPalavras {
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
if (!arquivo.exists()) {
// proteo para no apagar o arquivo j criado
try (FileWriter file = new FileWriter(arquivo)) {
System.out.print("Nmero de Palavras: ");
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();
157
}
file.write('\n');
}
file.close();
}
}
else {
System.out.println("ERRO: Arquivo j existe");
}
Exemplo de gravao no arquivo palavras.dat:

Nmero 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
Observao: 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.FileReader;
public class ProgCarregaPalavras {
byte a;
if (arquivo.exists()) {
try (FileReader file = new FileReader(arquivo)) {
int numPalavras = file.read();
file.read();
for (int i = 1;i <= numPalavras;i++) {
158
a = (byte) file.read();
while(a != '\n') {
System.out.printf("%c", a);
a = (byte) file.read();
}
}
file.close();
}
else {
}
}
Palavra: carambola
Palavra: beringela
Palavra: abacate
Palavra: ervilha
Palavra: damasco
Programa exemplo: Permite consultar o arquivo de palavras (palavras.dat). Para tanto

solicitado, ao usurio, o nmero do registro para ser calculado a posio deste registro no
arquivo. Logo aps o registro exibido na tela.
// -------------------------------------------------------------------------------------- Programa Principal: ProgCarregaPalavrasUsuario.java
package progcarregapalavrasusuario;
import java.io.*;
import java.util.*;
public class ProgCarregaPalavrasUsuario {
String s;
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
FileReader file = new FileReader(arquivo);
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();
}
159
buffer.close();
in.close();
file.close();
int pos;
do {
System.out.print("Posio [1.." + numPalavras + "] ou [0] Sair: ");
pos = Integer.parseInt(s);
if (pos >= 1 && pos <= numPalavras) {
System.out.println("Palavra: " + linha[pos - 1]);
}
else {
if (pos != 0) {
System.out.println("ERRO: Posio Invlida");
}
}
} while (pos != 0);
}
else {
}
}
Arquivo: /Users/pluzzardi/palavras.dat
Total de Palavras: 5
Posio [1..5] ou [0] Sair: 1 <enter>
Palavra: carambola
Palavra: beringela
Palavra: abacate
Palavra: ervilha
Palavra: damasco
ERRO: Posio Invlida
8.5 Arquivo Texto

A seguir mostrado um programa que l um arquivo texto contendo:
a) Total de Palavras;
b) Lista de Palavras (nome de frutas).
160
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 {
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 ");
}
}
Total de palavras: 15
161
Palavra: abacaxi
Palavra: abacate
Palavra: banana
Palavra: pitanga
Palavra: goiaba
Palavra: morango
Palavra: carambola
Palavra: kiwi
Palavra: laranja
Palavra: bergamota
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) nmero
de linhas e (b) nmero de bytes.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgBytes.java
package progbytes;
import java.io.*;
public class ProgBytes {
int linhas = 0;
long bytes = 0;
String buffer;
String nomeArquivo;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
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)");
System.out.println("Erro: Problema com o Arquivo");
}
}
162
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 nmero;
b) Nmero de Linhas;
c)
Nmero de Bytes.
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgListar.java

package proglistar;
import java.io.*;
public class ProgListar {
int linhas = 0;
long bytes = 0;
String buffer;
String nomeArquivo;
try {
int i = 0;
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)");
}
}
Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter>
1: 15
2: abacaxi
163
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 nmero de uma

linha e exibe a linha especificada:
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinha.java
package proglinha;
import java.io.*;
public class ProgLinha {
int linha = 0, numLinha;
String s, buffer;
String nomeArquivo;
boolean listou = false;
try {
System.out.print("Nmero da Linha: ");
numLinha = Integer.parseInt(s);
int i = 0;
linha++;
if (linha == numLinha) {
System.out.printf("%2d: %s\n", linha, buffer);
listou = true;
}
i++;
}
}
if (!listou) {
164
System.out.println("ERRO: Linha no Encontrada");

}
}
Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter>
Nmero da Linha: 5 <enter>
5: pitanga
O seguinte programa mostra como gravar trs informaes em um arquivo texto

(Pessoa.dat): nome, idade e sexo de diversas pessoas.
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgWriteDados.java
package progwritedados;
public class ProgWriteDados {
String s;
String diretorio = "/Users/pluzzardi/";
File arquivo = new File(diretorio, "Pessoa.dat");
try (FileWriter file = new FileWriter(arquivo)) {
do {
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]: ");
char sexo = s.charAt(0);
file.write(sexo);
file.write(":");
do {
} while (!"SsNn".contains(s));
} while ("S".equalsIgnoreCase(s));
file.close();
}
} else {
System.out.println("ERRO: Arquivo j existe");}
}
}
165

Idade: 51 <enter>
Sexo [M/F]: m <enter>
Nome: Renato Luis <enter>
Idade: 49 <enter>
Nome: Francisco Carlos <enter>
Idade: 53 <enter>
O seguinte programa mostra como recarregar as trs informaes gravadas em um

arquivo texto acima (Pessoa.dat).
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgReadDados.java
package progreaddados;
import java.io.FileInputStream;
public class ProgReadDados {

String linha = buffer.readLine();
// l todos os dados
System.out.println("Linha: " + linha);
String[] partes = linha.split(":");
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 {
}
}
166
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
Idade: 54
Sexo: m
O programa a seguir mostra como anexar (append) mais informaes ao arquivo texto
(Pessoa.dat) j existente, sem sobre-escrev-lo.
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgAppendDados.java
package progappenddados;
import java.io.*;
public class ProgAppendDados {
String s;
try (FileWriter file = new FileWriter(arquivo, true)) { // true indica append, ou seja, anexar no fim do arquivo
do {
// o arquivo no sobre-escrito, ou seja, ele no apagado. Os dados antigos
// so mantidos e os novos anexados ao fim do arquivo
String nome = entrada.nextLine();
file.write(nome);
file.write(":");
String idade = entrada.nextLine();
file.write(idade);
file.write(":");
file.write(sexo);
file.write(":");
do {
}
} else {
167
}
}
Nome: Ana Maria <enter>
Idade: 56 <enter>
Sexo [M/F]: f <enter>
Nome: Julia Helena <enter>
Idade: 55 <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
Idade: 54
Sexo: m
Nome: Ana Maria
Idade: 56
Sexo: f
Nome: Julia Helena
Idade: 55
Sexo: f
8.6 Lista de exerccios: 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 nmero de bytes (caracteres) e o nmero de linhas do
arquivo ou ERRO: Arquivo no existe.
Entrada:
Nome do arquivo texto: lista.java <enter>
Sada:
(12345) Bytes
(44) Linhas
ou
ERRO: Arquivo no existe
programa deve permitir ao usurio consultar o arquivo atravs da entrada via teclado do
nmero da linha. O programa deve imprimir a linha especificada ou ERRO: Linha no existe
(zero para abandonar).
168

Nmero de linha: 7 <enter>
7: int i, j, k;
ERRO: Linha no existe
// sada do programa
ERRO: Arquivo no 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 contedo do arquivo origem para o arquivo
destino.
Entrada:
Arquivo origem: lista.java <enter>

Arquivo destino: lista.tmp
Sada:
<enter>
(20345) Bytes copiados
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 maisculo ou
minsculo (conforme escolha do usurio) gerando o arquivo texto destino.
Entrada:
Arquivo fonte: lista.java <enter>

Arquivo destino: lista.tmp <enter>
[+] Maisculo ou [-] Minsculo: + <enter>
Sada:
(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>
Sada:
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 no existe
programa deve permitir ao usurio consultar o arquivo atravs da entrada via teclado do
nmero inicial e nmero final. O programa deve imprimir desde a linha inicial at a linha final
ou ERRO: Linhas no existem.
Entrada:

Nmero inicial: 7 <enter>
Nmero final: 9 <enter>
Sada:
7: int i, j, k;
169
8: char tecla;
9: long bytes = 0;
ou
Entrada:
Nmero inicial: 70 <enter>

Nmero final: 90 <enter>
Sada:
ERRO: Linhas no 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 usurio inserir nomes neste arquivo via teclado. O
programa termina quando o usurio digitar <enter> na entrada do nome.
Nome do arquivo texto: nomes.txt <enter>
Nome: Eva <enter>
Nome: Carla <enter>
Nome: Fatima <enter>
Nome: Ana <enter>
Nome: <enter>
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>
Sada:
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.
Nome do arquivo texto origem: nomes.txt <enter>
Nome do arquivo texto destino: nomes.srt <enter>
Ok, arquivo ordenado e copiado
Observao: Utilize o programa anterior (ler.java) para ver os nomes ordenados.

programa deve permitir ao usurio inserir nome, idade e sexo ([M]asculino ou [F]eminino) neste
arquivo via teclado. O programa termina quando o usurio digitar <enter> na entrada do nome.
170

Nome do arquivo texto: dados.txt <enter>
Idade: 41 <enter>
Idade: 38 <enter>
Nome: Ana Maria <enter>
Idade: 44 <enter>
Nome: <enter>
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:
Sada:
Nome: Paulo Roberto

Idade: 41
Sexo: MASCULINO
Nome: Renato Luis
Idade: 38
Sexo: MASCULINO
Nome: Ana Maria
Idade: 44
Sexo: FEMININO
programa deve verificar a quantidade de homens e a quantidade de mulheres no aquivo criado
pelo programa "14.6.10".
Entrada:
Sada:
(2) Homens
(1) Mulheres
8.7 Acesso randmico em arquivos texto

possvel acessar um arquivo texto de forma randmica (aleatria), ou seja, no
puramente sequencial como o padro. Desta forma, pode-se acessar qualquer linha de um
arquivo texto.
// ---------------------------------------------------------------------------------------------- Programa Principal: ProgRadomTexto.java
package prograndomtexto;
import java.io.RandomAccessFile;
171
public class ProgRandomTexto {

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: ");
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 no existe");
}
file.seek(0);
// volta para a primeira linha
} while (nl != 0);
file.close();
} catch (IOException e) {
}
}

Nome do Arquivo Texto: /Users/pluzzardi/Frutas.txt <enter>
Linha: 3 <enter>
3: abacate
Linha: 5 <enter>
5: pitanga
Linha: 99 <enter>
Linha: 0 <enter>
8.8 Arquivo binrio de objetos em Java

Em Java possvel gravar e carregar dados em arquivos binrios que nada mais so que
so filas de bytes. Abaixo so vistos dois programas: (a) BinaryWrite grava dados (nome idade
172
e sexo) que so armazenados em um ArrayList e (b) programa BinaryRead recupera os dados

(como uma lista de dados) gravados no arquivo binrio gerado pelo programa BinaryWrite.
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgBinaryWrite.java
package progbinarywrite;
import java.io.ObjectOutputStream;
import java.io.FileOutputStream;
public class ProgBinaryWrite {
String s;
ArrayList pessoa = new ArrayList();
System.out.print("Nome do Arquivo Binrio: ");
try {
File file = new File(nomeArquivo);
try (ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(file))) {
do {
String nome = input.nextLine();
int idade = Integer.parseInt(s);
pessoa.add(nome);
pessoa.add(idade);
pessoa.add(sexo);
do {
} while (!"Nn".contains(s));
output.writeObject(pessoa); // grava ArrayList
}
} catch (IOException | NumberFormatException e) {
System.out.println(e.toString());
}
}

Nome do Arquivo Binrio: /Users/pluzzardi/pessoa.dat <enter>
Nome: Paulo <enter>
Idade: 51 <enter>
173

Idade: 49 <enter>
Sexo [M/F]: M <enter>
Nome: Francisco <enter>
Idade: 53 <enter>
Nome: Ana <enter>
Idade: 55 <enter>
Nome: Julia <enter>
Idade: 54 <enter>
Sexo [M/F]: F <enter>
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgBinaryRead.java
package progbinaryread;
import java.io.ObjectInputStream;
public class ProgBinaryRead {
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 Binrio: /Users/pluzzardi/pessoa.dat <enter>
Sada:
[Paulo, 51, m, Renato, 49, M, Francisco, 53, m, Ana, 55, f, Julia, 54, F]
8.9 Leitura e gravao de objetos (registro) em Arquivos

Em Java possvel ler e gravar dados organizados em registros. Um registro um
conjuntos de campos, onde campos so qualquer tipo em Java.
174
public class Registro {

Object nome;
Object idade;
Object sexo;
}
nome
idade
sexo
8.9.1 Gravao de objetos em um arquivo binrio de objetos

O programa abaixo permite gravar em um arquivo binrio de objetos as seguintes
informaes: 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;
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
public class FileObjeto {
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 criao do Arquivo: " + nomeFile);
175
}
}
// ------------------------------- 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) {
fileOut.close();
System.out.println("Ok, Arquivo fechado: " + nomeFile);
}
System.out.println("ERRO Fatal: Impossvel fechar o arquivo: " + nomeFile);
System.exit(1);
}
}
// --------------------------------------------------------------------------------------- Programa Principal: ProgWriteFileRegistro.java

public class ProgWriteFileRegistro {
public static void main(String[] args) throws IOException, ClassNotFoundException {
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 Binrio: /Users/pluzzardi/Objeto.dat <enter>
Sada:
Ok, Arquivo criado: /Users/pluzzardi/Objeto.dat

Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat
Observao: Por questes didticas, simplificao, no foi testado se o arquivo binrio existe,
ou seja, se ele existir, ser sobre-escrito.
176
Soluo 2: Nesta soluo o usurio digita os nomes, idades e sexo das pessoas.
// --------------------------------------------------------------------------------------------------------------------------- Classe: Registro.java
package progwritefileregistro2;
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

String nomeFile;
private ObjectOutputStream fileOut;
try {
fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile));
System.out.println("Ok, Arquivo criado: " + nomeFile);
System.out.println("ERRO Fatal: Problema na criao 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
try {
if (fileOut != null) {
fileOut.close();
}
177

System.exit(1);
}
}
// ---------------------------------------------------------------------------------------- Programa Principal: ProgWriteFileRegistro2.java
public class ProgWriteFileRegistro2 {
char ch;
do {
int idade = Integer.parseInt(s);
System.out.print("sexo [M]asculino ou [F]eminino: ");
Registro registro = new Registro(nome, idade, sexo);
file.addFile(registro);
do {
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++) {

return(true);
}
}
return(false);
}
Nome do Arquivo: /Users/pluzzardi/luz.dat <enter>
Ok, Arquivo criado: /Users/pluzzardi/luz.dat
178

Idade: 51 <enter>
sexo [M]asculino ou [F]eminino: m <enter>
Idade: 49 <enter>
Nome: Francisco Carlos <enter>
Idade: 53 <enter>
Ok, Arquivo fechado: /Users/pluzzardi/luz.dat
8.9.2 Leitura objetos em um arquivo binrio de objetos

O programa abaixo permite carregar (ler) de um arquivo binrio de objetos com as
seguintes informaes: nome, idade e sexo.
// --------------------------------------------------------------------------------------------------------------------------------------- Classe: Registro.java
package progreadfileregistro;
Object nome;
Object idade;
Object sexo;
}
// ---------------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java
import java.io.ObjectInputStream;
import java.io.EOFException;
// ---------------------------------- atributos da classe
String nomeFile;
private ObjectInputStream fileIn;
// ----------------------------------------------- construtor
try {
fileIn = new ObjectInputStream(new FileInputStream(nomeFile));
System.out.println("Ok, Arquivo Aberto: " + nomeFile);
System.out.println("ERRO Fatal: Problema na Abertura do Arquivo: " + nomeFile);
System.exit(1);
}
// ----------------------------------------------------------------------------------------------------- getFile
public void getFile() throws IOException, ClassNotFoundException {
179
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
try {
if (fileIn != null) {
fileIn.close();
}
System.exit(1);
}
}
// -------------------------------------------------------------------------------------- Programa Principal: ProgReadFileRegistro.java

public class ProgReadFileRegistro {
file.getFile();
file.closeFile();
}
Entrada:
Nome do Arquivo Binrio: /Users/pluzzardi/Objeto.dat <enter>
Sada:
Ok, Arquivo Aberto: /Users/pluzzardi/Objeto.dat

Nome
Idade Sexo
Paulo Roberto
50 m
Adriane Maria
42 f
Paola
13 f
Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat
ou
180
Entrada:
Nome do Arquivo: /Users/pluzzardi/luz.dat <enter>
Sada:
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
181
9. Noes de desenvolvimento de aplicaes em camadas (MVC)

9.1 Conceitos
Model View Controller (MVC Modelo Viso Controlador) um modelo de arquitetura
de programa que divide a representao da informao e da interao.
O model (modelo) contm os dados da aplicao, as regras de negcios, a lgica e os
mtodos. Uma view (viso) pode ser qualquer sada ou impresso da representao dos dados.
Pode-se possuir vrias vises da mesma informao. O controller (controlador) faz a
mediao da entrada, convertendo-a em comandos para o modelo ou viso. As vantagens do
MVC so resusabilidade de cdigo e separao de conceitos.
Resumindo, as partes presentes no MVC tem as seguintes funes:
Controller enxerga a view e reconhece o model. Recebe requisies do usurio da

view e envia para o model executar as requisies.
Model recebe as requisies e as executa, atualizando os dados da aplicao.
View analisa o model e espera os dados serem
atualiza-dos, mostrando os
dados atualizados.
Vantagens do modelo Model View Controller:

1. fcil manter, testar e atualizar.
2. simples incluir novos dados, apenas pela incluso de seus visualizadores e controles.
3. Torna a aplicao escalvel.
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. No recomendvel para aplicaes pequenas.
182
9.2 Primeiro exemplo da utilizao do MVC (ProgMVCPessoa)

A seguir visto e descrito a utilizao do MVC em Java (Figura 12). O programa
ProgMVCPessoa trabalha com as seguintes informaes de uma pessoa (nome, idade e sexo).
Figura 12: Exemplo de MVC

// ------------------------------------------------------------------------------------------------------------------------------------------------- Pacote: entity
// -------------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java
package entity;
public final class Pessoa {
// --------------------------------- atributos da classe
private int idade;
183
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);
}
// ----------------------------------------------------- mtodos pblicos 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);
}
// ----------------------------------------------------------- mtodos estticos da classe

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
184
// --------------------------------------------------------------------------------------------------------------------------------------- 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');
}
// --------------------------------------------------------------- mtodos pblicos 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 Invlida");
}
if (pessoa.getSexo() != 'x') {
System.out.println("Sexo: " + pessoa.getSexo());
} else {
System.out.println("ERRO: Sexo Invlido");
}
}
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 {
}
if (pessoa.getPessoa().getSexo() != 'x') {
System.out.println("Sexo: " + pessoa.getPessoa().getSexo());
} else {
}
}
// ------------------------------------------------------------------------------------------------------------------- Programa Principal: Principal.java

package pessoaView;
public class Principal {
185
new PessoaView();
}
// -------------------------------------------------------------------------------------------------------------------------------------------- Pacote: service

// -------------------------------------------------------------------------------------------------------------------------- Classe: PessoaService.java
package service;
public class PessoaService {
private Pessoa pessoa;
// ------------------------------------------ construtor da classe
public PessoaService() {
pessoa = new Pessoa();
}
public PessoaService(String nome, int idade, char sexo) {
alteraPessoa(nome, idade, sexo);
}
// --------------------------------------------------------------------------------------------- mtodos pblicos 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);
}
Nome: Paulo Roberto
ERRO: Idade Invlida
ERRO: Sexo Invlido
Nome: Renato Luis
Idade: 49
Sexo: m
9.3 Segundo exemplo da utilizao do MVC (ProgMVCPessoa2)

A seguir visto e descrito a utilizao do MVC em Java (Figura 13). O programa
ProgMVCPessoa trabalha com as seguintes informaes de uma pessoa (nome, idade e sexo) e
permite ao usurio digitar estas informaes via teclado.
186
Figura 13: Exemplo de MVC

// --------------------------------------------------------------------------------------------------------------------------------------------- Pacote: entity
// ---------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java
package entity;
public final class Pessoa {
// -------------------------------- atributos da classe
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);
}
// ---------------------------------------------------------- mtodos pblicos da classe
187
this.nome = nome;
}
public void setIdade(int idade) {
this.idade = idade >= 0 && idade <= 110 ? idade : -99;
}
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);
}
// ----------------------------------------------------------------- mtodos pblicos da classe

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
// ----------------------------------------------------------------------------------------------------------------------------------------- Pacote: pessoaView

// ------------------------------------------------------------------------------------------------------------ Classe: PessoaView.java
package pessoaView;
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);
188
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);
// ---------------------------------------------------------------- mtodos pblicos da classe

public void exibeView(Pessoa pessoa) {
System.out.println("Nome: " + pessoa.getNome());
if (pessoa.getIdade() != -99) {
System.out.println("Idade: " + pessoa.getIdade());
} else {
}
if (pessoa.getSexo() != 'x') {
System.out.println("Sexo: " + pessoa.getSexo());
} else {
}
}
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 {
}
if (pessoa.getPessoa().getSexo() != 'x') {
System.out.println("Sexo: " + pessoa.getPessoa().getSexo());
} else {
}
}
// -------------------------------------------------------------------------------------------------------------------- Programa Principal: Principal.java

package pessoaView;
public class Principal {
new PessoaView();
}
}
// -------------------------------------------------------------------------------------------------------------------------------------------- Pacote: service
// ----------------------------------------------------------------------------------------------------------------------------- Classe: PessoaService.java
package service;
public class PessoaService {
189
// -------------------------------------- atributos da classe

private Pessoa pessoa;
// -------------------------------------- construtor da classe
public PessoaService() {
}
public PessoaService(String nome, int idade, char sexo) {
alteraPessoa(nome, idade, sexo);
}
// ------------------------------------------------------------------------------------------- mtodos pblicos 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);
}
}
// ----------------------------------------------------------------------------------------------------------------------------------------------- Pacote: util
// ------------------------------------------------------------------------------------------------------------- Classe: Utilidade.java
package util;
public class Utilidade {
public static String lerString(String mensagem) {
System.out.print(mensagem);
return(s);
}
public static int lerInteiro(String mensagem) {
int inteiro = Integer.parseInt(s);
return(inteiro);
}
public static char lerChar(String mensagem) {

char ch = s.charAt(0);
return(ch);
}
190
Entrada:
Digite seu Nome: Paulo Roberto <enter>

Digite sua Idade: 52 <enter>
Seu Sexo [M]asculino ou [F]eminino: m <enter>
Sada:
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>
Sada:
Nome: Adriane Maria

Idade: 44
Sexo: f
191
10. Conceitos gerais

10.1 Como calculado o hashcode no Java
A seguir visto um pequeno programa que mostra o clculo do hashcode de uma
string (String) e/ou de um objeto (Object) em Java.
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgHash.java
package proghash;
public class ProgHash {
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());
}
HashCode: -1424385949
Hash calculado: -1424385949
HashCode objeto: -1424385949
Observao: Note que o resultado deu negativo pois extrapolou o mximo dos inteiros
positivos (int). Veja na Tabela 5, abaixo, a faixa de valores ddos nmeros 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
192
11. Lista Encadeada Simples em Java

11.1 Lista Encadeada de Inteiros
A implementao de uma Lista Encadeada permite alocacar dinamicamente
elementos na memria RAM, ou seja, a lista linear de elementos cresce com a execuo do
programa enquanto houver memria livre. Operaes como insero e remoo so 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 so alocados dinamicamente, elas crescem com a necessidade do usurio. Por outro
lado, o programador no precisa estipular um tamanho fixo para elas, pois elas podem crescer
enquanto houver memria livre, ou seja, os elementos alocados e armazenados podem estar em
qualquer posio da rea de dados da memria RAM (Random Access Memory) [Figura 15].
Desta forma, os elementos precisam estar conectados por uma ligao entre os nodos da lista,
esta ligao se chama elo. Em Java este elo uma referncia. Alm disso, necessrio
armazenar, pelo menos, a referncia do primeiro elemento da lista, para se ter acesso aos
demais elementos da lista. E para facilitar, pode-se ainda armazenar o nmero de elementos da
lista (e o ltimo), pois para obter esta informao, seria necessrio percorrer toda a lista
contando os elementos. Esta operao muito dispendiosa se a lista for muito grande.
public class Nodo {
public int info;
public Nodo elo;
}
// info: informao que ser armazenada na memria RAM

// guarda a referncia do prximo elemento
193
Observao: Note que esta lista encadeada simples (acima) funcionar como uma pilha, pois
ela cresce para a esquerda, ou seja, toda insero e remoo realizada apenas num extremo
(lado esquerdo).
Figura 15: Alocao de elementos na Memria RAM

A Figura 15 acima, mostra a diferena entre alocao esttica de memria e a alocao
dinmica de memria. Note que na esttica (lado esquerdo) h contiguidade fsica, ou seja,
os elementos esto um ao lado do outro, por causa disto possvel indexar cada elemento de
um vetor, ou seja, x[0], x[1], x[n]. Note que na dinmica (lado direito) necessrio
(obrigatrio) armazenar a referncia do primeiro elemento e o primeiro elemento necessita ter
um elo para o segundo e assim sucessivamente, at que o ltimo elemento no aponta para
nenhum elemento (referncia do ltimo null).
Note que o vetor x alocado estaticamente :
short []x = {10, 20, 30, 40, 50, 60, 70, 80};
Observao: Cada elemento do tipo short ocupa 2 bytes na memria RAM
Note que a lista encadeada simples :

10 20 30 40 50
// onde 10 o primeiro
// 50 o ltimo elemento
194
Problema proposto: Escrever um programa em Java que permite inserir, excluir, consultar
dados em uma lista encadeada simples.
Programa exemplo: Demonstra a incluso, excluso e consulta de nmeros inteiros em

uma lista encadeada simples utilizando as classes: Nodo e ListaSimples escritas pelo
programador.
// --------------------------------------------------------------------------------------------------------------------------------- Classe: Nodo.java
package progsimples;
public class Nodo {
public int info;
public Nodo elo;
}
// --------------------------------------------------------------------------------------------------------------------------------- Classe: ListaSimples.java
public class ListaSimples {
// ------------------------------------ atributos da classe
private int n;
private Nodo primeiro;
// ------------------------------------ construtor
ListaSimples() {
primeiro = null;
n = 0;
}
// ----------------------------------------------------------- mtodos pblicos 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--;
195
if (n == 0) {
primeiro = null;
}
return (valor);
}
// ----------------------------------------------------------- pesquisar
public int pesquisar(int valor) {
if (n != 0) {
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);
}
// ----------------------------------------------------------- exibir
public void exibir() {
System.out.print("Lista Encadeada Simples: [");
if (n == 0) {
System.out.println("Vazia]");
} else {
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 {
196
return (valor);
}
// ---------------------- mtodos privados da classe

// ---------------------- mtodos estticos da classe
}
// ------------------------------------------------------------------------------------------------------------------------------- Classe: ProgSimples.java
public class ProgSimples {
ListaSimples simples = new ListaSimples();
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: ");
op = s.charAt(0);
} while (!strChr("IiEeCcPpRrFf", op));
if (strChr("Ff", op)) {
System.exit(0);
}
switch (op) {
case 'I':
case 'i':
simples.incluir(valor);
break;
case 'E':
case 'e':
valor = simples.excluir();
if (valor != -999) {
System.out.println("Valor Excludo Esquerda: " + valor);
} else {
System.out.println("ERRO: Lista vazia Esquerda");
}
break;
case 'P':
case 'p':
System.out.print("Valor Pesquisar: ");
int valorPesquisar = Integer.parseInt(s);
posicao = simples.pesquisar(valorPesquisar);
System.out.println("Posio do Valor pesquisado: " + posicao);
} else {
197
System.out.println("ERRO: Valor no 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 {
}
break;
}
} while (!strChr("Ff", op));
}
public static boolean strChr(String s, char ch) {

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}

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]
Valor: 20 <enter>
Descritor: | progsimples.Nodo@5d08e435 | 2 |
Lista Encadeada Simples: [20 10]
Valor: 30 <enter>
Descritor: | progsimples.Nodo@72be834a | 3 |
Lista Encadeada Simples: [30 20 10]
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 Excludo Esquerda: 40
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter>
Valor Pesquisar: 20 <enter>
Posio do Valor pesquisado: 2
198
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter>
Valor Consultado Esquerda: 30
Descritor: | progsimples.Nodo@5d08e435 | 2 |
Lista Encadeada Simples: [20 10]
Descritor: | progsimples.Nodo@77eec5fe | 1 |
Lista Encadeada Simples: [10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter>
11.2 Lista Encadeada Genrica (String, Integer ou Double)

A seguir, a Lista Simples Genrica permite armazenar elementos dos seguintes tipos de
dados: String, Integer, Double ou Character.
Sintaxe: ListaSimplesGenerica <String> simples = new ListaSimplesGenerica<>();
// --------------------------------------------------------------------------------------------------------------------------------- Classe: Nodo.java
public class Nodo<E> {
E element;
Nodo<E> elo;
}
// ------------------------------------------------------------------------------------------------------------- Classe: ListaSimplesGenerica.java
public class ListaSimplesGenerica <E>{
// ---------------------- atributos da classe
private int n;
// ---------------------- construtor
ListaSimplesGenerica() {
primeiro = null;
n = 0;
}
// ----------------------------------------------------------- incluir
public void incluir(Object valor) {
199
ref.element = valor;
if (n != 0) {
ref.elo = primeiro;
}
n++;
primeiro = ref;
}
// ----------------------------------------------------------- excluir
public Object excluir() {
if (n == 0) {
return (-999);
} else {
Object valor = ref.element;
primeiro = ref.elo;
n--;
if (n == 0) {
primeiro = null;
}
return (valor);
}
}
// ----------------------------------------------------------- pesquisar
public int pesquisar(Object valor) {
if (n != 0) {
int posicao = 1;
if (ref.element.equals(valor)) {
return (posicao);
}
ref = ref.elo;
posicao++;
}
} else {
}
return (-1);
}
// ----------------------------------------------------------- exibir
public void exibir() {
System.out.print("Lista Encadeada Simples: [");
if (n == 0) {
} else {
System.out.print(ref.element + " ");
ref = ref.elo;
}
}
}
200
System.out.println("Descritor: | " + primeiro + " | " + n + " |");

}
// ----------------------------------------------------------- removeAll
primeiro = null;
n = 0;
System.gc();
}
// ----------------------------------------------------------- consultar
public Object consultar() {
if (n == 0) {
return (-999);
} else {
Object valor = ref.element;
return (valor);
}
}
}
// ----------------------------------------------------------------------------------------------------------- Classe: ProgListaSimplesGenerica.java
public class ProgSimplesGenerica {
ListaSimplesGenerica<String> simples = new ListaSimplesGenerica<>();
// troque String por Integer ou Double e teste novamente
char op;
int posicao;
Object valor;
do {
simples.exibeDescritor();
simples.exibir();
do {
op = s.charAt(0);
System.exit(0);
}
switch (op) {
case 'I':
case 'i':
simples.incluir(s);
break;
201
case 'E':
case 'e':
valor = simples.excluir();
if (valor.hashCode() != -999) {
} else {
}
break;
case 'P':
case 'p':
String valorPesquisar = input.nextLine();
posicao = simples.pesquisar(valorPesquisar);
} else {
}
break;
case 'R':
case 'r':
simples.removeAll();
break;
case 'C':
case 'c':
valor = simples.consultar();
if (valor.hashCode() != -999) {
} else {
}
break;
}
}

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}

Valor: Ana <enter>
Descritor: | progsimples.Nodo@6d6f6e28 | 1 |
Lista Encadeada Simples: [Ana]
Valor: Beatriz <enter>
202
Descritor: | progsimples.Nodo@135fbaa4 | 2 |
Lista Encadeada Simples: [Beatriz Ana]
Valor: Carla <enter>
Descritor: | progsimples.Nodo@45ee12a7 | 3 |
Lista Encadeada Simples: [Carla Beatriz Ana]
Valor Pesquisar: Beatriz <enter>
Valor Consultado Esquerda: Carla
Valor Excludo Esquerda: Carla
Descritor: | progsimples.Nodo@135fbaa4 | 2 |
Lista Encadeada Simples: [Beatriz Ana]
Valor Excludo Esquerda: Beatriz
Descritor: | progsimples.Nodo@6d6f6e28 | 1 |
Lista Encadeada Simples: [Ana]
Valor Excludo Esquerda: Ana
ERRO: Lista vazia Esquerda
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 no descritor.
Descritor: Estrutura que normalmente armazena o primeiro elemento, a quantidade de elementos e o ltimo elemento da Lista.
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.
203
Programa exemplo: Demonstra a incluso, excluso, pesquisa, consulta, remoo

completa e exibio de nmeros inteiros ( esquerda, direita e na posio escolhida pelo
usurio) 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;
}
// --------------------------------------------------------------------------------------------------------------------------------------- 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
}
204

// ----------------------------------------------------------- incluirEsquerda
public void incluirEsquerda(int valor) {
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) {
ref.info = valor;
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) {
ref.info = valor;
Nodo aux = descritor.primeiro;
if (posicao == 1) {
incluirEsquerda(valor);
} 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 {
}
}
// ----------------------------------------------------------- excluirEsquerda
public int excluirEsquerda() {
205
return (-999);
} else {
Nodo ref = descritor.primeiro;
descritor.primeiro = ref.posterior;
if (descritor.primeiro != null) {
descritor.primeiro.anterior = null;
}
descritor.n--;
descritor.ultimo = null;
}
return (valor);
}
// ----------------------------------------------------------- excluirDireita
public int excluirDireita() {
return (-999);
} else {
Nodo ref = descritor.ultimo;
descritor.ultimo = ref.anterior;
if (descritor.ultimo != null) {
descritor.ultimo.posterior = null;
}
descritor.n--;
descritor.primeiro = null;
}
return (valor);
}
}
// ----------------------------------------------------------- excluirPosicao
public int excluirPosicao(int posicao) {
return (-999);
} else {
if (posicao == 1) {
return (excluirEsquerda());
} else {
if (posicao == descritor.n) {
return (excluirDireita());
} else {
Nodo aux = ref;
for (int i = 1; i < posicao; i++) {
aux = ref;
ref = ref.posterior;
}
aux.posterior = ref.posterior;
ref.posterior.anterior = aux;
descritor.n--;
descritor.ultimo = null;
206
}
return (valor);
}
}
// ----------------------------------------------------------- pesquisar
public int pesquisar(int valor) {
if (descritor.n != 0) {
int posicao = 1;
if (ref.info == valor) {
return (posicao);
}
posicao++;
}
} else {
}
return (-1);
}
// ----------------------------------------------------------- exibirEsquerda
public void exibirEsquerda() {
System.out.print("Lista pela Esquerda: [");
} else {
}
}
// ----------------------------------------------------------- exibirDireita
public void exibirDireita() {
System.out.print("Lista pela Direita: [");
} else {
ref = ref.anterior;
}
}
}
System.out.println("Descritor: | " + descritor.primeiro + " | " +
207
descritor.n + " | " + descritor.ultimo + " |");

}
// ----------------------------------------------------------- removeAll
descritor = new Descritor(null, 0, null);
System.gc();
}
// ----------------------------------------------------------- consultarEsquerda
public int consultarEsquerda() {
return (-999);
} else {
return (valor);
}
}
// ----------------------------------------------------------- consultarDireita
public int consultarDireita() {
return (-999);
} else {
return (valor);
}
}
// ----------------------------------------------------------- consultarPosicao
public int consultarPosicao(int posicao) {
return (-999);
} else {
if (posicao == 1) {
return (consultarEsquerda());
} else {
if (posicao == descritor.n) {
return (consultarDireita());
} else {
for (int i = 1; i < posicao; i++) {
}
return (valor);
}
}
}
}
}
// ------------------------------------------------------------------------------------------------------------------- Programa Principal: ProgDupla.java
208
package progdupla;
public class ProgDupla {
ListaDupla dupla = new ListaDupla();
char ch = 'T', op;
int valor, posicao;
do {
dupla.exibeDescritor();
dupla.exibirDireita();
dupla.exibirEsquerda();
do {
op = s.charAt(0);
System.exit(0);
}
if (strChr("IiEeCc", op)) {
do {
System.out.print("[E]squerda, [D]ireita ou [P]osio: ");
ch = s.charAt(0);
} while (!strChr("DdEePp", ch));
}
switch (op) {
case 'I':
case 'i':
switch (ch) {
case 'D':
case 'd':
dupla.incluirDireita(valor);
break;
case 'E':
case 'e':
dupla.incluirEsquerda(valor);
break;
case 'P':
case 'p':
dupla.incluirPosicao(valor, posicao);
break;
}
break;
case 'E':
case 'e':
switch (ch) {
case 'D':
209
case 'd':
valor = dupla.excluirDireita();
if (valor != -999) {
System.out.println("Valor Excludo Direita: " + valor);
} else {
System.out.println("ERRO: Lista vazia Direita");
}
break;
case 'E':
case 'e':
valor = dupla.excluirEsquerda();
if (valor != -999) {
} else {
}
break;
case 'P':
case 'p':
valor = dupla.excluirPosicao(posicao);
if (valor != -999) {
System.out.println("Valor Excludo na Posio: " + valor);
} else {
System.out.println("ERRO: Lista vazia na Posio");
}
break;
}
break;
case 'P':
case 'p':
int valorPesquisar = Integer.parseInt(s);
posicao = dupla.pesquisar(valorPesquisar);
} else {
}
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':
210
case 'e':
valor = dupla.consultarEsquerda();
if (valor != -999) {
} else {
}
break;
case 'P':
case 'p':
valor = dupla.consultarPosicao(posicao);
if (valor != -999) {
System.out.println("Valor Consultado na Posio: " + valor);
} else {
System.out.println("ERRO: Lista vazia na Posio");
}
break;
}
break;
}
}
int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
}
Descritor: | null | 0 | null |
Lista pela Direita: [Vazia]
Lista pela Esquerda: [Vazia]
[E]squerda, [D]ireita ou [P]osio: e <enter>
Valor: 10 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 1 | progdupla.Nodo@3ed8d90c |
Lista pela Direita: [10]
Lista pela Esquerda: [10]
[E]squerda, [D]ireita ou [P]osio: d <enter>
Valor: 20 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 2 | progdupla.Nodo@e91c310 |
Lista pela Direita: [20 10]
Lista pela Esquerda: [10 20]
Valor: 40 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 3 | progdupla.Nodo@39d56e9 |
Lista pela Direita: [40 20 10]
211
Lista pela Esquerda: [10 20 40]

[E]squerda, [D]ireita ou [P]osio: p <enter>
Valor: 30 <enter>
Posio: 3 <enter>
Lista pela Direita: [40 30 20 10]
Lista pela Esquerda: [10 20 30 40]
Valor Pesquisar: 30 <enter>
Valor Consultado Direita: 40
212
13. Classe entrada de inteiros e reais em Java sem erro na digitao

A
seguir,
so
vistos
dois
programas
em
Java,
cada
um
com
as
classes:
EntradaDadosScanner e EntradaDadosSwing, respectivamente, e que permitem a entrada de

dados via teclado de nmeros inteiros (leInteiro) e reais (LeReal) sem erro de converso
(Integer.parseInt e Double.parseDouble) por descuido na digitao pelo usurio, ou seja, o
usurio pode digitar qualquer coisa (em tese, por enquanto) que os mtodos da classe eliminam
os erros de digitao.
Imagine a seguinte entrada de um inteiro e de um real em um programa Java com este

tipo de digitao (em vermelho):
Digite um Inteiro: -123 de oliveira 4,.5678 <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 invlidos

para um inteiro ou para um real, inclusive pontos (.) e vrgulas (,) repetidas e o sinal negativo (-)
no local indevido.
// --------------------------------------------------------------------------------- Programa Principal: ProgEntradaDadosScanner.java
package progentradadadosscanner;
public class ProgEntradaDadosScanner {
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;
public class EntradaDadosScanner {
213
// ------------------------------------------------------ mtodos pblicos da classe

// -------------------------------------------------- leInteiro
public int leInteiro(String mensagem) {
String s;
int limite, n;
do {
s = s.replaceAll("[^0-9\\-]", ""); // eliminar letras e caracteres no numricos
n = s.length();
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);
}
}
}
int inteiro = Integer.parseInt(s); // converso segura sem erros
return (inteiro);
// ----------------------------------------------------------- leReal
public double leReal(String mensagem) {
String s;
do {
s = s.replaceAll("[^0-9\\-.,]", "");
// eliminar letras
s = verificaVirgulaPonto(s);
int n = s.length();
if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) {
s = "";
}
double real = Double.parseDouble(s);
// converso segura sem erros
return (real);
}
// ----------------------------------------------------- mtodos 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] == '.') {
214
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++) {
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 Nmeros Inteiros");
return ("");
}
return (s);
}
A seguir uma outra verso utilizando o pacote swing.

215
// -------------------------------------------------------------------------------------- Programa Principal: ProgEntradaDadosSwing.java

package progentradadadosswing;
import javax.swing.JOptionPane;
public class ProgEntradaDadosSwing {
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 {
// -------------------------------------------------- leInteiro
public int leInteiro(String mensagem) {
String s;
int n, limite;
do {
s = JOptionPane.showInputDialog(mensagem);
s = s.replaceAll("[^0-9\\-]", "");
// eliminar letras e caracteres no numricos
n = s.length();
if (!(n == 1 && s.charAt(0) == '-')) {
if (n > 0) {
if (s.charAt(0) == '-') {
limite = 11;
} else {
limite = 10;
}
if (n >= limite) {
s = verificaLimites(s);
}
}
} else {
s = "";
}
int inteiro = Integer.parseInt(s);
return (inteiro);
}
// ----------------------------------------------------------- leReal
public double leReal(String mensagem) {
216
String s;
do {
s = JOptionPane.showInputDialog(mensagem);
s = s.replaceAll("[^0-9\\-.,]", "");
// eliminar letras digitadas incorretamente e que no
s = verificaVirgulaPonto(s);
// podem ser convertidas para double
int n = s.length();
if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) {
s = "";
}
double real = Double.parseDouble(s);
return (real);
// --------------------------------------------------------------------- mtodos 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++) {
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) {
217
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 Nmeros Inteiros");
return ("");
}
return (s);
}
218
14. Alguns programas exemplos em Java

A seguir so vistos quatro (4) exemplos da utilizao das classes existentes do Java vistas
no decorrer do livro.
14.1 Torre de Hanoi (Pilha - Stack)

A seguir visto a implementao de uma Torre de Hanoi (Figura 17) em Java usando a
classe Stack (Pilha).
Figura 17: Jogo Torre de Hanoi

Regras do Jogo:
a) No se pode colocar um disco grande sobre um disco pequeno
b) Ganha quando trocar todos os trs discos de uma torre para outra
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgTorre.java
package progtorre;
219
public class ProgTorre {
String s;
int in, out;
Stack p1 = 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: ");
in = Integer.parseInt(s);
if (in == 0) {
System.exit(0);
}
} while (in < 1 || in > 3);
do {
System.out.print("Para: ");
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);
}
if (ganhou) {
System.exit(0);
}
if (ganhou) {
System.exit(0);
}
}
220
} 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);
}
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;
break;
break;
}
switch (out) {
case 1: if (p1.empty()) {
return(true);
}
else {
nodo = p1.peek();
b = nodo.hashCode();
}
break;
return(true);
}
else {
nodo = p2.peek();
}
break;
return(true);
}
else {
nodo = p3.peek();
}
break;
221
}
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) {
System.out.println("Status: Impossivel mover (p1)");
}
else {
pode = true;
}
break;
}
else {
pode = true;
}
break;
}
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;
nodo = p2.pop();
}
else {
in = 0;
222
}
break;
nodo = p3.pop();
}
else {
in = 0;
}
break;
}
if (in != 0) {
switch (b) {
case 1: p1.push(in);
moveu = true;
break;
moveu = true;
break;
moveu = true;
break;
}
}
return(moveu);
}
// --------------------------------------------------------------------------------- exibePilhas
static void exibePilhas(Stack p1, Stack p2, Stack p3) {
System.out.println("p1: " + p1);
}
Observao: Substitua o mtodo exibePilhas pelo mtodo 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';
}
if (a2 != '-') {
a2 = '2';
}
if (a3 != '-') {
a3 = '3';
}
223
b1 = nodo.toString().charAt(0);
if (b1 != '-') {
b1 = '1';
}
if (b2 != '-') {
b2 = '2';
}
if (b3 != '-') {
b3 = '3';
}
c1 = nodo.toString().charAt(0);
if (c1 != '-') {
c1 = '1';
}
if (c2 != '-') {
c2 = '2';
}
if (c3 != '-') {
c3 = '3';
}
if (c3 == '-' && c2 == '-' && c1 != '-') {
c3 = c1;
c1 = '-';
}
if (c3 == '-' && c2 != '-' && c1 == '-') {
c3 = c2;
c2 = '-';
}
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 != '-') {
224
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);
%c
%c \n", a2, b2, c2);
%c
%c \n", a3, b3, c3);
System.out.printf("--------- --------- ---------\n");
System.out.printf(" p1
p2
p3\n\n");
14.2 Analisador de Expresses usando Stack

Programa abaixo implementa um Analisador de Expresses utilizando a classe Java
Stack. O programa resolve expresses do tipo: (4*(5+(4*3)/(3-1))) ou (3*(4+5))
Exemplo de entrada de dados:
Expresso: (4*(5+(4*3)/(3-1))) <enter>
// ----------------------------------------------------------------------------------------- Programa Principal: ProgAnalisaExpressao.java
package proganalisaexpressao;
public class ProgAnalisaExpressao {
Stack numeros = new Stack();
Stack operadores = new Stack();
String s;
float resp;
System.out.print("Expressao: ");
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;
225
numeros.push(t);
exibePilha(numeros);
exibePilha(operadores);
}
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);
}
}
if (operadores.empty()) {
resp = Float.parseFloat(st);
}
else {
resp = 0;
while (!operadores.empty()) {
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);
}
}
System.out.println("Resposta: " + resp);
}
else {
System.out.println("Erro: Expressao Invalida");
}
// ---------------------------------------- calculaOperacao
226
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: Diviso 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] + " ");
}
}

Expresso: (4*(5+(4*3)/(3-1))) <enter>
Pilha: 4
Pilha:
227
Pilha: 5 4
Pilha: *
Pilha: 4 5 4
Pilha: + *
Pilha: 3 4 5 4
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
usurio digita primeiro dois valores e depois o operador.
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 {
PolonesaReversa polonesa = new PolonesaReversa();
228
polonesa.calculaPolonesaReversa();
}
// -------------------------------------------------------------------------------------------------------- Classe: PolonesaReversa.java
package progpolonesareversa;
public class PolonesaReversa {
// --------------------------------------------------- atributos da classe
private double x, y, resp = 0;
private char op;
private int erro;
public PolonesaReversa () { // construtor
erro = 0;
}
public void calculaPolonesaReversa() {
String s;
System.out.println("Polonesa Reversa: <enter> abandonar");

do {
if (resp == 0) {
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;
}
if (s.equals("")) {
System.exit(0);
}
s = s.replaceAll("[^0-9\\-.]", "");
// elimina letras digitadas incorretamente
y = Double.parseDouble(s);
do {
if (s.equals("")) {
System.exit(0);
}
op = s.charAt(0);
} while (!strChr("+-*/Pp", op));
operaCalculadora();
exibeCalculadora();
} while (!s.equals(""));
229
// ---------------------------------------------------- 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;
// diviso por zero
else
resp = divisao(x, y);
break;
case 'P':
case 'p': resp = power(x, y); // potncia
break;
}
}
// ---------------------------------------------------- exibeCalculadora
private void exibeCalculadora() {
switch (erro) {
case 1: System.out.println("Erro: Diviso por Zero");
break;
case 2: System.out.println("Erro: Raiz Complexa");
break;
case 3: System.out.println("Erro: Tangente Invlida");
break;
default: System.out.println(resp);
}
}
// ................................................ mtodos privados da classe
// ---------------------------- strChr
private boolean strChr(String s, char ch) {
for (int i = 0; i < s.length(); i++) {

return(true);
}
}
return(false);
// ------------------------------------------------------------ soma
private double soma(double x, double y) {
return(x + y);
}
// ----------------------------------------------------------------- subtrao
private double subtracao(double x, double y) {
return(x - y);
}
// ------------------------------------------------------------------------- multiplicao
private double multiplicacao(double x, double y) {
230
return(x * y);
}
// -------------------------------------------------------------- diviso
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-Cabeas

A seguir visto a implementao de um jogo chamado Quebra-Cabeas (Figura 18),
cujo objetivo colocar os nmeros de 1 8 em ordem crescente, conforme exemplo abaixo:
Figura 18: Jogo Quebra-Cabeas

// ------------------------------------------------------------------------------------------------ Programa Principal: ProgQuebraCabeca.java
package progquebracabeca;
public class ProgQuebraCabeca {
Tabuleiro tabuleiro = new Tabuleiro();
tabuleiro.sorteiaNumeros();
tabuleiro.exibeTabuleiro();
tabuleiro.jogadasJogador();
}
// ---------------------------------------------------------------------------------------------------------------------- Classe: Tabuleiro.java

package progcabeca;
231
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;
}
}
}
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 Invlido");
}
if (verificaVitoria()) {
System.out.println("Vitria");
System.exit(0);
}
}
// ----------------------------------------------------- jogadasJogador
public void jogadasJogador() {
char tecla;
232
do {
System.out.print("Move (" + jogadas + "): ");
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(" ");
}
}
}
}
// ----------------------------------------------- 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;
}
} 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);
233
Anexos: Soluo dos problemas propostos no Livro

Anexo 1.4 Soluo da Lista: Classes
1.4.1 ProgCirculo
// ------------------------------------------------------------------------------------------------ Classe: Circulo.java
public class Circulo {
// ---------------------------- atributos da classe
private double raio;
private double area;
// --------------------------- construtor
// ---------------------------------------------------- mtodos pblicos 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);
}
}
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgCirculo.java
public class ProgCirculo {
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;
234
public class PesoIdeal {

// ---------------------------- atributos de classe
private char sexo;
private double altura;
private double pesoIdeal;
// ----------------------------------------------------- construtor da classe
PesoIdeal(char sexo, double altura) {
this.sexo = sexo;
}
// -------------------------------------------------- mtodos pblicos da classe
public void calculaPesoIdeal() {
switch (sexo) {
case 'H':
case 'h':
pesoIdeal = 72.7 * altura - 58.0;
break;
case 'M':
case 'm':
break;
default:
}
}
public double getPesoIdeal() {
return (pesoIdeal);
}
// ------------------------ mtodos privados da classe

// ------------------------ mtodos estticos da classe
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgPeso.java

package progpeso;
public class ProgPeso {
PesoIdeal piHomem = new PesoIdeal('H', 1.67);
PesoIdeal piMulher = new PesoIdeal('m', 1.65);
// sexo, altura
// 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
235
public class CPF {
// ---------------------------- atributos da classe
private String cpf;
private int digito;
// ------------------------------ construtor da classe
CPF(String cpf) {
this.cpf = cpf;
}
// ------------------------------------ mtodos pblicos da classe
public int verificaCPF() {
int soma = 0;
int x = 10;
int n = cpf.length();
for (int i = 0;i < n;i++) {
soma = soma + (cpf.charAt(i) - 48) * x;
// converte char para int
x--;
}
// 48 o cdigo ascii do zero
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;
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);
}
// --------------------- mtodos privados da classe
// --------------------- mtodos estticos da classe
}
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java
public class ProgValidaCPF {
String s = "123456789";
236
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
public class DiaSemana {
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;
}
//------------------------------------------------------- mtodos pblicos 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 = "tera-feira";
break;
case 2: semana = "quarta-feira";
break;
case 3: semana = "quinta-feira";
break;
case 4: semana = "sexta-feira";
break;
case 5: semana = "sbado";
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
237
public class ProgDiaSemana {

DiaSemana dia = new DiaSemana(10, 2, 1962);
dia.verificaDiaSemana();
dia.exibeDiaSemana();
}
1.4.5 ProgTestData
// ------------------------------------------------------------------------------------------------------------------------- Classe: Data.java
public class Data {
private int dia;
private int mes;
private int ano;
// ------------------------------ construtor da classe
// ---------------------------------------- mtodos pblicos da classe
public void setDia(int dia) {
if (dia >= 1 && dia <= 31) {
this.dia = dia;
} else {
this.dia = 1;
System.out.println("ERRO: Dia Invlido");
}
}
public void setMes(int mes) {
if (mes >= 1 && mes <= 12) {
this.mes = mes;
} else {
this.mes = 1;
System.out.println("ERRO: Ms Invlido");
}
}
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", "maro", "abril",
"maio", "junho", "julho", "agosto", "setembro", "outubro",
"novembro", "dezembro"};
238
System.out.printf("Data: %d de %s de %d\n", dia, nomeMes[mes - 1], ano);

}
// ------------------------------ mtodos privados da classe
// ------------------------------ mtodos estticos da classe
}
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgTestData.java
public class ProgTestData {
Data data = new Data();
data.setData(25, 8, 2014);
data.extenso();
1.4.6 ProgVetorSort
// ----------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java
// -------------------------- atributos da classe
private int[] vetor;
private int n;
// ------------------------------------------- construtor
n = 0;
}
// --------------------------------------- add
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 {
239
}
}
// ------------------------------------------------------------ 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 {
}
}
// ------------------------------------------------------------- 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 {
}
}
// --------------------------------------- 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
for (int i = 0; i < n - 1; i++) {
}
System.out.println(vetor[n - 1] + "]");
}
240
// ----------------------------------------- length
public int length() {
return (n);
}
// -------------------------------------------------- existe
public boolean existe(int valor) {
for (int i = 0; i < n; i++) {
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;
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]) {
vetor[j] = temp;
}
}
}
}
}
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java
public class ProgVetorSort {
241
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();
1.4.7 ProgPessoa
// ------------------------------------------------------------------------------------------------------------------------ Classe: Pessoa.java
package progpessoa;
import java.util.Date;
// -------------------------------- atributos da classe
private int ano;
private int idade;
private char sexo;
// ---------------------- construtor
// -------------------------------------------------------- mtodos pblicos da classe
this.nome = nome;
}
this.ano = ano;
}
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 pedaos
// descobre o nmero de padaos
int anoAtual = Integer.parseInt(partes[n-1]); // pega o ltimo pedao, aonde est o ano atual
242
idade = anoAtual - ano;

}
public void exibePessoa() {
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;
}
}
// ---------------------- mtodos esttivos da classe
}
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java
package progpessoa;
public class ProgPessoa {
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
import java.util.Date;
private int ano;
private int idade;
private char sexo;
243
// ---------------------- construtor
// ------------------------------------------------------ mtodos pblicos da classe
this.nome = nome;
}
this.ano = ano;
}
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();
String data = date.toString();
String [] partes = data.split(" ");
int anoAtual = Integer.parseInt(partes[n-1]);
idade = anoAtual - ano;
}
// carrega a data do sistema

// converte para String
// parte a data em pedaos
// descobre o nmero de pedaos
// pega o ltimo pedao, aonde est o ano atual
public void exibePessoa() {

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;
}
}

// -------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa2.java

public class ProgPessoa2 {
Pessoa [] pessoa = new Pessoa[3];
pessoa[0].setDados("Paulo Roberto", 1962, 'm');
244
pessoa[1].setDados("Renato Luis", 1960, 'm');

pessoa[2].setDados("Francisco Carlos", 1959, 'm');
1.4.9 ProgPessoas
// ----------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java
// ---------------------------------- atributos da classe
private String[] nome;
private int[] idade;
private int n;
// ------------------------------------------ construtor
Pessoa(int numeroPessoas) {
this.max = numeroPessoas;
nome = new String[this.max];
idade = new int[this.max];
this.n = 0;
}
// ---------------------------------------------------------------------- mtodos pblicos 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]);
}
}
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];
245
}
}
nome[i] = nome[j];
nome[j] = temp;
int t = idade[i];
idade[i] = idade[j];
idade[j] = t;
}
}
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java
public class ProgPessoas {
Pessoa pessoa = new Pessoa(7);
pessoa.insereDados("Beatriz", 11);
pessoa.insereDados("Debora", 13);
pessoa.insereDados("Ftima", 15);
pessoa.insereDados("Geni", 16);
pessoa.insereDados("Carla", 12);
pessoa.insereDados("Eva", 14);
pessoa.insereDados("Ana", 10);
pessoa.sort();
1.4.10 ProgAgenda
// ---------------------------------------------------------------------------------------------------------------------------- Classe: Agenda.java
package progagenda;
public class Agenda {
// ----------------------------- atributos da classe
private String [] nome;
private String [] fone;
private int n;
// --------------------------------------------- construtor
Agenda(int numeroPessoas) {
this.max = numeroPessoas;
nome = new String[this.max];
fone = new String[this.max];
this.n = 0;
}
// ----------------------------------------------------------------------------------------- mtodos pblicos da classe
246
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("");
}
// ----------------------------- mtodos privados da classe
// ----------------------------- mtodos estticos da classe
}
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgAgenda.java
package progagenda;
public class ProgAgenda {
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("Ftima", "9981-6789");
String fone = "99815678";
String nome = agenda.consultaNome(fone);
} else {
}
fone = "9981-0123";
nome = agenda.consultaNome(fone);
} else {
}
}
247
Anexo 2.3 Soluo da Lista: Interface e Polimorfismo

2.3.1 ProgInterface_1
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
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
public interface Passaro {
public final int numeroPatas = 2;
public abstract void exibeCores();
}
// ----------------------------------------------------------------------------------------------------------------------- Classe: Cardeal.java
public class Cardeal implements Passaro {
// ---------------------------------------- atributos da classe
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
System.out.println("Nome do Pssaro: " + nome);
System.out.println("Nmero de Patas: " + numeroPatas);
}
@Override
public void exibeCores() {
System.out.println("Cor do Topete: " + cor_topete);
System.out.println("Cor do Corpo: " + cor_corpo);
}
248
}
// -------------------------------------------------------------------------------------------------------- Classe: CardealBanhado.java
public class CardealBanhado implements Passaro {
// --------------------------------------- atributos da classe
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
System.out.println("Nome do Pssaro: " + nome);
System.out.println("Nmero de Patas: " + numeroPatas);
}
@Override
public void exibeCores() {
System.out.println("Cor do Topete: " + cor_topete);
System.out.println("Cor do Corpo: " + cor_corpo);
}
// ---------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
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
public abstract void setDados(String nome, int idade, char sexo);
public abstract String toString();
}
249
// ------------------------------------------------------------------------------------------------------------------------- Classe: Homem.java

public class Homem implements Pessoa {
private int idade;
private char sexo;
@Override
public void setDados(String nome, int idade, char sexo) {
setNome(nome);
setIdade(idade);
setSexo(sexo);
}
// ----------------------------------------- sobrecarga do mtodo 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
public class Mulher implements Pessoa {
private int idade;
private char sexo;
@Override
public void setDados(String nome, int idade, char sexo) {
setNome(nome);
setIdade(idade);
setSexo(sexo);
}
// ----------------------------------------- sobrecarga do mtodo toString
@Override
return("| Mulher: " + nome + " | Idade: " + idade + " | Sexo: FEMININO |");
}
250
private void setNome(String nome) {

this.nome = nome;
}
private void setIdade(int idade) {
this.idade = idade;
}
private void setSexo(char sexo) {

this.sexo = sexo;
}
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
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

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;
}
251
// ------------------------------- sobrecarga do mtodo toString

@Override
return("| Nome: " + nome + " | Idade: " + idade + " | Sexo: " + sexo + " |");
}
Anexo 3.4 Soluo da Lista: Herana

3.4.1 Herana (Primeiro)
// ----------------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java
package progtestapessoa;
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;
}

}
// ----------------------------------------------------------------------------------------------------------- Classe Derivada: Cliente.java

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

252
public class ProgTestaHeranca {

Cliente cliente = new Cliente("Paulo Roberto", "123.456.789-09", 1234.56);
cliente.imprimePessoa();
cliente.imprimeCliente();
}
3.4.2 Herana (Segundo)

// ---------------------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java
protected double altura;
protected char sexo;
Pessoa() {
this.altura = 0.0;
this.sexo = 'g';
}
Pessoa(double altura, char sexo) {
this.sexo = sexo;
}

System.out.println("Altura: " + altura);
System.out.println("Sexo: " + sexo);
}
// -------------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java

public class Homem extends Pessoa {
// ------------------------------------------- atributos da classe
// ---------------------------------------------------- construtor
Homem(double altura, char sexo) {
super(altura, sexo);
}
// ------------------------------------------------------------ mtodos pblicos da classe
public void calculaPesoIdealHomem() {
}
public void imprimePesoIdealHomem() {
System.out.printf("Peso Ideal (Homem): %.2f\n", pesoIdeal);
}
253

// ------------------------------- mtodos estticos da classe
}
// ------------------------------------------------------------------------------------------------------ Classe Derivada: Mulher.java
public class Mulher extends Pessoa {
// --------------------------------------- atributos da classe
// ------------------------------------------------- construtor
Mulher(double altura, char sexo) {
super(altura, sexo);
}
// ------------------------------------------------------- mtodos pblicos da classe
public void calculaPesoIdealMulher() {
}
public void imprimePesoIdealMulher() {
System.out.printf("Peso Ideal (Mulher): %.2f\n", pesoIdeal);
}
// ------------------------------- mtodos estticos da classe
}
// --------------------------------------------------------------------------------------------- Programa Principal: ProgTestaHomem.java
public class ProgTestaHomem {
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();
3.4.3 Herana (Terceiro)

// ------------------------------------------------------------------------------------------------------------------- Classe Base: Objeto.java
public class Objeto {
protected int x;
protected int y;
254
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
public class Linha extends Objeto {
Linha (int xi, int yi, int xf, int yf) {
}
public void imprimeLinha(String mensagem) {
}
}
// -------------------------------------------------------------------------------------------------- Classe Derivada: Retangulo.java
public class Retangulo extends Objeto {
Retangulo (int xi, int yi, int xf, int yf) {
p2 = new Objeto(xf, yi);
p4 = new Objeto(xi, yf);
}
public void imprimeRetangulo(String mensagem) {
255

}
// ------------------------------------------------------------------------------------------- Programa Principal: ProgTestaObjetos.java

public class ProgTestaObjetos {
Linha linha = new Linha(1, 2, 3, 4);
Retangulo retangulo = new Retangulo(1, 2, 3, 4);
linha.imprimeLinha("Linha");
retangulo.imprimeRetangulo("Retngulo");
}
Anexo 4.4 Soluo da Lista: Entrada e Sada Bufferizada

4.4.1 ProgBuffer_1
// ---------------------------------------------------------------------------------------------- Programa Principal: ProgBuffer_1.java
package progbuffer_1;
public class ProgBuffer_1 {
String[] partes = text.split(" ");
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;
256
}
}
double media = (double) soma / n;
out.write("Mdia: " + 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;
public class ProgBuffer_2 {
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();
}
}
257
Anexo 5.6.1 Soluo da Lista: Vector, ArrayList e LinkedList

5.6.1.1 ProgVector_1
// ----------------------------------------------------------------------------------------- Programa Principal: ProgVector_1.java
package progvector_1;
public class ProgVector_1 {
ArrayList letras = new ArrayList();
ArrayList inverso = new ArrayList();
char letra;
do {
System.out.print("Letra: ");
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);
}
// ---------------------------------------------------------------------------------------------------- Programa Base: ProgVector_2.java
ArrayList <Integer> idade = new ArrayList();
System.out.print("Nmero de Idades: ");
int n = Integer.parseInt(s);
int u = n - 1;
for (int i = 0; i <= u; i++) {
258
int leIdade = Integer.parseInt(s);
idade.add(leIdade);
}
char ch;
do {
int antes = 0;
System.out.print("Idade para Consulta: ");
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 {
ch = s.charAt(0);
// Sugesto do Discente: Afrnio Peres da Fonseca
// ------------------------------------------ mtodo esttico: strChr

int n = s.length();
for (int i = 0; i < n; i++) {
return(true);
}
}
return(false);
}
// ---------------------------------------------------------------------------------------------------------- Programa Base: ProgVector_3.java
ArrayList <Integer> numeros = new ArrayList();
int leNumero, valor;
do {
System.out.print("Nmero: ");
259
leNumero = Integer.parseInt(s);
if (leNumero != 0) {
numeros.add(leNumero);
}
} while (leNumero != 0);
int n = numeros.size();
int u = n 1;
do {
/*
int posicao = numeros.indexOf(valor);
if (posicao == -1) {
System.out.println("ERRO: Nmero no encontrado");
} else {
}
*/
boolean encontrou = false;
if (valor != 0) {
for (int i = 0; i <= u; i++) {
if (numeros.get(i) == valor) {
System.out.println("Posio no Vetor: " + i);
encontrou = true;
break;
}
}
if (!encontrou) {
System.out.println("Erro: Nmero no encontrado");
}
}
}
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_4.java
ArrayList <Character> conceito = new ArrayList();
char ch;
do {
System.out.print("Conceito: ");
ch = s.charAt(0);
if (!strChr("Ff", ch)) {
if (strChr("AaBbCcDdEe", ch)) {
260
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)");
// ------------------------------------------ mtodo esttico: strChr

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
// ---------------------------------------------------------------------------------------------- Programa Prinicpal: ProgVector_5.java
ArrayList nomes = new ArrayList();
String s;
char letra;
do {
nomes.add(s);
}
int n = nomes.size();
261
do {
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());
}
}
System.out.println("Nomes: " + nomes.toString());
}
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_6.java
ArrayList <String> nome = new ArrayList<>();
String s;
char ch;
do {
nome.add(s);
int idadeDigitada = Integer.parseInt(s);
idade.add(idadeDigitada);
do {
ch = s.charAt(0);
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;
262
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
int n = s.length();
for (int i = 0; i < n; i++) {
return(true);
}
}
return(false);
}
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_7.java
ArrayList nome = new ArrayList();
String s;
do {
nome.add(s);
}
Object [] vetor = nome.toArray();
Arrays.sort(vetor);
System.out.println(Arrays.toString(vetor));
}
}
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_8.java
263
int leIdade;
do {
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("Mdia: " + media);
}
}
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVector_9.java
String [] partes_1 = text.split(" ");
int n1 = partes_1.length;
for (int i = 0;i < n1;i++) {
int t = Integer.parseInt(partes_1[i]);
}
264
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();
ArrayList megaSena = new ArrayList();
int numeroPalpites;
do {
System.out.print("Nmero de Palpites para a MegaSena: ");
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());
265
megaSena.removeAll(megaSena);
}
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);
}
char opcao, lado;
Object valor;
do {
do {
System.out.print("[I]ncluir, [C]onsultar, [R]emover ou [F]im: ");
opcao = s.charAt(0);
} while (!strChr("IiCcRrFf", opcao));
if (strChr("Ff", opcao)) {
System.exit(0);
}
do {
System.out.print("[E]squerda ou [D]ireita ");
lado = s.charAt(0);
} while (!strChr("EeDd", lado));
switch (opcao) {
case 'I':
case 'i':
System.out.print("Dado: ");
int dado = Integer.parseInt(s);
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
lista.addFirst(dado);
break;
266
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 'D':
case 'd':
valor = lista.getLast();
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 {
}
break;
case 'D':
case 'd':
valor = lista.removeLast();
System.out.println("Dado Removido Direita: " + valor);
} else {
}
break;
}
break;
}
System.out.println("LinkedList: " + lista);
} while (true);

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
267
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVector_12.java
char opcao, lado;
Object valor;
int posicao;
do {
do {
System.out.print("[I]ncluir, [C]onsultar, [R]emover ou [F]im: ");
} while (!strChr("IiCcRrFf", opcao));
System.exit(0);
}
do {
System.out.print("[E]squerda, [P]osio [D]ireita: ");
lado = s.charAt(0);
} while (!strChr("EePpDd", lado));
switch (opcao) {
case 'I':
case 'i':
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
break;
case 'P':
case 'p':
lista.add(posicao, dado);
} else {
}
break;
268
case 'D':
case 'd':
break;
}
}
break;
case 'C':
case 'c':
switch (lado) {
case 'E':
case 'e':
valor = lista.getFirst();
break;
case 'P':
case 'p':
valor = lista.get(posicao);
} else {
}
break;
case 'D':
case 'd':
valor = lista.getLast();
break;
}
break;
case 'R':
case 'r':
switch (lado) {
case 'E':
case 'e':
} else {
}
break;
case 'P':
case 'p':
valor = lista.remove(posicao);
System.out.println("Dado Removido da Posio: " + valor);
} else {
}
269
break;
case 'D':
case 'd':
} else {
}
break;
}
break;
}
} while (true);
// ------------------------------------------------------- mtodo esttico

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
}
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_13.java
char opcao, lado = 'E';
Object valor;
do {
do {
System.out.print("[I]ncluir, [E]lemento, [R]emover ou [F]im: ");
} while (!strChr("IiEeRrFf", opcao));
System.exit(0);
}
if (strChr("IiRr", opcao)) {
do {
System.out.print("[E]squerda ou [D]ireita ");
270
lado = s.charAt(0);
}
switch (opcao) {
case 'I':
case 'i':
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
break;
case 'D':
case 'd':
break;
}
}
break;
case 'E':
case 'e':
System.out.print("Elemento a Pesquisar: ");
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':
} else {
}
break;
case 'D':
case 'd':
} else {
}
271
break;
}
break;
}
} while (true);
}

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_14.java
Object valor;
do {
do {
System.out.print("[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: ");
} while (!strChr("IiEeRrPpFf", opcao));
System.exit(0);
}
if (strChr("IiRr", opcao)) {
do {
lado = s.charAt(0);
}
switch (opcao) {
case 'I':
case 'i':
if (dado != 0) {
272
switch (lado) {
case 'E':
case 'e':
break;
case 'D':
case 'd':
break;
}
}
break;
case 'E':
case 'e':
System.out.print("Elemento a Pesquisar: ");
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':
} else {
}
break;
case 'D':
case 'd':
} else {
}
break;
}
break;
case 'P':
case 'p':
System.out.print("Indice: ");
indice = Integer.parseInt(s);
if (indice >= 0 && indice < lista.size()) {
valor = lista.get(indice);
273
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++) {
}
System.out.println("\nLinkedList: " + lista);
} while (true);
}
int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
}
Object valor;
do {
do {
System.out.print("[I]ncluir, [S]ort, [C]lear All ou [F]im: ");
} while (!strChr("IiSsCcFf", opcao));
System.exit(0);
}
if (strChr("Ii", opcao)) {
do {
lado = s.charAt(0);
}
274
switch (opcao) {
case 'I':
case 'i':
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
break;
case 'D':
case 'd':
break;
}
}
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.println("\nLinkedList: " + lista);
} while (true);
// ------------------------------------------------------- mtodo esttico

int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
}
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgVector_16.java
275
ArrayList<Integer> array = new ArrayList();
Integer info = 999;
do {
System.out.print("Info: ");
if (info == 999) {
array.add(Integer.parseInt(s));
info++;
} else {
info = Integer.parseInt(s);
if (info != 0) {
int posicao = verificaPosicao(array, info);
array.add(posicao, info);
} else {
System.out.println("ERRO: Informao Repetida");
}
}
}
}
System.out.println("ArrayList: " + array);
} while (info != 0);
}
// ------------------------------------------------------- mtodo esttico

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 informao repetida
return (-1);
}
if (info < array.get(i).hashCode()) {
// localiza posio da informao menor
return (i);
}
if (info > array.get(i).hashCode()) {
// localiza posio da informao maior
posicao = i + 1;
}
}
return (posicao);
}
276
Anexo 5.8.2 Soluo da Lista: Strings

5.8.2.1 ProgString_1
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgString_1.java
package progstring_1;
public class ProgString_1 {
int vogais = 0, consoantes, espacos = 0;
int maiusculas = 0, minusculas;
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 ' ' (espao 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) Mascula(s)\n", maiusculas);
minusculas = totalLetras - maiusculas - espacos;
System.out.printf("(%d) Minscula(s)\n", minusculas);
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_2.java
char digito;
do {
int contaLetras = 0;
277
String palavra = input.nextLine();

char letra = s.charAt(0);
int n = palavra.length();
for (int i = 0; i < n; i++) {
if (palavra.charAt(i) == letra) {
contaLetras++;
}
}
if (contaLetras == 0) {
System.out.println("ERRO: No existe a letra " + letra + " na palavra (" + palavra + ")");
} else {
System.out.println(contaLetras + " letra(s)");
}
do {
System.out.print("Continua [S]im ou [N]o? ");
digito = s.charAt(0);
} while ("SsNn".indexOf(digito) == -1);
} while ("Ss".indexOf(digito) != -1);
}
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgString_3.java
char antecessora = 'X', sucessora = 'Y';
int posicao = Integer.parseInt(s);
if (posicao < 0 || posicao > n) {
System.out.println("Erro: Posio Invlida");
} 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);
278
System.out.println("Letra: " + palavra.charAt(posicao));

System.out.println("Sucessora: " + sucessora);
}
}
String [] partes = nome.split(" ");
// nmero de palavras da String
int u = n - 1;
// ltimo elemento da String
for (int i = u;i >= 0;i--) {
System.out.println(partes[i]);
}
}
String[] partes = nome.split(" ");
int u = n - 1;
System.out.println(partes[u].toUpperCase());
}
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgString_6.java
279
nome = corrigeNome(nome);
System.out.println("Nome corrigido: " + nome);
String[] partes = nome.split(" ");
System.out.print(partes[n - 1] + ", " + partes[0] + " ");
for (int i = 1;i < n-1;i++) {
System.out.print(partes[i].charAt(0) + ". ");
}
}
static String corrigeNome(String nome) {
nome = nome.toLowerCase();
String temp = "";
temp = temp + Character.toUpperCase(nome.charAt(0));
for (int i = 1; i < n; i++) {
if (nome.charAt(i) == 32) {
temp = temp + " " + Character.toUpperCase(nome.charAt(i + 1));
i++;
} else {
temp = temp + nome.charAt(i);
}
}
return (temp);
}
}
System.out.print("Estado: ");
String estado = input.nextLine();
estado = converteString(estado);
System.out.println("Estado corrigido: " + estado);
String [] partes = estado.split(" ");
if (n >= 2) {
280
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);
}
}
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgString_8.java
System.out.print("Incio: ");
int inicio = Integer.parseInt(s);
if (inicio < 0) {
System.out.println("ERRO: Incio Invlido");
System.exit(0);
}
System.out.print("Fim: ");
int fim = Integer.parseInt(s);
if (fim >= n) {
System.out.println("ERRO: Fim Invlido");
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));
281
}
Anexo 6.4 Soluo da Lista: Listas Lineares

6.4.1 ProgLista_1
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_1.java
package proglista_1;
public class ProgLista_1 {
String s;
do {
} while (s.equals(""));
String [] partes = s.split(" ");
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("Pilha: " + pilha.toString());
System.out.println("Total de Letras: " + totalLetras);
// cast
6.4.2 ProgLista_2
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_2.java
282

int espacos = 0;
String s;
do {
} 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.println("Nmero de Espaos Eliminados: " + espacos);
}
6.4.3 ProgLista_3
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_3.java
String nome;
int homens = 0, mulheres = 0, indeterminados = 0;
do {
nome = input.nextLine();
int u = n - 1;
switch (nome.charAt(u)) {
case 'A':
case 'a':
pilha.push('f');
mulheres++;
break;
case 'O':
case 'o':
283
pilha.push('m');
homens++;
break;
default:
pilha.push('i');
indeterminados++;
}
}
} while (nome.compareTo("") != 0);
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
String nome;
do {
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
284

Integer valor, quantidade;
do {
if (valor != 0) {
System.out.print("Quantidade: ");
quantidade = Integer.parseInt(s);
fila.offer(valor);
fila.offer(quantidade);
}
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++;
}
System.out.println("Total de Valores Impressos: " + totalImpresso);
6.4.6 ProgLista_6
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgLista_6.java
String nome;
do {
if (!nome.equals("")) {
pilha.push(n);
}
} while (!nome.equals(""));
if (!pilha.isEmpty()) {
285
int i = 0;
int totalCaracteres = 0, totalNomes = 0;
do {
Integer tamanho = (Integer) pilha.pop();
totalCaracteres = totalCaracteres + tamanho;
totalNomes++;
System.out.println("Total de Caracteres: " + totalCaracteres + " letra(s)");
System.out.println("Total de Nomes: " + totalNomes);
}
6.4.7 ProgLista_7
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));
}
}
}
}
int n = s.length();
for (int i = 0; i < n; i++) {
return (true);
}
}
return (false);
}
}
286
6.4.8 ProgLista_8
// ------------------------------------------------------------------------------------------- Programa Principal: ProgLista_8.java
public class Lista_8 {
for (int i = 0;i < n;i++) {
}
System.out.print("Nome Invertido: ");
do {
System.out.printf("%c", letra);
}
6.4.9 ProgLista_9
for (int i = 0;i < n;i++) {
if (strChr("AaEeIiOoUu", nome.charAt(i))) {
} else {
if (nome.charAt(i) != 32) {
fila.offer(nome.charAt(i));
}
}
287
}
int consoantes = 0;
do {
fila.poll();
consoantes++;
System.out.println("Total de Consoantes: " + consoantes);
int vogais = 0;
do {
pilha.pop();
vogais++;
System.out.println("Total de Vogais: " + vogais);
System.out.println("Total de Letras: " + (consoantes + vogais));
}
int n = s.length();
for (int i = 0;i < n;i++) {
return(true);
}
}
return(false);
}
}
6.4.10 ProgLista_10
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_10.java
String [] partes = nome.split(" ");
for (int i = 0;i < n;i++) {
fila.offer(partes[i]);
pilha.push(partes[i].charAt(0));
}
}
288
6.4.11 ProgLista_11
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_11.java
int valor;
do {
if (valor != 0) {
p1.push(valor);
p2.push(valor * 2);
}
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++) {
vetor[j] = (Integer) p2.pop();
}
Arrays.sort(vetor);
System.out.print("Pilhas: ");
for (i = 0;i < n*2;i++) {
}
6.4.12 ProgLista_12
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_12.java
289
Queue f1 = new LinkedList();
Queue f2 = new LinkedList();
int maior = 0, menor = 999;
Integer valor;
do {
if (valor != 0) {
f1.offer(valor);
if (valor > maior) {
maior = valor;
}
if (valor < menor) {
menor = valor;
}
}
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
290
for (int i = 0;i < n;i++) {
pilha.push(palavra.charAt(i));
}
int totalLetras = 0;
System.out.print("Palavra Invertida: ");
do {
totalLetras++;
System.out.println("Total de Letras: " + totalLetras);
6.4.14 ProgLista_14
do {
System.out.print("Valor Inicial: ");
int valorInicial = Integer.parseInt(s);
if (valorInicial == 0) {
System.exit(0);
}
System.out.print("Valor Final: ");
int valorFinal = Integer.parseInt(s);
System.out.print("Intervalo: ");
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);
}
}
} while (true);
291
6.4.15 ProgLista_15
Integer nodo = 0;
do {
if (nodo != 0) {
pilha.push(nodo);
fila.offer(nodo * 2);
}
}
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("Nmero de Elementos da Pilha: " + pilha.size());
System.out.println("\nFila: " + fila);
System.out.println("Primeiro Elemento da Fila: " + fila.peek());
System.out.println("Nmero de Elementos da Fila: " + fila.size());
} else {
System.out.println("Pilha: " + pilha);
System.out.println("Fila: " + fila);
}
}
Anexo 7.2 Soluo da Lista: Mapas

7.2.1 ProgMap_1
// ---------------------------------------------------------------------------------------------- Programa Principal: ProgMap_1.java
package progmap_1;
import java.util.LinkedHashMap;
292

LinkedHashMap pessoa = new LinkedHashMap();
pessoa.put(2, "Carla");
pessoa.put(4, "Eva");
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 + " ");
}
}
7.2.2 ProgMap_2
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgMap_2.java
package progmap_2;
import java.util.TreeMap;
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;
293
Map<Integer, String> mapa = new HashMap<>();
mapa.put(5, "Eva");
mapa.put(1, "Ana");
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());
}
}
}
7.2.4 ProgMap_4
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap_4.java
package progmap_4;
import java.util.Hashtable;
Hashtable pessoa = new Hashtable();
pessoa.put(20, "Beatriz"); // chave, valor

pessoa.put(30, "Carla"); // chave, valor
// 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;
Map<String, String> mapa = new HashMap<>();
mapa.put("E", "Eva");
mapa.put("B", "Beatriz");
mapa.put("C", "Carla");
294
mapa.put("A", "Ana");
mapa.put("D", "Debora");
System.out.println("Nmero 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 Soluo da Lista: Arquivos (File)

8.6.1 ProgFile_1
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_1.java
package progfile_1;
public class ProgFile_1 {
String linha;
try {
long bytes;
int linhas;
int brancas;
try (FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto)) {
bytes = 0;
linhas = 0;
brancas = 0;
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");
}
}
}
295
8.6.2 ProgFile_2
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_2.java
package progfile_2;
String linha;
try {
int nl;
do {
System.out.print("Linha: ");
nl = Integer.parseInt(s);
int linhas = 0;
linhas++;
if (nl == linhas) {
System.out.println(nl + ": " + linha);
}
}
if (!encontrouLinha && nl != 0) {
}
if (nl == 0) {
arqTexto.close();
}
}
} while (nl != 0);
}
}
8.6.3 ProgFile_3
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_3.java
package progfile_3;
296
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);
arqDestino.write(linha + "\n");
} System.out.println("(" + bytes + ") Bytes copiados");
arqOrigem.close();
}
arqDestino.close();
System.out.println("Erro: Problema com o Arquivo Origem");
}
}
8.6.4 ProgFile_4
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_4.java
package progfile_4;
String linha;
System.out.print("Arquivo Origem: ");
String arquivoOrigem = input.nextLine();
System.out.print("Arquivo Destino: ");
String arquivoDestino = input.nextLine();
System.out.print("[+] Maisculo ou [-] Minsculo: ");
297
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);
if (tipo == '+') {
arqDestino.write(linha.toUpperCase() + "\n");
} else {
arqDestino.write(linha.toLowerCase() + "\n");
}
} System.out.println("(" + bytes + ") Bytes copiados");
arqOrigem.close();
}
arqDestino.close();
System.out.println("Erro: Problema com o Arquivo Origem");
}
}
8.6.5 ProgFile_5
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_5.java
package progfile_5;
String linha;
boolean existe = false;
try {
int line = 1;
if (linha.contains(palavra)) {
System.out.println(line + ": " + linha);
existe = true;
}
line++;
}
arqTexto.close();
298
if (!existe) {
System.out.println("Erro: Palavra no existe");
}
}
}
8.6.6 ProgFile_6
package progfile_6;
String linha;
try {
int nli, nlf;
System.out.print("Nmero inicial: ");
nli = Integer.parseInt(s);
System.out.print("Nmero final: ");
nlf = Integer.parseInt(s);
if (nli > nlf) {
int temp = nli;
nli = nlf;
nlf = temp;
}
int line = 1;
if (line >= nli && line <= nlf) {
System.out.println(line + ": " + linha);
}
line++;
}
arqTexto.close();
if (!encontrouLinha) {
299

}
}
}
}
8.6.7 ProgFile_7
// ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_7.java
package progfile_7;
String palavra;

try {
try (FileWriter arqTexto = new FileWriter(nomeArquivo)) {
do {
palavra = input.nextLine();
if (!"".equals(palavra)) {
arqTexto.write(palavra + "\n");
}
} while (!"".equals(palavra));
arqTexto.close();
}
}
8.6.8 ProgFile_8
package progfile_8;
300

String linha;

try {
System.out.println(linha);
}
arqTexto.close();
}
}
8.6.9 ProgFile_9
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_9.java
package progfile_9;
import java.io.RandomAccessFile;
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 incio 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);
301

destino.write(nome[i] + "\n");
}
origem.close();
}
destino.close();
System.out.println("Ok, arquivo ordenado e copiado");
}
}
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;
}
}
}
}
}
8.6.10 ProgFile_10
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_10.java
package progfile_10;
String s;
System.out.print("Nome do arquivo texto: ");
File arquivo = new File(nomeArquivo);
FileWriter file = new FileWriter(arquivo);
do {
file.write(nome);
file.write(":");
String idade = input.nextLine();
file.write(idade);
file.write(":");
file.write(sexo);
302
file.write(":");
do {
file.close();
} else {
}
}
8.6.11 ProgFile_11
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_11.java
FileReader file = new FileReader(arquivo);
// l todos os dados, ou seja, carrega toda a linha de dados
System.out.println("Buffer: " + linha);
// e joga numa String
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 {
}
}
303
8.6.12 ProgFile_12
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_12.java
import java.io.FileNotFoundException;
public static void main(String[] args) throws FileNotFoundException, IOException {

int homens, mulheres;
// l todos os dados da linha do arquivo texto e joga numa String
System.out.println("Buffer: " + linha);
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 {
mulheres++;
}
}
}
buffer.close();
in.close();
conversor.close();
System.out.println("(" + homens + ") Homens");
System.out.println("(" + mulheres + ") Mulheres");
} else {
}
}
304

Algoritmos e Programação em Java

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algoritmos e Programação em Java

Uploaded by

Copyright:

Available Formats

Algoritmos e Programao

facebook: Paulo Roberto Gomes Luzzardi

Pelotas, sexta-feira, 25 de setembro de 2015 (10:15:20 am)

8.1 Mtodos para manipular arquivos em Java ................................................................................. 151

Anexo 4.4 Soluo da Lista: Entrada e Sada Bufferizada ................................................................ 256

7.2.2 ProgMap_2 .................................................................................................................................. 293

Mensagens: So as chamadas dos mtodos.

Considere a seguinte estrutura de dados da Figura 1, onde h um vetor de max

Figura 1: Estrutura de dados da classe Vetor

// nmero de elementos no vetor

// -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java

// apaga o ltimo espao em branco e a ltima vrgula

// 5 o nmero de elementos no vetor esttico da classe

Tente implementar os seguintes mtodos para a classe Vetor:

int pri = vetor.primeiro();

Exemplo de classe (Lista) aonde os elementos so inseridos a partir da posio zero

// -------------------------------------------------------- mtodo esttico

public void sort() {

Exemplo de classe (Lista) aonde os elementos so inseridos a partir da metade do vetor,

final int POSICAO = -4;

} // -------------------------------------------------------- mtodo esttico

static void ImprimeErro(int erro) {

private final int max;

public int removeListaDireita() {

public int numeroElementosLista() {

private boolean centralizaLista() {

Lista: (5 | 6) 0 0 0 0 0 100 200 0 0 0 0

Lista: (3) 100 200 300

Uma linguagem de programao orientada objetos pode suportar e/ou implementar

Polimorfismo (grego: muitas formas)

polimorfismo utilizada principalmente em sobrecarga de mtodos e operadores e classes

Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes

Sobrecarga de Mtodo: Permite que um mtodo retorne diferentes tipos de

Classes abstratas e concretas: Permite representar entidades e conceitos abstratos,

objetos de classes diferentes). Cada associao pode possuir caractersticas de (a)

1.2 Sobrecarga de Mtodos

static void imprime(Character ch) {

public class ProgPolimorfismo {

public static void pixel(char x, char y, char z) {

1.3 Referncia this

Soluo do programa proposto acima: Classe Vetor e seus mtodos.

System.out.println("Erro: Excedeu Limite do Vetor");

// 5 o nmero de elementos do vetor esttico da classe

1.4 Lista de exerccios: Classes

Peso Ideal Homem: 63,41

Clculo do Peso Ideal:

PIH = 72,7 x altura 58

PIM = 62,1 x altura 44,7

Dado o seguinte programa principal, implemente a classe CPF e seus mtodos:

// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java

int digitoVerificador = cpf.verificaCPF();

Dado o seguinte programa, implemente a classe DiaSemana e seus mtodos:

// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgDiaSemana.java

numeroDias = 22321 (para a data acima)

Onde: DIV a diviso inteira e MOD o resto inteiro da diviso

Resultado do Programa: (Sada)

Dado o seguinte programa principal, implemente a classe Data e seus mtodos:

// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestData.java

Implemente os mtodos forcaBruta e bubleSort na classe Vetor vista anteriormente

// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java

Dado o seguinte programa principal, implemente a classe Pessoa e seus mtodos.

// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java