Você está na página 1de 304

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;
private final int[] vetor;
private final int max;
// ----------------------------------------- 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");
}
Resultado do Programa:
Vetor: [10, 20, 30, 40, 50]
Erro: Excedeu Limite do Vetor
Vetor: [10, 20, 30, 40, 50]
Total de Elementos: 5
Valor Excludo: 50
Vetor: [10, 20, 30, 40]
Total de Elementos: 4
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 {
public static void main(String[] args) {
final int SUCESSO = 0;
final int CHEIA = -1;
final int VAZIA = -2;
final int EXCEDEU = -3;
final int POSICAO = - 4;
final int VALOR = -5;
Scanner input = new Scanner(System.in);
Lista lista = new Lista(7);
String s;
char op;
do {
do {
int[] valores = lista.exibeLista();
int n = lista.numeroElementosLista();
exibeLista(n, valores);
do {
System.out.print("[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: ");
s = input.nextLine();
} while (s.isEmpty());

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: ");
s = input.nextLine();
Integer valor = Integer.parseInt(s);
int erro = lista.insereLista(valor);
ImprimeErro(erro);
break;
case 'R':
case 'r':
erro = lista.removeLista();
if (erro != 0) {
System.out.println("Valor Removido: " + erro);
} else {
ImprimeErro(VAZIA);
}
break;
case 'A':
case 'a':
lista.removeallLista();
break;
case 'O':
case 'o':
System.out.print("Valor: ");
s = input.nextLine();
valor = Integer.parseInt(s);
int posicao = lista.procuraLista(valor);
if (posicao != -5) {
System.out.println("Posio: " + posicao);
} else {
ImprimeErro(POSICAO);
}
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
valor = lista.pesquisaLista(posicao);
if (valor != -4) {
System.out.println("Valor Pesquisado: " + valor);
} else {
ImprimeErro(VALOR);
}
break;
case 'S':
case 's':
lista.sort();
break;
case 'V':
case 'v':
lista.inverteLista();
break;

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;
private final int[] vetor;
private final int max;
// ----------------------- 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);
}
}
Resultado do Programa:
Lista: Vazia
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
Valor: 100 <enter>
Okay, operao realizada com sucesso
Lista: (1) 100
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
Valor: 200 <enter>
Okay, operao realizada com sucesso
Lista: (2) 100 200
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
Valor: 300 <enter>
Okay, operao realizada com sucesso
Lista: (3) 100 200 300
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit:

Exemplo de classe (Lista) aonde os elementos 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;
import java.util.Scanner;
public class TestaListaMetade {
public static void main(String[] args) {
final int SUCESSO = 0;
final int CHEIA = -1;
final int VAZIA = -2;
final int EXCEDEU = -3;

14

final int POSICAO = -4;


final int VALOR = -5;
Scanner input = new Scanner(System.in);
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: ");
s = input.nextLine();
} while (s.isEmpty());
op = s.charAt(0);
if (op == 'Q' || op == 'q') {
System.exit(1);
}
if ("IiRr".contains(s)) {
do {
System.out.print("[E]squerda ou [D]ireita: ");
r = input.nextLine();
ch = r.charAt(0);
} while (!"EeDd".contains(r));
}
} while (!"IiRrAaPpOoSsVv".contains(s));
//} while (!"IRAPOSV".equalsIgnoreCase(s));
switch (op) {
case 'I':
case 'i':
System.out.print("Valor: ");
s = input.nextLine();
Integer valor = Integer.parseInt(s);
switch (ch) {
case 'E':
case 'e':
lista.insereListaEsquerda(valor);
break;
case 'D':
case 'd':
lista.insereListaDireita(valor);
break;
}
break;
case 'R':
case 'r':
switch (ch) {
case 'E':
case 'e':
valor = lista.removeListaEsquerda();
if (valor != VAZIA) {
System.out.println("Valor Removido: " + valor);
} else {

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':
System.out.print("Valor: ");
s = input.nextLine();
valor = Integer.parseInt(s);
int posicao = lista.procuraLista(valor);
if (posicao != -1) {
System.out.println("Posio: " + posicao);
} else {
ImprimeErro(POSICAO);
}
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
valor = lista.pesquisaLista(posicao);
if (valor != -1) {
System.out.println("Valor Pesquisado: " + valor);
} else {
ImprimeErro(VALOR);
}
break;
case 'S':
case 's':
lista.sort();
break;
case 'V':
case 'v':
lista.inverteLista();
break;

}
} while (true);

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


static void ExibeLista(int n, int inic, int fim, int[] valores) {
System.out.print("Lista: ");
if (n == 0) {
System.out.print("Vazia");

16

} else {
System.out.print("(" + n + ") ");
for (int i = inic; i <= fim; i++) {
System.out.print(valores[i] + " ");
}
}
System.out.println("");

static void ImprimeErro(int erro) {


final String SUCESSO = "Okay, 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;
import java.util.Arrays;
public class Lista {
// ----------------------- atributos da classe
private int n = 0;
private int inic;
private int fim;
private final int[] vetor;

17

private final int max;


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

19

int i = inic;
for (int j = fim; j >= inic + (fim - inic) / 2; j--) {
int temp = vetor[i];
vetor[i] = vetor[j];
i++;
vetor[j] = temp;
}

public int numeroElementosLista() {


return (n);
}
public int inicioLista() {
return (inic);
}
public int fimLista() {
return (fim);
}

private boolean centralizaLista() {


int brancos = max - n;
int deslocamentos = brancos / 2;
if (deslocamentos < 1) {
return (false);
}
if (fim == max - 1) { // desloca para esquerda
int j = deslocamentos;
for (int i = inic; i <= fim; i++) {
vetor[j] = vetor[i];
j++;
}
inic = inic - deslocamentos - 1;
fim = inic + n - 1;
} else { // desloca para direita
deslocamentos++;
int j = fim + deslocamentos;
for (int i = fim; i >= inic; i--) {
vetor[j] = vetor[i];
j--;
}
fim = fim + deslocamentos;
inic = inic + deslocamentos;
}
return (true);
}

Resultado do Programa:

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


Lista: (2) 100 200
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
[E]squerda ou [D]ireita: d <enter>
Valor: 300 <enter>
Lista: (5 | 7) 0 0 0 0 0 100 200 300 0 0 0

20

Lista: (3) 100 200 300


[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
[E]squerda ou [D]ireita: d <enter>
Valor: 400 <enter>
Lista: (5 | 8) 0 0 0 0 0 100 200 300 400 0 0
Lista: (4) 100 200 300 400
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
[E]squerda ou [D]ireita: d <enter>
Valor: 500 <enter>
Lista: (5 | 9) 0 0 0 0 0 100 200 300 400 500 0
Lista: (5) 100 200 300 400 500
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
[E]squerda ou [D]ireita: d <enter>
Valor: 600 <enter>
Lista: (5 | 10) 0 0 0 0 0 100 200 300 400 500 600
Lista: (6) 100 200 300 400 500 600
[I]nserir, [R]emover, remove[A]ll, [P]esquisa, Pr[O]cura, [S]ort, In[v]erte ou [Q]uit: i <enter>
[E]squerda ou [D]ireita: d <enter>
Valor: 700 <enter>
Lista: (2 | 8) 0 0 100 200 300 400 500 600 700 500 600 // Note, lista centralizada
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 {
public static void main(String[] args) {
imprime("Pelotas-RS");
imprime(123.45);
imprime(123.45f);
imprime(123);
imprime('A');
}
static void imprime(String s) {
System.out.println("String: " + s);
}
static void imprime(Double d) {
System.out.println("Double: " + d);
}
static void imprime(Float f) {
System.out.println("Float: " + f);
}
static void imprime(Integer i) {
System.out.println("Inteiro: " + i);
}

static void imprime(Character ch) {


System.out.println("Caracter: " + ch);
}

Resultado do Programa:
String: Senac-RS
Double: 123.45
Float: 123.45
Inteiro: 123
Caracter: A
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java
package progpolimorfismo;

24

public class ProgPolimorfismo {


public static void main(String[] args) {
pixel(1, 2);
pixel(1, 2, 3);
pixel(1.0, 2.0, 3.0);
pixel('A', 'B', 'C');
}
public static void pixel(int x, int y) {
System.out.printf("x = %d | y = %d\n", x, y);
}
public static void pixel(int x, int y, int z) {
System.out.printf("x = %d | y = %d | z = %d\n", x, y, z);
}
public static void pixel(double x, double y, double z) {
System.out.printf("x = %.2f | y = %.2f | z = %.2f\n", x, y, z);
}

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


System.out.printf("x = %c | y = %c | z = %c\n", x, y, z);
}

Resultado do Programa:
x=1|y=2
x=1|y=2|z=3
x = 1,00 | y = 2,00 | z = 3,00
x=A|y=B|z=C

1.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 {
public static void main(String[] args) {
Data data = new Data(5, 8, 2014);

System.out.println(data);

}
Resultado do Programa:
Data: 05/08/2014

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


// -------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java
package progvetor1;
public class Vetor {
// --------------------------------------------- atributos da classe
private final int[] vetor;
private int n;
private final int max;
// ---------------------------------------------- construtor
Vetor(int numeroElementos) {
max = numeroElementos;
vetor = new int[max];
n = 0;
}
// ----------------------------------------------- add
public void add(int valor) {
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
public void exibe() {
System.out.print("Vetor: [");
for (int i = 0; i < n; i++) {
System.out.print(vetor[i] + ", ");
}
System.out.println("\b\b]");
}

27

// ------------------------------------------------------ numeroElementosVetor
public int numeroElementosVetor() {
return (n);
}
}
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor1.java
package progvetor1;
public class ProgVetor1 {
public static void main(String[] args) {
Vetor vetor = new Vetor(5);

// 5 o 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 {
System.out.println("ERRO: Vetor Vazio");
}
vetor.exibe();
System.out.println("Total de Elementos: " + vetor.length());
int primeiro = vetor.primeiro();
System.out.println("Primeiro: " + primeiro);
int ultimo = vetor.ultimo();
System.out.println("ltimo: " + ultimo);
int elemento = 20;
boolean flag = vetor.existe(elemento);
if (flag) {
System.out.println("Existe elemento: " + elemento);
} else {
System.out.println("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 {
public static void main(String[] args) {
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
Resultado do Programa:
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 {
public static void main(String[] args) {
PesoIdeal piHomem = new PesoIdeal('H', 1.67);
PesoIdeal piMulher = new PesoIdeal('m', 1.65);
piHomem.calculaPesoIdeal();
System.out.printf("Peso Ideal Homem: %.2f\n", piHomem.getPesoIdeal());

piMulher.calculaPesoIdeal();
System.out.printf("Peso Ideal Mulher: %.2f\n", piMulher.getPesoIdeal());

}
Resultado do Programa:

Peso Ideal Homem: 63,41


Peso Ideal Mulher: 57,77

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 {
public static void main(String[] args) {
String s = "123456789";
CPF cpf = new CPF(s);

int digitoVerificador = cpf.verificaCPF();


System.out.printf("Digito verificador: %02d\n", digitoVerificador);
System.out.printf("CPF: %s-%02d\n", s , digitoVerificador);

}
Resultado do Programa:
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 {
public static void main(String[] args) {
DiaSemana dia = new DiaSemana(10, 2, 1962);
dia.verificaDiaSemana();
dia.exibeDiaSemana();
}

Resultado do Programa:
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 {
public static void main(String[] args) {
Data data = new Data();
data.setData(25, 8, 2014);
data.extenso();
}

Resultado do Programa:
Data: 25 de agosto de 2014
Data
int dia, mes, ano
setData
extenso
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 {
public static void main(String[] args) {
Vetor vetor = new Vetor(5);

vetor.add(40);
vetor.add(20);
vetor.add(30);
vetor.add(50);
vetor.add(10);
vetor.exibe();
vetor.add(60);
vetor.exibe();
vetor.forcaBruta();
vetor.exibe();
vetor.bubbleSort();
vetor.exibe();
}

32

Resultado do Programa:
Vetor: [40 20 30 50 10]
ERRO: Excedeu o Limite do Vetor
Vetor: [40 20 30 50 10]
Vetor: [10 20 30 40 50]
Vetor: [10 20 30 40 50]

1.4.7

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

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


package progpessoa;
public class ProgPessoa {
public static void main(String[] args) {
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa();
Pessoa p3 = new Pessoa();
p1.setDados("Paulo Roberto", 1962, 'm');
p2.setDados("Renato Luis", 1965, 'm');
p3.setDados("Francisco Carlos", 1959, 'm');
p1.calculaIdade();
p2.calculaIdade();
p3.calculaIdade();
p1.exibePessoa();
p2.exibePessoa();
p3.exibePessoa();
}

Resultado do Programa:
Nome: Paulo Roberto
Idade: 52 ano(s)
Sexo: Masculino
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

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


33

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


package progpessoa2;
public class ProgPessoa2 {
public static void main(String[] args) {
Pessoa [] pessoa = new Pessoa[3];
pessoa[0] = new Pessoa();
pessoa[0].setDados("Paulo Roberto", 1962, 'm');
pessoa[0].calculaIdade();
pessoa[0].exibePessoa();
pessoa[1] = new Pessoa();
pessoa[1].setDados("Renato Luis", 1965, 'm');
pessoa[1].calculaIdade();
pessoa[1].exibePessoa();
pessoa[2] = new Pessoa();
pessoa[2].setDados("Francisco Carlos", 1959, 'm');
pessoa[2].calculaIdade();
pessoa[2].exibePessoa();
}

Resultado do Programa:
Nome: Paulo Roberto
Idade: 52 ano(s)
Sexo: Masculino
Nome: Renato Luis
Idade: 49 ano(s)
Sexo: Masculino
Nome: Francisco Carlos
Idade: 55 ano(s)
Sexo: Masculino
Pessoa
String nome
int ano
int idade
char sexo
setDados
calculaIdade
exibePessoa
Diagrama de classe

1.4.9

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

// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java


package progpessoas;
public class ProgPessoas {
public static void main(String[] args) {
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();
pessoa.exibeDados();
}

Resultado do Programa:
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 {
public static void main(String[] args) {
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);
if (nome.compareTo("") != 0) {
System.out.println("Nome: " + nome + " - Telefone: " + fone);
} else {
System.out.println("ERRO: Usurio no Encontrado");
}

}
Resultado do Programa:
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 {
public static void main(String[] args) {
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
public String toString() {
return("Data: " + this.dia + "/" + this.mes + "/" + this.ano);
}
}

Programa exemplo: Programa que utiliza a classe Data definida anteriormente:


// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaData.java
package progtestadata;

37

public class ProgTestaData {


public static void main(String[] args) {
Data data = new Data(16, 3, 2010);

// construtor ir receber 3 argumentos

System.out.println(data);
}

Resultado do Programa:
Data: 16/3/2010

Exemplo da definio de uma classe Calculadora:


// -------------------------------------------------------------------------------------------------------------------- Classe: Calculadora.java
package progcalculadora;
import java.util.Scanner;
public class Calculadora {
// ------------------------ atributos da classe
private double x;
private double y;
private double resultado;
private char operador;
// ------------------------ construtor
// --------------------------------------- mtodos pblicos da classe
public void entradaDados() {
Scanner input = new Scanner(System.in);
System.out.print("Digite um Valor: ");
String s = input.nextLine();
s = s.replaceAll("[^0-9\\-.]", "");
// eliminao de letras digitadas de forma indevida
x = Double.parseDouble(s);
// que no podem ser convertidas para double
do {
System.out.print("Operao [+-*/RrPpSsCcTt]: ");
s = input.nextLine();
operador = s.charAt(0);
} while (!strChr("+-*/RrPpSsCcTt", operador));
if (strChr("+-*/Pp", operador)) {
System.out.print("Digite outro Valor: ");
s = input.nextLine();
s = s.replaceAll("[^0-9\\-.]", "");
// 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() {
double rads = converteRadianos(x);
return (Math.cos(rads));
}
private double tan() {
double rads = converteRadianos(x);
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
package progcalculadora;
public class ProgCalculadora {
public static void main(String[] args) {
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;
import java.util.Scanner;
public class ProgstrChr {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String nome, s;
do {
System.out.print("Nome: ");
nome = entrada.nextLine();
int n = nome.length();
System.out.println(nome + " seu nome tem " + n + " caracteres");
do {
System.out.print("Continua [S/N]? " );
s = entrada.nextLine();
} while ("SsNn".indexOf(s) == -1);
} while ("Nn".indexOf(s) == -1);
// ou ... } while ("S".equalsIgnoreCase(s));
}

Exemplo para testar o programa:


Nome: Paulo Roberto Gomes Luzzardi <enter>
Paulo Roberto Gomes Luzzardi seu nome tem 28 caracteres
Continua [S/N]? N <enter>

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 {
public static void main(String[] args) {
Homem homem = new Homem("Paulo Roberto");
Mulher mulher = new Mulher("Adriane Maria");
homem.exibeNome();
homem.exibeSexo();
mulher.exibeNome();
mulher.exibeSexo();
}

// ------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java


package proginterface;
public interface Pessoa {
public abstract void exibeNome();
public abstract void exibeSexo();
}
// ------------------------------------------------------------------------------------------------------------------------------ Classe: Homem.java
package proginterface;
public class Homem implements Pessoa {

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


package proginterface;
public class Mulher implements Pessoa{
// ------------------------------------------------- atributos da classe
private final String nome;
private static final char sexo = 'f';
Mulher(String nome) {
this.nome = nome;
}
@Override
// mtodo exibeNome sobrecarregado
public void exibeNome() {
System.out.println("Mulher: " + nome);
}

@Override
// mtodo exibeSexo sobrecarregado
public void exibeSexo() {
System.out.println("Sexo: Feminino -> " + sexo);
}

Resultado do Programa:
Homem: Paulo Roberto
Sexo: Masculino -> m
Mulher: Adriane Maria
Sexo: Feminino -> f
// --------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPixel.java
package progpixel;
public class ProgPixel {
public static void main(String[] args) {
Pixel2D pixel2D = new Pixel2D(3, 4);
Pixel3D pixel3D = new Pixel3D(5, 6, 7);

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
public void exibe() {
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
public void exibe() {
System.out.printf("x = %d | y = %d | z = %d\n", x, y, z);
}

Resultado do Programa:
x=3|y=4
x=7|y=8
x=5|y=6|z=7
x=1|y=2|z=3

2.2 Polimorfismo
Conforme dito anteriormente, Polimorfismo, do grego: muitas formas, a capacidade
de objetos diferentes reagirem segundo a sua 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
package progpolimorfismo;

47

public class ProgPolimorfismo {


public static void main(String[] args) {
Pessoa homem = new Homem(1.64, 'm');
System.out.printf("Peso Ideal: %.2f (%s)\n", homem.calculaPesoIdeal(), homem.getSexo());
Pessoa mulher = new Mulher(1.64, 'f');
System.out.printf("Peso Ideal: %.2f (%s)\n", mulher.calculaPesoIdeal(), mulher.getSexo());
}
}
// ------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java
package progpolimorfismo;
abstract class Pessoa {
protected Double altura;
protected Character sexo;
public abstract Double calculaPesoIdeal();
public abstract String getSexo();
}
// ------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java
package progpolimorfismo;
class Homem extends Pessoa {
Homem(Double altura, Character sexo) {
this.altura = altura;
this.sexo = sexo;
}
@Override
public Double calculaPesoIdeal() {
Double pesoIdeal = 72.7 * altura - 58.0;
return (pesoIdeal);
}

@Override
public String getSexo() {
return("Masculino");
}

// ------------------------------------------------------------------------------------------------------- Classe Derivada: Mulher.java


package progpolimorfismo;
class Mulher extends Pessoa{
Mulher(Double altura, Character sexo) {
this.altura = altura;
this.sexo = sexo;
}
@Override
public Double calculaPesoIdeal() {
Double pesoIdeal = 62.1 * altura - 44.7;
return (pesoIdeal);

48

}
@Override
public String getSexo() {
return("Feminino");
}
}
Resultado do Programa:
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 {
public static void main(String[] args) {

Cardeal cardeal = new Cardeal("Cardeal", "Vermelho", "Cinza");


CardealBanhado cardealBanhado = new CardealBanhado("Cardeal Banhado", "Vermelho", "preto");

cardeal.exibeNome();
cardeal.exibeCores();
cardealBanhado.exibeNome();
cardealBanhado.exibeCores();

e a seguinte interface (Passaro):


// ---------------------------------------------------------------------------------------------------------------------------------- Interface: Passaro.java
package proginterface_1;
public interface Passaro {
public final int patas = 2;
// no pode ser private
public abstract void exibeNome();
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:
Resultado do Programa:
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
package proginterface_2;
public class ProgInterface_2 {
public static void main(String[] args) {
Homem homem = new Homem();
Mulher mulher = new Mulher();

homem.setDados("Paulo Roberto", 52, 'm');


mulher.setDados("Adriane Maria", 45, 'f');
System.out.println(homem);
System.out.println(mulher);

e a seguinte interface (Pessoa):


// ---------------------------------------------------------------------------------------------------------------------- Interface: Pessoa.java
package proginterface_2;
public interface Pessoa {
public abstract void setDados(String nome, int idade, char sexo);
public abstract String toString();
}
Resultado do Programa:
| Homem: Paulo Roberto | Idade: 52 | Sexo: MASCULINO |
| Mulher: Adriane Maria | Idade: 45 | Sexo: FEMININO |

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 {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;

objeto.setAtributos(1, 2);
resp = objeto.soma();
System.out.println("Somador (x + y + z): " + objeto.somador(resp));

}
// ---------------------------------------------------------------------------------------------------------------------------- Classe Base: Base.java
package progheranca;
public class Base {
private int x, y;

// atributos privados

public void setAtributos(int a, int b) {


x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
public int soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
}
}
// -------------------------------------------------------------------------------------------------------------------- Classe Derivada: Derivada.java
package progheranca;
public class Derivada extends Base {
private int z;

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

Resultado do Programa:
z=3
x=1
y=2
Soma (x + y): 3
Somador (x + y + z): 6

Responda: Porque o atributo z exibido primeiro?


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 {
public static void main(String[] args) {

54

Derivada objeto = new Derivada(3);


int resp;
objeto.setAtributos(1, 2);
resp = objeto.soma();
System.out.println("Somador (x + y + z): " + objeto.somador(resp));
}

// --------------------------------------------------------------------------------------------------------------------------- Classe Base: base.java


package progheranca2;
public class Base {
protected int x, y;

// atributos protegidos

public void setAtributos(int a, int b) {


x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
public int soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
}
}
// -------------------------------------------------------------------------------------------------------------------- Classe Derivada: Derivada.java
package progheranca2;
public class Derivada extends Base {
private int z;
Derivada(int x) {
z = x;
System.out.println("z = " + z);
}
public int somador(int soma) {
return(x + y + z);
}

// possvel acessar x e y pois so protegidos na classe base

}
Resultado do Programa:
z=3
x=1
y=2
Soma (x + y): 3
Somador (x + y + z): 6

O comando Super faz uma chamada formal ao construtor padro da classe-pai. A seguir,
o programa exemplo mostra a utilizao do comando Super.

55

// -------------------------------------------------------------------------------------------------------------------- Classe Derivada: Derivada.java


package progheranca3;
public class Derivada extends Base {
private int z;
Derivada(int x) {
super(10, 20);
// chamada formal ao construtor da classe pai
//super();
z = x;
System.out.println("z = " + z);
}
public int somador(int soma) {
return(x + y + z);
// 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.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
package progheranca3;
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);
}
public void setAtributos(int a, int b) {
x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
protected int soma() {
System.out.println("Soma (x + y): " + (x + y));

56

return(x + y);
}

// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgHeranca3.java


package progheranca3;
public class ProgHeranca3 {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;

objeto.setAtributos(1, 2);
resp = objeto.soma();
System.out.println("Somador (x + y + z): " + objeto.somador(resp));

}
Resultado do Programa:
x = 10 - y = 20
z=3
x=1
y=2
Soma (x + y): 3
Somador (x + y + z): 6

3.4 Lista de exerccios: Herana


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

// -------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java


package progtestaheranca;
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
package progtestaheranca;
public class Cliente extends Pessoa {
private double conta;
Cliente(String nome, String cpf, double conta) {
this.conta = conta;
}
public void imprimeCliente() {
System.out.println("Conta: " + conta);
}
}
Resultado esperado do programa:
Nome: Paulo Roberto
CPF: 123.456.789-09
Conta: 1234.56
Resultado real do programa:
Nome: xxxx
CPF: xxx.xxx.xxx-xx
Conta: 1234.56

Que 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;
public class Pessoa {
protected double altura;
protected char sexo;
Pessoa() {
this.altura = 0.0;
this.sexo = 'g';
}
Pessoa(double altura, char sexo) {
this.altura = altura;
this.sexo = sexo;
}
public void imprimePessoa() {
System.out.println("Altura: " + altura);
System.out.println("Sexo: " + sexo);
}
}
Pessoa
double altura
char sexo
imprimePessoa
Classe base (superclasse)
Homem
double pesoIdealHomem
calculaPesoIdealHomem
imprimePesoIdealHomem
Classe derivada (subclasse)
Mulher
double pesoIdealMulher
calculaPesoIdealMulher
imprimePesoIdealMulher
Classe derivada (subclasse)

// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestaHomem.java


package progtestahomem;
public class ProgTestaHomem {
public static void main(String[] args) {
Homem homem = new Homem(1.64, 'm');
Mulher mulher = new Mulher(1.59, 'f');
homem.calculaPesoIdealHomem();
homem.imprimePessoa();
homem.imprimePesoIdealHomem();
mulher.calculaPesoIdealMulher();
mulher.imprimePessoa();
mulher.imprimePesoIdealMulher();
}

59

Resultado do Programa:
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 {
public static void main(String[] args) {
Linha linha = new Linha(1, 2, 3, 4);
Retangulo retangulo = new Retangulo(1, 2, 3, 4);

linha.imprimeLinha("Linha");
retangulo.imprimeRetangulo("Retngulo");

}
// -------------------------------------------------------------------------------------------------------------------------- Classe Base: Objeto.java
package progtestaobjetos;
public class Objeto {
protected int x;
protected int y;
Objeto() {
x = 0;
y = 0;
}
Objeto(int x, int y) {
this.x = x;
this.y = y;
}

public void imprimeObjeto(String mensagem) {


System.out.println(mensagem + " -> (" + x + "," + y + ")");
}

// ----------------------------------------------------------------------------------------------------------------------- Classe Derivada: Linha.java


package progtestaobjetos;
public class Linha extends Objeto {
private final Objeto p1;

60

private final Objeto p2;


Linha (int xi, int yi, int xf, int yf) {
p1 = new Objeto(xi, yi);
p2 = new Objeto(xf, yf);
}
public void imprimeLinha(String mensagem) {
System.out.println(mensagem);
System.out.println("x: " + p1.x + " | y: " + p1.y);
p1.imprimeObjeto("p1");
System.out.println("x: " + p2.x + " | y: " + p2.y);
p2.imprimeObjeto("p2");
}
}

Implemente a classe derivada Retangulo (Figura 3) para que o programa funcione


conforme o resultado do programa abaixo:
Resultado do Programa:
Linha:
x=1-y=2
x=3-y=4
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;
import java.util.Scanner;
public class ProgScanner {
public static void main(String[] args) {
Scanner input = new Scanner (System.in);
System.out.print("Inteiro: ");
String s = input.nextLine();
Integer x = Integer.parseInt(s);
System.out.println("Valor: " + x);
}

// l uma string via teclado


// converte a String para inteiro

Exemplo para testar o programa:


Inteiro: 7 <enter>
Valor: 7

A seguir, o programa exemplo, mostra como fazer a leitura de int, float, double ou byte
via teclado.
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgEntradaDados.java
package progentradadados;
import java.util.Scanner;
public class ProgEntradaDados {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);

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);
}
}
Exemplo para testar o programa:
Digite um Inteiro: 123 <enter>
INTEIRO: 123 -> SizeOf: 4 Byte(s)
Digite um Float: 123,45 <enter>
FLOAT: 123.45 -> SizeOf: 4 Byte(s)
Digite um Double: 123,45 <enter>
DOUBLE: 123.45 -> SizeOf: 8 Byte(s)

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 {

public static void main(String[] args) {


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));
System.out.print("Nome: ");
String nome = userInput.readLine();
Integer n = nome.length();

64

System.out.println("Nome: " + nome + " tem " + nome.length() + " caracteres");


}

Resultado do Programa:
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.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class ProgBufferReader {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
String text = in.readLine();
String [] partes = text.split(" ");
int n = partes.length;
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;
import java.util.Scanner;
public class ProgPrint {
public static void main(String[] args) {
Scanner entrada = new Scanner (System.in);
String s;
int x;
System.out.print("Inteiro: ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.println("Valor: " + x);
System.out.printf("Valor: %03d\n ", x);
}
}
Entrada:

Inteiro: 16 <enter>

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 {


public static void main(String[] args) {
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;
import java.util.Scanner;
import java.util.Vector;
public class ProgVector {
public static void main(String[] args) {
Vector vetor = new Vector();
Scanner input = new Scanner(System.in);
int u = -1, nodo;
do {
u++;
System.out.print("Nodo: ");
String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
vetor.add(nodo);
// vetor.add(u, nodo); onde u o ltimo elemento
}
} while (nodo != 0);
int n = vetor.size();
for (int i = 0; i < n;i++) {
System.out.println("Elemento: " + vetor.get(i) + " ");
}
System.out.println("Nmero de Elementos: " + n);
System.out.println("Vector: " + vetor);
}

Exemplo para testar o programa:


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;
import java.util.Scanner;
import java.util.Vector;
public class ProgVector2 {
public static void main(String[] args) {
Vector vetor = new Vector();
Scanner input = new Scanner(System.in);
int nodo, pos;

do {
System.out.print("Nodo: ");
String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
System.out.print("Posio: ");
s = input.nextLine();
pos = Integer.parseInt(s);
if (pos >= 0 && pos <= vetor.size()) {
vetor.add(pos, nodo);
}
else {
System.out.println("ERRO: Posio Invlida ");
}
}
exibeVector(vetor);
} while (nodo != 0);
int n = vetor.size();
for (int i = 0; i < n;i++) {
System.out.println("Elemento: "+ vetor.get(i) + " ");
}
System.out.println("Nmero de Elementos: " + n);
System.out.println("Vector: " + vetor);

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) {
System.out.printf("%2d ", i);
}
System.out.println();
}

Exemplo para testar o programa:


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;
import java.util.LinkedList;
import java.util.Scanner;
public class ProgLinkedList {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
Scanner input = new Scanner(System.in);
int valor;
char op;
do {
exibeLista(lista);
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
do {
System.out.print("[F]irst, [L]ast ou [A]dd: ");
s = input.nextLine();
op = s.charAt(0);
} while ("FfLlAa".indexOf(op) == -1);
switch (op) {
case 'F':
case 'f': lista.addFirst(valor);

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("]");

}
Exemplo para testar o programa:
LinkedList: []
Valor: 10 <enter>
[F]irst, [L]ast ou [A]dd: f <enter>
LinkedList: [10 ]
Valor: 20 <enter>
[F]irst, [L]ast ou [A]dd: l <enter>
LinkedList: [10 20 ]
Valor: 30 <enter>
[F]irst, [L]ast ou [A]dd: a <enter>
LinkedList: [10 20 30 ]
Valor: 0 <enter>
LinkedList: [10 20 30 ]

Programa Exemplo: Mostra uma LinkedList e alguns dos seus mtodos inserindo inteiros e
ordenando-os.
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedList2.java
package proglinkedlist2;
import java.util.Arrays;
import java.util.LinkedList;
public class ProgLinkedList2 {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
lista.add(40);

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

Resultado do Programa:
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)


import java.util.Arrays;
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;
import java.util.Arrays;
public class ProgArraysTeste {
public static void main(String[] args) {
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);

}
Resultado do Programa:
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;
import java.util.Arrays;
import java.util.Scanner;
public class ProgArrays {
public static void main(String[] args) {
final int MAX = 10;
int [] vetor = new int[MAX];
Scanner input = new Scanner(System.in);
int u = -1, n = 0, valor;
do {
u++;
n++;
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
vetor[u] = valor;
}
else {
u--;
}

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

Exemplo para testar o programa:


Valor: 10 <enter>
Valor: 20 <enter>
Valor: 30 <enter>
Valor: 40 <enter>
Valor: 50 <enter>
Valor: 0 <enter>
Array: [10, 20, 30, 40, 50, 0, 0, 0, 0, 0]

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 {
public static void main(String[] args) {
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));
}
}

Resultado do Programa:
Nome: Paulo Roberto
Nome: Renato Luis
Nome: Francisco Carlos
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;
import java.util.ArrayList;
public class ProgArrayListView {
public static void main(String[] args) {
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 ...

}
Resultado do Programa:
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;
import java.util.ArrayList;
import java.util.Vector;

86

public class ProgtoArray {


public static void main(String[] args) {
ArrayList <Integer> lista = new ArrayList();
lista.add(10);
lista.add(30);
lista.add(40);
lista.add(1, 20);
System.out.println("ArrayList: " + lista);
Object [] objeto = lista.toArray();
System.out.print("Objetos: ");
for(int i = 0;i < lista.size();i++) {
System.out.print(objeto[i] + " ");
}
System.out.println();
Vector vetor = new Vector();
vetor.add('A');
vetor.add('C');
vetor.add('D');
vetor.add(1, 'B');
System.out.println("Vector: " + vetor);
Object [] objet = vetor.toArray();
System.out.print("Objetos: ");
for(int i = 0;i < vetor.size();i++) {
System.out.print(objet[i] + " ");
}
System.out.println();
}

Resultado do Programa:
ArrayList: [10, 20, 30, 40]
Objetos: 10 20 30 40
Vector: [A, B, C, D]
Objetos: A B C D

5.6.1 Lista de 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.
Exemplo para testar o programa:

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):
Exemplo para testar o programa:

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):
Exemplo para testar o programa:

Nome: Paulo <enter>


Nome: Roberto <enter>
Nome: Renato <enter>
Nome: Pedro <enter>
Nome: Fabio <enter>
Nome: <enter>
Letra: R <enter>
Nome: Roberto
Nome: Renato
Letra: P <enter>
Nome: Paulo
Nome: Pedro
Letra: T <enter>
Letra: <enter>

5.6.1.6 Escreva um programa em Java que recebe via teclado n nomes e idades,
armazenando em dois vetores (Vector ou ArrayList). A entrada dos dados termina quando o
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>
Continua [S/N]? s <enter>
Nome: Carla <enter>
Idade: 14 <enter>
Continua [S/N]? N <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: Beatriz <enter>


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]


Palpite para MegaSena [17, 39, 57, 74, 81, 98]
Palpite para MegaSena [5, 9, 15, 18, 63, 93]
Palpite para MegaSena [14, 20, 42, 48, 80, 88]

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

Exemplo para testar o programa:


[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita e <enter>
Dado: 10
LinkedList: [10]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita d <enter>
Dado: 20
LinkedList: [10, 20]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita d <enter>
Dado: 30
LinkedList: [10, 20, 30]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda ou [D]ireita e <enter>
Dado Removido esquerda: 10
LinkedList: [20, 30]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda ou [D]ireita e <enter>
Dado Removido esquerda: 20
LinkedList: [30]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda ou [D]ireita e <enter>
Dado Removido esquerda: 30
LinkedList: []
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda ou [D]ireita e <enter>
ERRO: Lista Vazia
LinkedList: []
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda ou [D]ireita d <enter>
ERRO: Lista Vazia
LinkedList: []
[I]ncluir, [C]onsultar, [R]emover ou [F]im: f <enter>

5.6.1.12 Complemente o programa anterior com a funo de Incluir, consultar e remover


em uma posio escolhida pelo usurio, ou seja, [E]squerda, [P]osio ou [D]ireita (conforme
exemplo abaixo).
Exemplo para testar o programa:
[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda, [P]osio [D]ireita: e <enter>
Dado: 10 <enter>
LinkedList: [10]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda, [P]osio [D]ireita: d <enter>
Dado: 20
LinkedList: [10, 20]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[E]squerda, [P]osio [D]ireita: d <enter>
Dado: 40
LinkedList: [10, 20, 40]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: i <enter>
[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>
[E]squerda, [P]osio [D]ireita: p <enter>
Posio: 2 <enter>
Dado Consultado: 30
LinkedList: [10, 20, 30, 40]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda, [P]osio [D]ireita: p <enter>
Posio: 3 <enter>
Dado Removido da Posio: 40
LinkedList: [10, 20, 30]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: r <enter>
[E]squerda, [P]osio [D]ireita: p <enter>
Posio: 6 <enter>
ERRO: Posio Invlida
LinkedList: [10, 20, 30]
[I]ncluir, [C]onsultar, [R]emover ou [F]im: f <enter>

5.6.1.13 Escreva um programa em Java que armazena n nmeros inteiros em uma Lista
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).
Exemplo para testar o programa:
[I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita e <enter>
Dado: 10 <enter>
LinkedList: [10]
[I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita d <enter>
Dado: 20 <enter>
LinkedList: [10, 20]
[I]ncluir, [E]lemento, [R]emover ou [F]im: i <enter>
[E]squerda ou [D]ireita d <enter>
Dado: 30 <enter>
LinkedList: [10, 20, 30]
[I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter>
Elemento a Pesquisar: 20 <enter>
Antecessor: 10
Sucessor: 30
LinkedList: [10, 20, 30]
[I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter>
Elemento a Pesquisar: 10 <enter>
ERRO: SEM ANTECESSOR
Sucessor: 20
LinkedList: [10, 20, 30]
[I]ncluir, [E]lemento, [R]emover ou [F]im: e <enter>
Elemento a Pesquisar: 30 <enter>
Antecessor: 20
ERRO: SEm SUCESSOR
LinkedList: [10, 20, 30]
[I]ncluir, [E]lemento, [R]emover ou [F]im: f <enter>

92

5.6.1.14 Escreva um programa em Java que armazena n nmeros inteiros em uma Lista
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).
Exemplo para testar o programa:
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter>
[E]squerda ou [D]ireita: e <enter>
Dado: 10 <enter>
Indices: 0
LinkedList: [10]
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>
Dado: 20 <enter>
Indices: 0 1
LinkedList: [10, 20]
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>
Dado: 30 <enter>
Indices: 0 1 2
LinkedList: [10, 20, 30]
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>
Dado: 40 <enter>
Indices: 0 1 2 3
LinkedList: [10, 20, 30, 40]
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: p <enter>
Indice: 2 <enter>
Dado Pesquisado pelo Indice: 30
Indices: 0 1 2 3
LinkedList: [10, 20, 30, 40]
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: p <enter>
Indice: 8 <enter>
ERRO: Indice Inexistente
Indices: 0 1 2 3
LinkedList: [10, 20, 30, 40]
[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: f <enter>

5.6.1.15 Escreva um programa em Java que armazena n nmeros inteiros em uma Lista
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).
Exemplo para testar o programa:
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
[E]squerda ou [D]ireita: e <enter>
Dado: 10 <enter>
Indices: 0
LinkedList: [10]
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>

93

Dado: 40 <enter>
Indices: 0 1
LinkedList: [10, 40]
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>
Dado: 50 <enter>
Indices: 0 1 2
LinkedList: [10, 40, 50]
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>
Dado: 30 <enter>
Indices: 0 1 2 3
LinkedList: [10, 40, 50, 30]
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
[E]squerda ou [D]ireita: d <enter>
Dado: 20 <enter>
Indices: 0 1 2 3 4
LinkedList: [10, 40, 50, 30, 20]
[I]ncluir, [S]ort, [C]lear All ou [F]im: i <enter>
[E]squerda ou [D]ireita: e <enter>
Dado: 60 <enter>
Indices: 0 1 2 3 4 5
LinkedList: [60, 10, 40, 50, 30, 20]
[I]ncluir, [S]ort, [C]lear All ou [F]im: s <enter>
Indices: 0 1 2 3 4 5
LinkedList: [10, 20, 30, 40, 50, 60]
[I]ncluir, [S]ort, [C]lear All ou [F]im: c <enter>
Indices:
LinkedList: []
[I]ncluir, [S]ort, [C]lear All ou [F]im: f <enter>

5.6.1.16 Escreva um programa em Java que armazena n 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).
Exemplo para testar o programa:
Info: 10 <enter>
ArrayList: [10]
Info: 30 <enter>
ArrayList: [10, 30]
Info: 40 <enter>
ArrayList: [10, 30, 40]
Info: 20 <enter>
ArrayList: [10, 20, 30, 40]
Info: 5 <enter>
ArrayList: [5, 10, 20, 30, 40]
Info: 60 <enter>
ArrayList: [5, 10, 20, 30, 40, 60]
Info: 50 <enter>
ArrayList: [5, 10, 20, 30, 40, 50, 60]
Info: 20 <enter>
ERRO: 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;
import java.util.ArrayList;
public class ProgArrayList2D {
public static void main(String[] args) {
final int numeroLinhas = 7;
final int numeroColunas = 5;
ArrayList[][] tabela = new ArrayList[numeroLinhas][numeroColunas];
int x = 10;
for (int i = 0; i < numeroLinhas; i++) {
int n = x;
for (int j = 0; j < numeroColunas; j++) {
tabela[i][j] = new ArrayList();
tabela[i][j].add(n);
n = n + 10;
}
x++;
}
for (int i = 0; i < numeroLinhas; i++) {
for (int j = 0; j < numeroColunas; j++) {
System.out.print(tabela[i][j]);
}
System.out.println();
}
}

Resultado do Programa:
[10][20][30][40][50]
[11][21][31][41][51]
[12][22][32][42][52]
[13][23][33][43][53]
[14][24][34][44][54]
[15][25][35][45][55]
[16][26][36][46][56]

Programa Exemplo: Escreva um programa em Java que l duas matrizes: A e B e gera uma
matriz C que a multiplicao da matriz A com a matriz B. Todas as matrizes devem ser
ArrayLists.
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgMultMatriz.java
package progmultmatriz;

95

import java.util.ArrayList;
import java.util.Scanner;
public class ProgMultMatriz {
public static void main(String[] args) {
int ma, na, mb, nb;
Scanner entrada = new Scanner(System.in);
String s;
System.out.print("Nmero de Linhas da Matriz A (mA): ");
s = entrada.nextLine();
ma = Integer.parseInt(s);
System.out.print("Nmero de Colunas da Matriz A(nA): ");
s = entrada.nextLine();
na = Integer.parseInt(s);
System.out.print("Nmero de Linhas da Matriz B(mB): ");
s = entrada.nextLine();
mb = Integer.parseInt(s);
System.out.print("Nmero de Colunas da Matriz B(nB): ");
s = entrada.nextLine();
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) + "]: ");
s = entrada.nextLine();
a[lin][col].add(Integer.parseInt(s));
}
}
System.out.println("Matriz B");
for (int lin = 0; lin < mb; lin++) {
for (int col = 0; col < nb; col++) {
b[lin][col] = new ArrayList();
System.out.print("B[" + (lin + 1) + ", " + (col + 1) + "]: ");
s = entrada.nextLine();
b[lin][col].add(Integer.parseInt(s));
}
}
System.out.println("Matriz C = A x B");
for (int lin = 0; lin < ma; lin++) {
for (int col = 0; col < nb; col++) {
int soma = 0;
for (int k = 0; k < na; k++) {
c[lin][col] = new ArrayList();
String A = "";

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

for (int lin = 0; lin < ma; lin++) {


for (int col = 0; col < nb; col++) {

System.out.println("C[" + (lin + 1) + ", " + (col + 1) + "]: " + c[lin][col]);

}
}

}
Exemplo para testar o programa:
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;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgArrayList2D_2 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
final int numeroLinhas = 3, numeroColunas = 4;

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;
for (int l = 0; l < numeroLinhas; l++) {
int soma = 0;
for (int c = 0; c < numeroColunas; c++) {
soma = soma + a[l][c].get(0).hashCode();
sl[k] = new ArrayList();
// instanciar cada elemento
sl[k].add(soma);
}
k++;
}
System.out.println();
for (k = 0; k < numeroLinhas; k++) {
System.out.println("sl[" + (k + 1) + "]: " + sl[k]);
}
k = 0;
for (int c = 0; c < numeroColunas; c++) {
int soma = 0;
for (int l = 0; l < numeroLinhas; l++) {
soma = soma + a[l][c].get(0).hashCode();
sc[k] = new ArrayList();
// instanciar cada elemento
sc[k].add(soma);
}
k++;
}

System.out.println();
for (k = 0; k < numeroColunas; k++) {
System.out.println("sc[" + (k + 1) + "]: " + sc[k]);
}
System.out.println();

}
Exemplo para testar o programa:
a [1,1]: 1 <enter>
a [1,2]: 2 <enter>
a [1,3]: 3 <enter>
a [1,4]: 4 <enter>
a [2,1]: 5 <enter>
a [2,2]: 6 <enter>
a [2,3]: 7 <enter>
a [2,4]: 8 <enter>
a [3,1]: 9 <enter>

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;
import java.util.ArrayList;
public class ProgArrayList2D_3 {
public static void main(String[] args) {
final int numeroLinhas = 12, numeroColunas = 13;
ArrayList<Double>[][] a = new ArrayList[numeroLinhas][numeroColunas];
double x = 1.0;
// gera matriz A
for (int l = 0; l < numeroLinhas; l++) {
for (int c = 0; c < numeroColunas; c++) {
a[l][c] = new ArrayList();
if (c == 0) {
a[l][c].add(x);
x++;
} else {
a[l][c].add(1.0);
}
}
}
// lista o ArrayList 2D (matriz a)
System.out.println("Matriz Original: ");
for (int l = 0; l < numeroLinhas; l++) {
for (int c = 0; c < numeroColunas; c++) {
System.out.printf("%4.1f ", a[l][c].get(0));
}
System.out.println();
}
ArrayList<Double>[] maior = new ArrayList[numeroLinhas];
System.out.println("\nMatriz Modificada: ");

99

// ArrayList 1D

// ArrayList 2D

for (int l = 0; l < numeroLinhas; l++) {


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

for (int l = 0; l < numeroLinhas; l++) {


System.out.printf("%4.1f -> ", maior[l].get(0));
for (int c = 0; c < numeroColunas; c++) {
System.out.printf("%.2f ", a[l][c].get(0));
}
System.out.println();
}

}
Resultado do Programa:
Matriz Original:
1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
2,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
3,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
4,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
5,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
6,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
7,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
8,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
9,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
10,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
11,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
12,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
Matriz Modificada:
1,0 -> 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00 1,00
2,0 -> 1,00 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50 0,50
3,0 -> 1,00 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33 0,33
4,0 -> 1,00 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25 0,25
5,0 -> 1,00 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20 0,20
6,0 -> 1,00 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17 0,17
7,0 -> 1,00 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14 0,14
8,0 -> 1,00 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13 0,13
9,0 -> 1,00 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11 0,11
10,0 -> 1,00 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10 0,10
11,0 -> 1,00 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09 0,09
12,0 -> 1,00 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08 0,08

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);
}
Resultado do Programa:
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.


Sintaxe: boolean equals(Object objeto);
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.
Sintaxe: int hashCode();
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.
Sintaxe: String toString();
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 {
public static void main(String[] args) {
String s = "Paulo Roberto Gomes Luzzardi";

System.out.println("Nome: " + s);


System.out.println("Nome: " + s.toUpperCase());
System.out.println("Nome: " + s.toLowerCase());

}
Resultado do Programa:
Nome: Paulo Roberto Gomes Luzzardi
Nome: PAULO ROBERTO GOMES LUZZARDI
Nome: paulo roberto gomes luzzardi

b) Exemplo do uso de length, charAt e indexOf:


// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgInverte.java
package proginverte;
import java.util.Scanner;
public class ProgInverte {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String s;
int n;
char op;
do {
System.out.print("Nome: ");
s = input.nextLine();

105

System.out.print("Invertido: ");
n = s.length();
for (int i = n-1;i >= 0;i--) {
System.out.print(s.charAt(i));
}
System.out.println();
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
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
Continua [S/N]? s <enter>
Nome: satolep <enter>
Invertido: pelotas
Continua [S/N]? N <enter>

c)

Exemplo do uso de String.format:

// --------------------------------------------------------------------------------------------------- Programa Principal: ProgStringFormat.java


package progstringformat;
public class ProgStringFormat {
public static void main(String[] args) {
float numero = 123.456789f;
String formato = String.format("%.3f", numero);
//JOptionPane.showMessageDialog(null, "numero: " + formato);
System.out.printf("Nmero: %.4f\n", numero);
System.out.println("Nmero Formatado: " + formato);
}

Resultado do Programa:
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:
Exemplo para testar o programa:

Palavra: Luzzardi <enter>


Letra: z <enter>
2 letra(s)
Continua [S]im ou [N]o? S <enter>
Palavra: Luzzardi <enter>
Letra: w <enter>
ERRO: 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:

Nome: Paulo Roberto Gomes Luzzardi <enter>

Sada:

Luzzardi
Gomes
Roberto
Paulo

5.8.2.5 Escreva um programa em Java que recebe via teclado um nome. Logo aps a entrada
do nome o programa deve imprimir (EM LETRA MAISCULA) o sobrenome da pessoa,
conforme exemplos abaixo:
Exemplo para testar o programa:

Sobrenome: LUZZARDI
Sair [S/N]? N <enter>
Nome: Renato Souza <enter>
Sobrenome: SOUZA
Sair [S/N]? s <enter>

Observao: O programa termina quando o usurio digitar S ou s na pergunta: Sair [S/N]?

107

5.8.2.6 Escreva um programa em Java que recebe via teclado um nome. Logo aps a entrada
do nome o programa deve imprimir na tela: sobrenome, primeiro nome e demais nomes
abreviados, conforme exemplos abaixo:
Exemplo para testar o programa:

Nome: Paulo Roberto Gomes Luzzardi <enter>


Autor: Luzzardi, Paulo R. G.
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:
Exemplo para testar o programa:

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:
Exemplo para testar o programa:

Palavra: universidade <enter>


Incio: 7 <enter>
Fim: 11 <enter>
String resultante: idade
Continua [S/N]? s <enter>
Palavra: eletricidade <enter>
Incio: 7 <enter>
Fim: 15 <enter>
ERRO: Fim Invlido
Continua [S/N]? N <enter>

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.
Sintaxe: boolean equals(Object objeto);
Indica se um objeto igual a outro.
Sintaxe: protected void finalize();
Chama o coletor de lixo (garbage coletor) do objeto quando o coletor de lixo determina que no h mais referncias ao
objeto.
Sintaxe: Class getClass();
Retorna a classe runtime do objeto.
Sintaxe: int hashCode();
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.
Sintaxe: String toString();
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);
}

Resultado do Programa:
Objeto: Paulo Roberto
Objeto: 48

109

// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgObjeto.java


package progobjeto;
import java.util.Stack;
public class ProgObjeto {
public static void main(String[] args) throws Exception {
Object objeto = "Paulo Roberto";
System.out.println("Objeto String: " + objeto);
objeto = 48;
System.out.println("Objeto Inteiro: " + objeto);
Stack pilha = new Stack();
pilha.push(123);
objeto = pilha.pop();
System.out.println("Objeto Pilha: " + objeto);
Integer valor = objeto.hashCode();
System.out.println("Valor: " + valor);
}
}
Resultado do Programa:
Objeto String: Paulo Roberto
Objeto Inteiro: 48
Objeto Pilha: 123
Valor: 123
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgNovoObjeto.java
package prognovoobjeto;
import java.util.Scanner;
public class ProgNovoObjeto {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String s;
int n;

System.out.print("Numero de Objetos: ");


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

110

Exemplo para testar o programa:


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.
Sintaxe: boolean remove(Object objeto);
Remove o objeto especificado do conjunto.

111

Sintaxe: void clear();


Remove todos os elementos do conjunto.
Sintaxe: Object clone();
Retorna um clone do conjunto para um determinado objeto.
Sintaxe: boolean contains (Object objeto);
Retorna true se o objeto especificado existe, caso contrrio retorna false.
Sintaxe: int size ();
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 {
public static void main(String[] args) {
LinkedHashSet<String> lista = new LinkedHashSet<>();
lista.add("Ana");
lista.add("Beatriz");
lista.add("Carla");
lista.add("Debora");
lista.add("Eva");
Iterator<String> iterator = lista.iterator();
System.out.print("LinkedHashSet: [");
while (iterator.hasNext()) {
System.out.print(iterator.next() + ", ");
}
System.out.println(\b\b]);
}
}
Resultado do Programa:
LinkedHashSet: [Ana, Beatriz, Carla, Debora, Eva]
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashSet2.java
package proglinkedhashset2;
import java.util.Iterator;
import java.util.LinkedHashSet;

112

public class ProgLinkedHashSet2 {


public static void main(String[] args) {
LinkedHashSet<Integer> lista = new LinkedHashSet<>();
lista.add(100);
lista.add(200);
lista.add(300);
lista.add(400);
lista.add(500);
int n = lista.size();
System.out.println("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("\b\b]");
System.out.println("Soma Total dos Elementos do Conjunto: " + somaTotal);
double media = (double) somaTotal / n;
System.out.println("Mdia do Conjunto: " + media);
}
}
Resultado do Programa:
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 {
public static void main(String[] args) {
Nodo <Integer> inteiro = new Nodo<>();
inteiro.add(123);
System.out.println("Inteiro: " + inteiro.get());
Nodo <Double> real = new Nodo<>();
real.add(123.45);
System.out.println("Double: " + real.get());
Nodo <String> string = new Nodo<>();
string.add("Paulo");
System.out.println("String: " + string.get());
Nodo <Character> caracter = new Nodo<>();
caracter.add('A');
System.out.println("Caracter: " + caracter.get());
Nodo <Float> numFloat = new Nodo<>();
numFloat.add(1.23f);
System.out.println("Float: " + numFloat.get());

}
Resultado do Programa:
Inteiro: 123
Double: 123.45
String: Paulo
Caracter: A
Float: 1.23
// ------------------------------------------------------------------------------------------------------------------ Classe 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 {
public static void main(String[] args) {
Pixel <Integer> pixelInt = new Pixel<>();
pixelInt.add(100, 200, 3);
System.out.println("x: " + pixelInt.getX());
System.out.println("y: " + pixelInt.getY());
System.out.println("Cor: " + pixelInt.getCor());

Pixel <Double> pixelDouble = new Pixel<>();


pixelDouble.add(50.70, 100.80, 4);
System.out.println("x: " + pixelDouble.getX());
System.out.println("y: " + pixelDouble.getY());
System.out.println("Cor: " + pixelDouble.getCor());

}
Resultado do Programa:
x: 100
y: 200
Cor: 3
x: 50.7
y: 100.8
Cor: 4

5.13 Fila 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.
Sintaxe: void clear();
Remove todos os elementos da PriorityQueue.
Sintaxe: Comparator <? super E> comparator ();
Retorna um comparador utilizado para ordenar os elementos da fila ou null se esta fila classificada de acordo com a
ordenao natural de seus elementos.
Sintaxe: boolean contains(Object objeto);
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.
Sintaxe: int size ();
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 {
public static void main(String[] args) {
PriorityQueue fila = new PriorityQueue();
// aloca 11 elementos
fila.offer(20);
fila.offer(40);
fila.offer(10);
fila.offer(30);
System.out.println("Fila: " + fila);
System.out.println("Menor Elemento Prioritrio: " + (Integer) fila.poll());
System.out.print("PriorityQueue: [");
while (!fila.isEmpty()) {
Integer nodo = (Integer) fila.poll();
System.out.print(nodo + ", ");
}
System.out.println("\b\b]");
}

// remove o menor elemento

}
Resultado do Programa:
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
public String toString() {
return("[" + nome + " tem " + idade + " anos]");
}

// ----------------------------------------------------------------------------------------------- Programa Principal: ProgPriorityQueue.java

117

package progpriorityqueue;
import java.util.PriorityQueue;
public class ProgPriorityQueue {
public static void main(String[] args) {
// ordem descendente
PriorityQueue <Pessoa> fila = new PriorityQueue<>((Pessoa p1, Pessoa p2) -> p2.idade - p1.idade);
// ordem ascendente
// PriorityQueue <Pessoa> fila = new PriorityQueue<>((Pessoa p1, Pessoa p2) -> p1.idade - p2.idade);
fila.offer(new Pessoa("Paulo Roberto", 52));
fila.offer(new Pessoa("Renato Luis", 49));
fila.offer(new Pessoa("Ana Maria", 56));
fila.offer(new Pessoa("Francisco Carlos", 54));
fila.offer(new Pessoa("Julia Helena", 55));
System.out.println("Fila Prioritria: " + fila);
while (!fila.isEmpty()) {
System.out.println(fila.poll());
}
}

Resultado do Programa:
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) {
System.out.println("]");
} else {
System.out.println("\b\b]");
}
}

// ----------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPilha.java


package progpilha;
import java.util.Scanner;
public class ProgPilha {
public static void main(String[] args) {
Pilha pilha = new Pilha(5);
Scanner entrada = new Scanner(System.in);
String s;
int nodo;

do {
pilha.exibePilha();
System.out.print("Elemento: ");
s = entrada.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0)
pilha.push(nodo);
} while (nodo != 0);
pilha.exibePilha();

}
Exemplo para testar o programa:
Pilha: []
Elemento: 10 <enter>
Pilha: [10]
Elemento: 20 <enter>
Pilha: [10, 20]
Elemento: 30 <enter>
Pilha: [10, 20, 30]
Elemento: 40 <enter>
Pilha: [10, 20, 30, 40]
Elemento: 50 <enter>
Pilha: [10, 20, 30, 40, 50]
Elemento: 60 <enter>
Erro: Pilha Cheia
Pilha: [10, 20, 30, 40, 50]
Elemento: 0
Pilha: [10, 20, 30, 40, 50]

121

Stack (Pilha)
import java.util.Stack;
A classe Stack utilizada para armazenar elementos em uma Pilha.
A seguir so descritos os principais mtodos da classe Stack.
Sintaxe: boolean isEmpty();
Testa se a pilha est vazia.
Sintaxe: Object peek();
Verifica o objeto que est no topo da pilha sem remov-lo da pilha.
Sintaxe: Object pop();
Remove o objeto do topo da pilha e retorna o valor do objeto.
Sintaxe: Object push(Object objeto);
Insere o objeto no topo da pilha.
Sintaxe: int search(Object objeto);
Retorna a 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;
import java.util.Scanner;
import java.util.Stack;
public class ProgStack2 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
int nodo, n = 0;
do {
System.out.print("Nodo: ");
String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
pilha.push(nodo);
n++;
}
} while (nodo != 0);
System.out.println("Stack: " + pilha);
String extenso = "";
while (!pilha.empty()) {
extenso = extenso + pilha.pop() + ", ";
}
if (n == 0) {
extenso = "]";

122

} else {
extenso = extenso + "\b\b]";
}
System.out.println("Pilha: [" + extenso);
}

Exemplo para testar o programa:


Nodo: 10 <enter>
Nodo: 20 <enter>
Nodo: 30 <enter>
Nodo: 40 <enter>
Nodo: 50 <enter>
Nodo: 60 <enter>
Nodo: 0 <enter>
Stack: [10, 20, 30, 40, 50, 60]
Pilha: [60, 50, 40, 30, 20, 10]

Programa Exemplo: 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;
import java.util.Scanner;
import java.util.Stack;
public class ProgStack3 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
int nodo, n = 0;
do {
System.out.print("Nodo: ");
String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
pilha.push(nodo);
n++;
}
} while (nodo != 0);
System.out.println("Stack: " + pilha);
System.out.print("Pilha: [");
while (!pilha.empty()) {
Integer info = (Integer) pilha.pop();
System.out.print(info + ", ");
}
System.out.println("\b\b]");
}

// cast para Integer

123

Exemplo para testar o programa:


Nodo: 10 <enter>
Nodo: 20 <enter>
Nodo: 30 <enter>
Nodo: 40 <enter>
Nodo: 50 <enter>
Nodo: 60 <enter>
Nodo: 0 <enter>
Stack: [10, 20, 30, 40, 50, 60]
Pilha: [60, 50, 40, 30, 20, 10]

Programa Exemplo: Uma pilha utilizando a classe Stack e alguns dos seus mtodos, permitindo
procurar um elemento na pilha e retornando sua posio. Considere que a primeira posio
zero (0).
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgStack.java
package progstack;
import java.util.Scanner;
import java.util.Stack;
public class ProgStack {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
int valor;
do {
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
pilha.push(valor);
}
} while (valor != 0);
do {
System.out.print("Procurar: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
int posicao = pilha.search(valor);
// procura elemento que contm o valor
if (posicao == -1) {
System.out.println("ERRO: Elemento no encontrado");
} else {
System.out.println("Posio: " + posicao);
}
}
} while (valor != 0);
}

124

Exemplo para testar o programa:


Valor: 10 <enter>
Valor: 20 <enter>
Valor: 30 <enter>
Valor: 40 <enter>
Valor: 50 <enter>
Valor: 0 <enter>
Procurar: 30 <enter>
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;
import java.util.Scanner;
public class ProgFila {
public static void main(String[] args) {
Fila fila = new Fila(5);
Scanner entrada = new Scanner(System.in);
int nodo, nodos = 0;

do {
System.out.print("Elemento: ");
String s = entrada.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
fila.insereFila(nodo);
nodos++;
}
} while (nodo != 0);
String extenso = "";
System.out.print("Fila: [");
nodo = fila.retiraFila();
if (nodo != 0) {
extenso = extenso + nodo + ", ";
}
while (!fila.isEmptyFila()) {
nodo = fila.retiraFila();
extenso = extenso + nodo + ", ";
}
if (nodos == 0) {
System.out.print(extenso + "]\n");
} else {
System.out.print(extenso + "\b\b]\n");
}

126

Exemplo para testar o programa:


Elemento: 10 <enter>
Elemento: 20 <enter>
Elemento: 30 <enter>
Elemento: 40 <enter>
Elemento: 50 <enter>
Elemento: 60 <enter>
Erro: Fila Cheia
Elemento: 0 <enter>
Fila: [10, 20, 30, 40, 50]

Queue (Fila)
import java.util.Queue;
A interface Queue utilizada para armazenar elementos em uma Fila.
A seguir 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;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class ProgQueue {
public static void main(String[] args) {
Queue fila = new LinkedList();
// Fila implementada como uma Lista Encadeada Simples (LinkedList)
Scanner input = new Scanner(System.in);
String extenso = "";

127

int nodo;
do {
System.out.print("Nodo: ");
String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
fila.offer(nodo);
}
} while (nodo != 0);
System.out.println("Queue: " + fila);
if (!fila.isEmpty()) {
do {
extenso = extenso + fila.poll() + ", ";
} while (!fila.isEmpty());
}
if (extenso.equals("")) {
System.out.println("Fila: []");
} else {
System.out.println("Fila: [" + extenso + "\b\b]");
}
}

Exemplo para testar o programa:


Nodo: 10 <enter>
Nodo: 20 <enter>
Nodo: 30 <enter>
Nodo: 40 <enter>
Nodo: 50 <enter>
Nodo: 0 <enter>
Queue: [10, 20, 30, 40, 50]
Fila: [10 ,20, 30, 40, 50]

Programa Exemplo: Mostra uma Fila utilizando a classe Queue e LinkedList e seus principais
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;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class ProgQueue2 {
public static void main(String[] args) {
Queue fila = new LinkedList();
// Fila implementada com uma Lista Encadeada Simples
Scanner input = new Scanner(System.in);
Integer nodo;
do {
System.out.print("Nodo: ");

128

String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
fila.offer(nodo);
}
} while (nodo != 0);
System.out.println("Queue: " + fila);
System.out.print("Fila: [");
if (!fila.isEmpty()) {
do {
nodo = (Integer) fila.poll();
System.out.print(nodo + ", ");
} while (!fila.isEmpty());
System.out.println("\b\b]");
} else {
System.out.println("]");
}

// cast para Integer

}
Exemplo para testar o programa:
Nodo: 10 <enter>
Nodo: 20 <enter>
Nodo: 30 <enter>
Nodo: 40 <enter>
Nodo: 50 <enter>
Nodo: 0 <enter>
Queue: [10, 20, 30, 40, 50]
Fila: [10 ,20, 30, 40, 50]

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 final int[] vetor;
private int inic;
private int fim;
private int n;
// --------------------------------------------------------- construtor
public Deque(int numeroElementos) {
inic = -1;
fim = 0;
n = 0;
vetor = new int[numeroElementos];
}
// ------------------------------------------------------------ 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) {
System.out.println("]");
} else {
for (int i = 0; i < n; i++) {
System.out.print(vetor[i] + ", ");
}
System.out.println("\b\b]");
}
}
}
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgDeque.java
package progdeque;
import java.util.Scanner;
public class ProgDeque {
public static void main(String[] args) {
Deque deque = new Deque(5);
Scanner input = new Scanner(System.in);
int nodo;
char op;
do {
deque.exibeDeque();
System.out.print("Elemento: ");

131

String s = input.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0) {
do {
System.out.print("[E]squerda ou [D]ireita: ");
s = input.nextLine();
op = s.charAt(0);
} while ("EeDd".indexOf(op) == -1);
if (nodo != 0) {
switch (op) {
case 'E':
case 'e':
deque.insereDequeEsquerda(nodo);
break;
case 'D':
case 'd':
deque.insereDequeDireita(nodo);
break;
}
}
}
} while (nodo != 0);
do {
int esquerda = deque.retiraDequeEsquerda();
if (esquerda == 0) {
System.out.println("Deque: Vazia esquerda");
} else {
System.out.println("Esquerda: " + esquerda);
}
int direita = deque.retiraDequeDireita();
if (esquerda == 0) {
System.out.println("Deque: Vazia direita");
} else {
System.out.println("Direita: " + direita);
}
} while (!deque.emptyDeque());
}

Exemplo para testar o programa:


Deque: []
Elemento: 10 <enter>
[E]squerda ou [D]ireita: e <enter>
Deque: [10]
Elemento: 20 <enter>
[E]squerda ou [D]ireita: d <enter>
Deque: [10, 20]
Elemento: 30 <enter>
[E]squerda ou [D]ireita: d <enter>
Deque: [10, 20, 30]
Elemento: 40 <enter>
[E]squerda ou [D]ireita: d <enter>
Deque: [10, 20, 30, 40]
Elemento: 50 <enter>
[E]squerda ou [D]ireita: d <enter>
Deque: [10, 20, 30, 40, 50]
Elemento: 60 <enter>
[E]squerda ou [D]ireita: d <enter>

132

Erro: Deque Cheia Direita


Deque: [10, 20, 30, 40, 50]
Elemento: 60 <enter>
[E]squerda ou [D]ireita: e <enter>
Erro: Deque Cheia Esquerda
Deque: [10, 20, 30, 40, 50]
Elemento: 0 <enter>
Esquerda: 10
Direita: 50
Esquerda: 20
Direita: 40
Esquerda: 30
Direita: 0

Java

possui

classes

pr-definidas

para

trabalhar

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.
Sintaxe: void clear();
Remove todos os elementos do deque.
Sintaxe: ArrayDeque<E> clone();
Retorna uma cpia do deque.
Sintaxe: boolean contains(Object objeto);
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,

Sintaxe: boolean isEmpty();


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.
Sintaxe: boolean remove(Object objeto);
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;
import java.util.Scanner;
public class ProgArrayDeque {
public static void main(String[] args) {
ArrayDeque deque = new ArrayDeque();
Scanner entrada = new Scanner(System.in);
String s;
char tecla = 'f', op = 'f';
int = 0;
Integer nodo;

// aloca com 16 elementos

do {
System.out.println("Deque: " + deque);
System.out.print("[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: ");
do {
s = entrada.nextLine();
if (!s.equals("")) {
tecla = s.charAt(0);
}
} while (!strChr("IiCcEeFf", tecla));
if (!strChr("Ff", tecla)) {
System.out.print("[E]squerda ou [D]ireita: ");
do {
s = entrada.nextLine();
if (!s.equals("")) {
op = s.charAt(0);
}
} while (!strChr("EeDd", op));
switch (tecla) {
case 'I':
case 'i': System.out.print("Nodo: ");
s = entrada.nextLine();
nodo = Integer.parseInt(s);
if (strChr("Ee", op)) {
deque.addFirst(nodo);
}

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()) {
if (strChr("Ee", op)) {
nodo = (Integer) deque.peekFirst();
}
else {
nodo = (Integer) deque.peekLast();
}
System.out.println("Consultado: " + nodo);
}
else {
System.out.println("ERRO: Deque Vazio");
}
break;
case 'E':
case 'e': if (!deque.isEmpty()) {
if (strChr("Ee", op)) {
nodo = (Integer) deque.pollFirst();
}
else {
nodo = (Integer) deque.pollLast();
}
System.out.println("Excluiu: " + nodo);
n--;
}
else {
System.out.println("ERRO: Deque Vazio");
}
break;

}
}
} while (!strChr("Ff", tecla));

// --------------------------------------------------------------- strChr
static boolean strChr(String s, char tecla) {
int n = s.length();
for (int i = 0;i < n;i++) {
if (s.charAt(i) == tecla) {
return(true);
}
}
return(false);
}

Exemplo para testar o programa:


Deque: []

136

// cast

// cast

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


[E]squerda ou [D]ireita: e <enter>
Nodo: 10 <enter>
Deque: [10]
[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i <enter>
[E]squerda ou [D]ireita: d <enter>
Nodo: 20 <enter>
Deque: [10, 20]
[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i <enter>
[E]squerda ou [D]ireita: d <enter>
Nodo: 30 <enter>
Deque: [10, 20, 30]
[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: f <enter>

6.4 Lista de 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:

Nome: paulo roberto gomes luzzardi <enter>

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: Debora <enter>


Nome: Carla <enter>
Nome: Beatriz <enter>
Nome: Paulo <enter>
Nome: Renato <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: Debora <enter>


Nome: Carla <enter>
Nome: Eva <enter>
Nome: Beatriz <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>
Quantidade: 4 <enter>
Valor: 30 <enter>
Quantidade: 2 <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:

Nome: paulo roberto gomes luzzardi <enter>

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:

Nome: paulo roberto gomes luzzardi <enter>

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:

Nome: paulo roberto gomes luzzardi <enter>

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:

Nome: Paulo Roberto Gomes Luzzardi <enter>

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.
Exemplo para testar o programa:
Valor Inicial: 10 <enter>
Valor Final: 70 <enter>
Intervalo: 10 <enter>
Fila: [10, 20, 30, 40, 50, 60, 70]
Valor Inicial: 60 <enter>
Valor Final: 20 <enter>
Intervalo: 5 <enter>
Fila: [60, 55, 50, 45, 40, 35, 30, 25, 20]
Valor Inicial: 0 <enter>

6.4.15 Escreva um programa em Java que recebe n valores inteiros via teclado. O programa
deve inserir cada inteiro em uma Pilha (Stack) e dobrar o valor e inserir em uma Fila (Queue).
Ao final, o programa deve exibir na tela todas as 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();
}
}
Resultado do Programa:
Tamanho da Hashtable: 3
Tabela Hash: {10=Ana, 20=Beatriz, 30=Carla}

Exemplos de Mapas com HashMap:


// ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgMap1.java
package progmap1;
import java.util.HashMap;
import java.util.Map;
public class ProgMap1 {

public static void main(String[] args) {


Map <Integer, String> mapa = new HashMap<>();
mapa.put(2, "Beatriz");
mapa.put(5, "Eva");
mapa.put(1, "Ana");
mapa.put(3, "Carla");
mapa.put(4, "Debora");
System.out.println("Mapa: " + mapa.toString());
}

Resultado do Programa:
Mapa: {1=Ana, 2=Beatriz, 3=Carla, 4=Debora, 5=Eva}
// ---------------------------------------------------------------------------------------------------------- Programa principal: ProgMap2.java
package progmap2;
import java.util.HashMap;
import java.util.Map;

143

public class ProgMap2 {


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

public static void main(String[] args) {


Map <String, Integer> mapa = new HashMap<>();
mapa.put("Eva", 5);
mapa.put("Beatriz", 2);
mapa.put("Carla", 3);
mapa.put("Ana", 1);
mapa.put("Debora", 4);
Set <String> keys = mapa.keySet();
// carrega as chaves
TreeSet <String> sortedkeys = new TreeSet<> (keys);
// ordena as chaves
for (String key : sortedkeys) {
// exibe as chaves em ordem
System.out.println("Chave: " + mapa.get(key) + " | Pessoa: " + key);
}
}

Resultado do Programa:
Chave: 1 | Pessoa: Ana
Chave: 2 | Pessoa: Beatriz
Chave: 3 | Pessoa: Carla
Chave: 4 | Pessoa: Debora
Chave: 5 | Pessoa: Eva
// ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap4.java
package progmap4;
import java.util.HashMap;
import java.util.Map;

144

public class ProgMap4 {

public static void main(String[] args) {


Map<Integer, String> mapa = new HashMap<>();
mapa.put(5, "Eva");
mapa.put(2, "Beatriz");
mapa.put(3, "Carla");
mapa.put(1, "Ana");
mapa.put(4, "Debora");
int n = mapa.size();
for (int i = 1; i <= n; i++) {
System.out.println("Chave: " + i + " | Pessoa: " + mapa.get(i));
}
}

Resultado do Programa:
Chave: 1 | Pessoa: Ana
Chave: 2 | Pessoa: Beatriz
Chave: 3 | Pessoa: Carla
Chave: 4 | Pessoa: Debora
Chave: 5 | Pessoa: Eva
// ----------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap5.java
package progmap_5;
import java.util.HashMap;
import java.util.Map;
public class ProgMap_5 {
public static void main(String[] args) {
Map<String, String> mapa = new HashMap<>();
mapa.put("E", "Eva");
mapa.put("B", "Beatriz");
mapa.put("C", "Carla");
mapa.put("A", "Ana");
mapa.put("D", "Debora");
System.out.println("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 + " ");
}
System.out.println();
}
}

Resultado do Programa:
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 {
public static void main(String[] args) {
TreeMap<String, Integer> alunos = new TreeMap<>();
alunos.put("Carla", 17);
alunos.put("Debora", 18);
alunos.put("Beatriz", 19);
alunos.put("Ana", 20);

// ordem ascendente

for (String key : alunos.keySet()) {


System.out.printf("%-7s -> %2d\n",key, alunos.get(key));
}
System.out.println("keySet: " + alunos.keySet());
alunos.clear();
}

Resultado do Programa:
Ana -> 20
Beatriz -> 19
Carla -> 17
Debora -> 18
keySet: [Ana, Beatriz, Carla, Debora]
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgLinkedHashMap.java
package proglinkedhashmap;
import java.util.LinkedHashMap;
public class ProgLinkedHashMap {
public static void main(String[] args) {
LinkedHashMap pessoa = new LinkedHashMap();
pessoa.put("Carla", 67.12);
pessoa.put("Debora", 70.23);
pessoa.put("Ana", 56.13);
pessoa.put("Beatriz", 57.45);
pessoa.put("Eva", 59.12);

System.out.println("Mapa: " + pessoa.toString());


for (Object key : pessoa.keySet()) {
System.out.printf("%-7s -> %.2f\n", key, pessoa.get(key));
}

146

Resultado do Programa:
Mapa: {Carla=67.12, Debora=70.23, Ana=56.13, Beatriz=57.45, Eva=59.12}
Carla -> 67,12
Debora -> 70,23
Ana -> 56,13
Beatriz -> 57,45
Eva -> 59,12

7.2 Lista de Exerccios: Mapas


7.2.1 Escreva um programa em Java que utiliza uma LinkedHashMap e tenha o seguinte
resultado:
Resultado do Programa:
Carla -> (2)
Eva -> (4)
Ana -> (0)
Beatriz -> (1)
Debora -> (3)
Mapa: Ana Beatriz Carla Debora Eva

7.2.2 Escreva um programa em Java que utiliza uma TreeMap e tenha o seguinte resultado:
Resultado do Programa:
Ana -> A
Beatriz -> B
Carla -> C
Debora -> D
keySet: [Ana, Beatriz, Carla, Debora]

7.2.3 Escreva um programa em Java que utiliza uma Map e tenha o seguinte resultado:
Resultado do Programa:
Chave: 1 | Pessoa: Ana | Bytes: 3
Chave: 2 | Pessoa: Beatriz | Bytes: 7
Chave: 3 | Pessoa: Carla | Bytes: 5
Chave: 4 | Pessoa: Debora | Bytes: 6
Chave: 5 | Pessoa: Eva | Bytes: 3

7.2.4 Escreva um programa em Java que utiliza uma HashTable e tenha o seguinte resultado:
Resultado do Programa:
Tamanho da Hashtable: 3
Chaves: [10, 20, 30]
Valor: [Ana, Beatriz, Carla]

7.2.5 Escreva um programa em Java que utiliza um Map (HashMap) e tenha o seguinte
resultado:
147

Resultado do Programa:
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.
Sintaxe: boolean equals(Object objeto);
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.
Sintaxe: int hashCode();
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.
Sintaxe: String toString();
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 {
public static void main(String[] args) {
String nomeArquivo = "/Users/pluzzardi/luzzardi.txt";
File arqTexto = new File(nomeArquivo);

if (arqTexto.exists()) {
long bytes = arqTexto.length();
System.out.println("Arquivo: " + nomeArquivo);
System.out.println("Bytes: " + bytes);
} else {
System.out.println("ERRO: Arquivo no existe");
}

}
Resultado do Programa:
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;
import java.io.File;
public class ProgListaDiretorio {
public static void main(String[] args) {
File diretorio = new File("//Users//pluzzardi");
String [] arquivos = diretorio.list();
for (String arquivo : arquivos) {
File filho = new File(diretorio, arquivo);
System.out.println(filho.getAbsolutePath());
}
}

Resultado do Programa:
/Users/pluzzardi/.bash_history
/Users/pluzzardi/.CFUserTextEncoding
/Users/pluzzardi/.config
/Users/pluzzardi/.cups
/Users/pluzzardi/.dropbox
/Users/pluzzardi/.DS_Store
/Users/pluzzardi/.gbas
/Users/pluzzardi/.local
/Users/pluzzardi/.netbeans-derby
/Users/pluzzardi/.ssh
/Users/pluzzardi/.Trash
/Users/pluzzardi/.viminfo
/Users/pluzzardi/Desktop
/Users/pluzzardi/Documents
/Users/pluzzardi/Downloads
/Users/pluzzardi/Dropbox
/Users/pluzzardi/frutas.luz
/Users/pluzzardi/Frutas.txt
/Users/pluzzardi/Leitura.zip
/Users/pluzzardi/Library
/Users/pluzzardi/luzzardi.dat
/Users/pluzzardi/Luzzardi.txt
/Users/pluzzardi/Movies
/Users/pluzzardi/Music
/Users/pluzzardi/NetBeansProjects
/Users/pluzzardi/nomes.sort
/Users/pluzzardi/nomes.txt
/Users/pluzzardi/palavras.dat
/Users/pluzzardi/pessoa.dat
/Users/pluzzardi/pessoas.dat

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;
import java.io.File;
import java.util.Scanner;
public class ProgListaDiretorioUsuario {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Pathname: ");
String nomeDiretorio = entrada.nextLine();
File diretorio = new File(nomeDiretorio);
String [] arquivos = diretorio.list();

for (int i = 0;i < arquivos.length;i++) {


File filho = new File(diretorio, arquivos[i]);
System.out.println(filho.getAbsolutePath());
}

}
Resultado do Programa:
Pathname: /Users/pluzzardi
/Users/pluzzardi/.bash_history
/Users/pluzzardi/.CFUserTextEncoding
/Users/pluzzardi/.config
/Users/pluzzardi/.cups
/Users/pluzzardi/.dropbox
/Users/pluzzardi/.DS_Store
/Users/pluzzardi/.gbas
/Users/pluzzardi/.local
/Users/pluzzardi/.netbeans-derby
/Users/pluzzardi/.ssh
/Users/pluzzardi/.Trash
/Users/pluzzardi/.viminfo
/Users/pluzzardi/Desktop
/Users/pluzzardi/Documents
/Users/pluzzardi/Downloads
/Users/pluzzardi/Dropbox
/Users/pluzzardi/frutas.luz
/Users/pluzzardi/Frutas.txt
/Users/pluzzardi/Leitura.zip
/Users/pluzzardi/Library
/Users/pluzzardi/luzzardi.dat
/Users/pluzzardi/Luzzardi.txt
/Users/pluzzardi/Movies

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.File;
import java.io.FileWriter;
import java.util.Scanner;
public class ProgCriaPalavras {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
if (!arquivo.exists()) {
// proteo para no apagar o arquivo j criado
try (FileWriter file = new FileWriter(arquivo)) {
System.out.print("Nmero de Palavras: ");
String s = entrada.nextLine();
int numPalavras = Integer.parseInt(s);
file.write((byte)numPalavras);
file.write('\n');
for (int i = 1;i <= numPalavras;i++) {
System.out.print("Palavra: ");
byte a = (byte) System.in.read();
while(a != '\n') {
file.write(a);
a = (byte) System.in.read();

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.File;
import java.io.FileReader;
public class ProgCarregaPalavras {
public static void main(String[] args) throws Exception {
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
byte a;
if (arquivo.exists()) {
try (FileReader file = new FileReader(arquivo)) {
int numPalavras = file.read();
file.read();
for (int i = 1;i <= numPalavras;i++) {
System.out.print("Palavra: ");

158

a = (byte) file.read();
while(a != '\n') {
System.out.printf("%c", a);
a = (byte) file.read();
}
System.out.println();
}

file.close();

}
else {
System.out.println("ERRO: Arquivo no existe");
}

}
Resultado do Programa:
Palavra: carambola
Palavra: beringela
Palavra: abacate
Palavra: ervilha
Palavra: damasco

Programa exemplo: Permite consultar o arquivo de palavras (palavras.dat). Para tanto


solicitado, ao 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 {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String s;
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
FileReader file = new FileReader(arquivo);
if (arquivo.exists()) {
System.out.println("Arquivo: " + arquivo);
int numPalavras = file.read();
String temp = buffer.readLine();
// descarta a primeira linha
System.out.println("Total de Palavras: " + numPalavras);
String [] linha = new String[numPalavras + 1];
for (int i = 0;i < numPalavras;i++) {
linha[i] = buffer.readLine();
}

159

buffer.close();
in.close();
file.close();
int pos;
do {
System.out.print("Posio [1.." + numPalavras + "] ou [0] Sair: ");
s = entrada.nextLine();
pos = Integer.parseInt(s);
if (pos >= 1 && pos <= numPalavras) {
System.out.println("Palavra: " + linha[pos - 1]);
}
else {
if (pos != 0) {
System.out.println("ERRO: Posio Invlida");
}
}
} while (pos != 0);
}
else {
System.out.println("ERRO: Arquivo no existe");
}
}

Resultado do Programa:
Arquivo: /Users/pluzzardi/palavras.dat
Total de Palavras: 5
Posio [1..5] ou [0] Sair: 1 <enter>
Palavra: carambola
Posio [1..5] ou [0] Sair: 2 <enter>
Palavra: beringela
Posio [1..5] ou [0] Sair: 3 <enter>
Palavra: abacate
Posio [1..5] ou [0] Sair: 4 <enter>
Palavra: ervilha
Posio [1..5] ou [0] Sair: 5 <enter>
Palavra: damasco
Posio [1..5] ou [0] Sair: 6 <enter>
ERRO: Posio Invlida
Posio [1..5] ou [0] Sair: 0 <enter>

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 {
public static void main(String[] args) {
int linhas = 0;
int max = 0;
String palavras [], linha;
String nomeArquivo = "/Users/pluzzardi/Frutas.txt";
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
max = Integer.parseInt(leitor.readLine());
palavras = new String[max];
System.out.println("Total de palavras: " + max);

int i = 0;
while ((linha = leitor.readLine()) != null) {
palavras[i] = linha;
System.out.println("Palavra: " + palavras[i]);
linhas++;
i++;
}
int n = (int) (Math.random() * max);
System.out.println("Palavra Sorteada: " + palavras[n]);
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo ");
}

}
Resultado do Programa:
Total de palavras: 15

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.*;
import java.util.Scanner;
public class ProgBytes {
public static void main(String[] args) {
int linhas = 0;
long bytes = 0;
String buffer;
Scanner input = new Scanner(System.in);
String nomeArquivo;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
int i = 0;
while ((buffer = leitor.readLine()) != null) {
bytes = bytes + buffer.length();
linhas++;
i++;
}
System.out.println(linhas + " Linha(s)");
System.out.println(bytes + " Byte(s)");
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo");
}
}

162

Resultado do Programa:
Nome do Arquivo: /Users/pluzzardi/NetBeansProjects/Bytes/src/bytes/bytes.java <enter>
37 Linha(s)
987 Byte(s)

A seguir mostrado um outro programa que l um arquivo texto exibindo:


a) Todas as linhas do arquivo texto com seu respectivo nmero;
b) Nmero de Linhas;
c)

Nmero de Bytes.

// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgListar.java


package proglistar;
import java.io.*;
import java.util.Scanner;
public class ProgListar {
public static void main(String[] args) {
int linhas = 0;
long bytes = 0;
String buffer;
Scanner input = new Scanner(System.in);
String nomeArquivo;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
int i = 0;
while ((buffer = leitor.readLine()) != null) {
bytes = bytes + buffer.length();
linhas++;
System.out.printf("%2d: %s\n", linhas, buffer);
i++;
}
System.out.println(linhas + " Linha(s)");
System.out.println(bytes + " Byte(s)");

} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo");
}

}
Resultado do Programa:
Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter>
1: 15
2: abacaxi

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.*;
import java.util.Scanner;
public class ProgLinha {
public static void main(String[] args) {
int linha = 0, numLinha;
String s, buffer;
Scanner input = new Scanner(System.in);
String nomeArquivo;
boolean listou = false;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
System.out.print("Nmero da Linha: ");
s = input.nextLine();
numLinha = Integer.parseInt(s);
int i = 0;
while ((buffer = leitor.readLine()) != null) {
linha++;
if (linha == numLinha) {
System.out.printf("%2d: %s\n", linha, buffer);
listou = true;
}
i++;
}
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo");
}
if (!listou) {

164

System.out.println("ERRO: Linha no Encontrada");


}

}
Resultado do Programa:
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;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;
public class ProgWriteDados {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String s;
String diretorio = "/Users/pluzzardi/";
File arquivo = new File(diretorio, "Pessoa.dat");
if (!arquivo.exists()) {
try (FileWriter file = new FileWriter(arquivo)) {
do {
System.out.print("Nome: ");
String nome = entrada.nextLine();
file.write(nome);
file.write(":");
System.out.print("Idade: ");
String idade = entrada.nextLine();
file.write(idade);
file.write(":");
System.out.print("Sexo [M/F]: ");
s = entrada.nextLine();
char sexo = s.charAt(0);
file.write(sexo);
file.write(":");
System.out.print("Continua [S/N]? ");
do {
s = entrada.nextLine();
} while (!"SsNn".contains(s));
} while ("S".equalsIgnoreCase(s));
file.close();
}
} else {
System.out.println("ERRO: Arquivo j existe");}
}
}

165

Exemplo para testar o programa:


Nome: Paulo Roberto <enter>
Idade: 51 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Renato Luis <enter>
Idade: 49 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Francisco Carlos <enter>
Idade: 53 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? n <enter>

O seguinte programa mostra como recarregar as trs informaes gravadas em um


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

public static void main(String[] args) throws Exception {


Scanner entrada = new Scanner(System.in);
String diretorio = "/Users/pluzzardi/";
File arquivo = new File(diretorio, "Pessoa.dat");
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
if (arquivo.exists()) {
try (FileReader file = new FileReader(arquivo)) {
String linha = buffer.readLine();
// l todos os dados
System.out.println("Linha: " + linha);
String[] partes = linha.split(":");
int n = partes.length;
System.out.println("Partes: " + n);
for (int i = 0; i < n; i = i + 3) {
System.out.println("Nome: " + partes[i]);
System.out.println("Idade: " + Integer.parseInt(partes[i + 1]));
System.out.println("Sexo: " + partes[i + 2]);
}
}
buffer.close();
} else {
System.out.println("ERRO: Arquivo j existe");
}
}

166

Resultado do Programa:
Linha: Paulo Roberto:52:m:Rento Luis:49:m:Francisco Carlos:54:m:
Partes: 9
Nome: Paulo Roberto
Idade: 52
Sexo: m
Nome: Rento Luis
Idade: 49
Sexo: m
Nome: Francisco Carlos
Idade: 54
Sexo: m

O programa a seguir mostra como anexar (append) mais informaes ao arquivo texto
(Pessoa.dat) j existente, sem sobre-escrev-lo.
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgAppendDados.java
package progappenddados;
import java.io.File;
import java.io.IOException;
import java.io.*;
import java.util.Scanner;
public class ProgAppendDados {
public static void main(String[] args) throws IOException {
Scanner entrada = new Scanner(System.in);
String s;
String diretorio = "/Users/pluzzardi/";
File arquivo = new File(diretorio, "Pessoa.dat");
if (arquivo.exists()) {
try (FileWriter file = new FileWriter(arquivo, true)) { // true indica append, ou seja, anexar no fim do arquivo
do {
// o arquivo no sobre-escrito, ou seja, ele no apagado. Os dados antigos
System.out.print("Nome: ");
// so mantidos e os novos anexados ao fim do arquivo
String nome = entrada.nextLine();
file.write(nome);
file.write(":");
System.out.print("Idade: ");
String idade = entrada.nextLine();
file.write(idade);
file.write(":");
System.out.print("Sexo [M/F]: ");
s = entrada.nextLine();
char sexo = s.charAt(0);
file.write(sexo);
file.write(":");
System.out.print("Continua [S/N]? ");
do {
s = entrada.nextLine();
} while (!"SsNn".contains(s));
} while ("S".equalsIgnoreCase(s));
}
} else {
System.out.println("ERRO: Arquivo no existe");

167

}
}
Exemplo para testar o programa:
Nome: Ana Maria <enter>
Idade: 56 <enter>
Sexo [M/F]: f <enter>
Continua [S/N]? s <enter>
Nome: Julia Helena <enter>
Idade: 55 <enter>
Sexo [M/F]: f <enter>
Continua [S/N]? n <enter>
Resultado do Programa: (ProgReadDados)
Linha: Paulo Roberto:52:m:Rento Luis:49:m:Francisco Carlos:54:m:Ana Maria:56:f:Julia Helena:55:f
Partes: 15
Nome: Paulo Roberto
Idade: 52
Sexo: m
Nome: Rento Luis
Idade: 49
Sexo: m
Nome: Francisco Carlos
Idade: 54
Sexo: m
Nome: Ana Maria
Idade: 56
Sexo: f
Nome: Julia Helena
Idade: 55
Sexo: f

8.6 Lista de 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

8.6.2 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O
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

Exemplo para testar o programa:

Nome do arquivo texto: lista.java <enter>


Nmero de linha: 7 <enter>
7: int i, j, k;
Nmero de linha: 70 <enter>
ERRO: Linha no existe
Nmero de linha: 0 <enter>
// 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

8.6.6 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O
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:

Nome do arquivo texto: lista.java <enter>


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.
Exemplo para testar o programa:
Nome do arquivo texto: nomes.txt <enter>
Nome: Beatriz <enter>
Nome: Eva <enter>
Nome: Debora <enter>
Nome: Carla <enter>
Nome: Fatima <enter>
Nome: Ana <enter>
Nome: <enter>

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.
Exemplo para testar o programa:
Nome do arquivo texto origem: nomes.txt <enter>
Nome do arquivo texto destino: nomes.srt <enter>
Ok, arquivo ordenado e copiado

Observao: Utilize o programa anterior (ler.java) para ver os nomes ordenados.


8.6.10 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O
programa deve permitir ao 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

Exemplo para testar o programa:


Nome do arquivo texto: dados.txt <enter>
Nome: Paulo Roberto <enter>
Idade: 41 <enter>
Sexo [M/F]: m <enter>
Nome: Renato Luis <enter>
Idade: 38 <enter>
Sexo [M/F]: m <enter>
Nome: Ana Maria <enter>
Idade: 44 <enter>
Sexo [M/F]: f <enter>
Nome: <enter>

8.6.11 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O
programa deve ler e imprimir na tela todos os dados (nome, idade e sexo) armazenados no
arquivo pelo programa "8.6.10" (veja exemplo abaixo).
Entrada:

Nome do arquivo texto: dados.txt <enter>

Sada:

Nome: Paulo Roberto


Idade: 41
Sexo: MASCULINO
Nome: Renato Luis
Idade: 38
Sexo: MASCULINO
Nome: Ana Maria
Idade: 44
Sexo: FEMININO

8.6.12 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O
programa deve verificar a quantidade de homens e a quantidade de mulheres no aquivo criado
pelo programa "14.6.10".
Entrada:

Nome do arquivo texto: dados.txt <enter>

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;
import java.io.IOException;
import java.util.Scanner;

171

public class ProgRandomTexto {


public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Nome do Arquivo Texto: ");
String nomeArquivo = input.nextLine();
try {
int nl;
RandomAccessFile file = new RandomAccessFile(nomeArquivo, "r");
do {
boolean encontrouLinha = false;
System.out.print("Linha: ");
String s = input.nextLine();
nl = Integer.parseInt(s);
int linhas = 0;
while ((linha = file.readLine()) != null) {
linhas++;
if (nl == linhas) {
System.out.println(nl + ": " + linha);
encontrouLinha = true;
}
}
if (!encontrouLinha) {
System.out.println("ERRO: Linha no existe");
}
file.seek(0);
// volta para a primeira linha
} while (nl != 0);
file.close();
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}
}

Exemplo para testar o programa:


Nome do Arquivo Texto: /Users/pluzzardi/Frutas.txt <enter>
Linha: 3 <enter>
3: abacate
Linha: 5 <enter>
5: pitanga
Linha: 99 <enter>
ERRO: Linha no existe
Linha: 0 <enter>
ERRO: Linha no existe

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.File;
import java.io.ObjectOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgBinaryWrite {
public static void main(String[] args) throws IOException {
Scanner input = new Scanner(System.in);
String s;
ArrayList pessoa = new ArrayList();
System.out.print("Nome do Arquivo Binrio: ");
String nomeArquivo = input.nextLine();
try {
File file = new File(nomeArquivo);
try (ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(file))) {
do {
System.out.print("Nome: ");
String nome = input.nextLine();
System.out.print("Idade: ");
s = input.nextLine();
int idade = Integer.parseInt(s);
System.out.print("Sexo [M/F]: ");
s = input.nextLine();
char sexo = s.charAt(0);
pessoa.add(nome);
pessoa.add(idade);
pessoa.add(sexo);
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
} while (!"SsNn".contains(s));
} while (!"Nn".contains(s));
output.writeObject(pessoa); // grava ArrayList
}
} catch (IOException | NumberFormatException e) {
System.out.println(e.toString());
}
}

Exemplo para testar o programa:


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

173

Sexo [M/F]: m <enter>


Continua [S/N]? s <enter>
Nome: Renato <enter>
Idade: 49 <enter>
Sexo [M/F]: M <enter>
Continua [S/N]? s <enter>
Nome: Francisco <enter>
Idade: 53 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Ana <enter>
Idade: 55 <enter>
Sexo [M/F]: f <enter>
Continua [S/N]? s <enter>
Nome: Julia <enter>
Idade: 54 <enter>
Sexo [M/F]: F <enter>
Continua [S/N]? N <enter>
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgBinaryRead.java
package progbinaryread;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Scanner;
public class ProgBinaryRead {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Nome do Arquivo Binrio: ");
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;
public class Registro {
Object nome;
Object idade;
Object sexo;
Registro(String nome, int idade, char sexo) {
this.nome = nome;
this.idade = idade;
this.sexo = sexo;
}
}
// ------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java
package progwritefileregistro;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class FileObjeto {
// ------------------------------ atributos da classe
String nomeFile;
private ObjectOutputStream fileOut;
FileObjeto(String nomeArquivo) {
nomeFile = nomeArquivo;
try {
fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile));
System.out.println("Ok, Arquivo criado: " + nomeFile);
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Problema na 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);
}
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Impossvel fechar o arquivo: " + nomeFile);
System.exit(1);
}
}

// --------------------------------------------------------------------------------------- Programa Principal: ProgWriteFileRegistro.java


package progwritefileregistro;
import java.io.IOException;
import java.util.Scanner;
public class ProgWriteFileRegistro {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Scanner input = new Scanner(System.in);
System.out.print("Nome do Arquivo Binrio: ");
String nomeArquivo = input.nextLine();
FileObjeto file = new FileObjeto(nomeArquivo);
file.addFile("Paulo Roberto", 50, 'm');
file.addFile("Adriane Maria", 42, 'f');
file.addFile("Paola", 13, 'f');
file.closeFile();
}
}
Entrada:

Nome do Arquivo 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;
public class Registro {
Object nome;
Object idade;
Object sexo;

Registro(String nome, int idade, char sexo) {


this.nome = nome;
this.idade = idade;
this.sexo = sexo;
}

// -------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java


package progwritefileregistro2;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class FileObjeto {
// ------------------------------ atributos da classe
String nomeFile;
private ObjectOutputStream fileOut;
FileObjeto(String nomeArquivo) {
nomeFile = nomeArquivo;
try {
fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile));
System.out.println("Ok, Arquivo criado: " + nomeFile);
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Problema na 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
public void closeFile() {
try {
if (fileOut != null) {
fileOut.close();
System.out.println("Ok, Arquivo fechado: " + nomeFile);
}
} catch (IOException ioException) {

177

System.out.println("ERRO Fatal: Impossvel fechar o arquivo: " + nomeFile);


System.exit(1);

}
}
// ---------------------------------------------------------------------------------------- Programa Principal: ProgWriteFileRegistro2.java
package progwritefileregistro2;
import java.io.IOException;
import java.util.Scanner;
public class ProgWriteFileRegistro2 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Scanner input = new Scanner(System.in);
char ch;
System.out.print("Nome do Arquivo: ");
String nomeArquivo = input.nextLine();
FileObjeto file = new FileObjeto(nomeArquivo);
do {
System.out.print("Nome: ");
String nome = input.nextLine();
System.out.print("Idade: ");
String s = input.nextLine();
int idade = Integer.parseInt(s);
System.out.print("sexo [M]asculino ou [F]eminino: ");
s = input.nextLine();
char sexo = s.charAt(0);
Registro registro = new Registro(nome, idade, sexo);
file.addFile(registro);
System.out.print("Continua [S/N]? ");
do {
s = input.nextLine();
ch = s.charAt(0);
} while (!strChr("SsNn", ch));
} while (strChr("Ss", ch));
file.closeFile();
}
// --------------------------------------------------------- strChr
static boolean strChr(String s, char ch) {
int n = s.length();

for (int i = 0;i < n;i++) {


if (s.charAt(i) == ch) {
return(true);
}
}
return(false);

}
Exemplo para testar o programa:
Nome do Arquivo: /Users/pluzzardi/luz.dat <enter>
Ok, Arquivo criado: /Users/pluzzardi/luz.dat

178

Nome: Paulo Roberto <enter>


Idade: 51 <enter>
sexo [M]asculino ou [F]eminino: m <enter>
Continua [S/N]? s <enter>
Nome: Renato Luis <enter>
Idade: 49 <enter>
sexo [M]asculino ou [F]eminino: m <enter>
Continua [S/N]? s <enter>
Nome: Francisco Carlos <enter>
Idade: 53 <enter>
sexo [M]asculino ou [F]eminino: m <enter>
Continua [S/N]? n <enter>
Ok, Arquivo fechado: /Users/pluzzardi/luz.dat

8.9.2 Leitura objetos em um arquivo 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;
public class Registro {
Object nome;
Object idade;
Object sexo;
}
// ---------------------------------------------------------------------------------------------------------------- Programa Principal: FileObjeto.java
package progreadfileregistro;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.EOFException;
public class FileObjeto {
// ---------------------------------- atributos da classe
String nomeFile;
private ObjectInputStream fileIn;
// ----------------------------------------------- construtor
FileObjeto(String nomeArquivo) {
nomeFile = nomeArquivo;
try {
fileIn = new ObjectInputStream(new FileInputStream(nomeFile));
System.out.println("Ok, Arquivo Aberto: " + nomeFile);
} catch (IOException ioException) {

System.out.println("ERRO Fatal: Problema na Abertura do Arquivo: " + nomeFile);

System.exit(1);
}

// ----------------------------------------------------------------------------------------------------- getFile
public void getFile() throws IOException, ClassNotFoundException {

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
public void closeFile() {
try {
if (fileIn != null) {
fileIn.close();
System.out.println("Ok, Arquivo fechado: " + nomeFile);
}
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Impossvel fechar o arquivo: " + nomeFile);
System.exit(1);
}
}

// -------------------------------------------------------------------------------------- Programa Principal: ProgReadFileRegistro.java


package progreadfileregistro;
import java.io.IOException;
import java.util.Scanner;
public class ProgReadFileRegistro {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Scanner input = new Scanner(System.in);
System.out.print("Nome do Arquivo Binrio: ");
String nomeArquivo = input.nextLine();
FileObjeto file = new FileObjeto(nomeArquivo);
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 String nome;
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


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

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');
exibeView(pessoaService);
}
// --------------------------------------------------------------- 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 {
System.out.println("ERRO: Idade Invlida");
}
if (pessoa.getPessoa().getSexo() != 'x') {
System.out.println("Sexo: " + pessoa.getPessoa().getSexo());
} else {
System.out.println("ERRO: Sexo Invlido");
}
}

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


package pessoaView;
public class Principal {
public static void main(String[] args) {

185

new PessoaView();
}

// -------------------------------------------------------------------------------------------------------------------------------------------- Pacote: service


// -------------------------------------------------------------------------------------------------------------------------- Classe: PessoaService.java

package service;
import entity.Pessoa;
public class PessoaService {
// --------------------------------- atributos da classe
private Pessoa pessoa;
// ------------------------------------------ construtor da classe
public PessoaService() {
pessoa = new Pessoa();
}
public PessoaService(String nome, int idade, char sexo) {
pessoa = new Pessoa();
alteraPessoa(nome, idade, sexo);
}
// --------------------------------------------------------------------------------------------- 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);
}

Resultado do Programa:
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 String nome;
private int idade;
private char sexo;
// --------------------------------- construtores da classe
public Pessoa() {
setNome("xxxxxxxxxx");
setIdade(-99);
setSexo('x');
}
public Pessoa(String nome, int idade, char sexo) {
setNome(nome);
setIdade(idade);
setSexo(sexo);
}
// ---------------------------------------------------------- mtodos pblicos da classe
public void setNome(String nome) {

187

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 pblicos da classe


static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}

// ----------------------------------------------------------------------------------------------------------------------------------------- Pacote: pessoaView


// ------------------------------------------------------------------------------------------------------------ Classe: PessoaView.java
package pessoaView;
import entity.Pessoa;
import service.PessoaService;
import static util.Utilidade.*;
public final class PessoaView {
// ------------------------------------------------ atributos da classe
PessoaService pessoaService;
// ------------------------------------------------- construtor da classe
PessoaView() {
String nome = lerString("Digite seu Nome: ");
int idade = lerInteiro("Digite sua Idade: ");
char sexo = lerChar("Seu Sexo [M]asculino ou [F]eminino: ");
pessoaService = new PessoaService(nome, idade, sexo);

188

exibeView(pessoaService);
PessoaService pessoaService = new PessoaService();
nome = lerString("Digite seu Nome: ");
idade = lerInteiro("Digite sua Idade: ");
sexo = lerChar("Sexo [M]asculino ou [F]eminino: ");
pessoaService.alteraPessoa(nome, idade, sexo);
exibeView(pessoaService);

// ---------------------------------------------------------------- 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 {
System.out.println("ERRO: Idade Invlida");
}
if (pessoa.getPessoa().getSexo() != 'x') {
System.out.println("Sexo: " + pessoa.getPessoa().getSexo());
} else {
System.out.println("ERRO: Sexo Invlido");
}
}

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


package pessoaView;
public class Principal {
public static void main(String[] args) {
new PessoaView();
}
}
// -------------------------------------------------------------------------------------------------------------------------------------------- Pacote: service
// ----------------------------------------------------------------------------------------------------------------------------- Classe: PessoaService.java
package service;
import entity.Pessoa;
public class PessoaService {

189

// -------------------------------------- atributos da classe


private Pessoa pessoa;
// -------------------------------------- construtor da classe
public PessoaService() {
pessoa = new Pessoa();
}
public PessoaService(String nome, int idade, char sexo) {
pessoa = new Pessoa();
alteraPessoa(nome, idade, sexo);
}
// ------------------------------------------------------------------------------------------- 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;
import java.util.Scanner;
public class Utilidade {
public static String lerString(String mensagem) {
Scanner input = new Scanner(System.in);
System.out.print(mensagem);
String s = input.nextLine();
return(s);
}
public static int lerInteiro(String mensagem) {
Scanner input = new Scanner(System.in);
System.out.print(mensagem);
String s = input.nextLine();
int inteiro = Integer.parseInt(s);
return(inteiro);
}

public static char lerChar(String mensagem) {


Scanner input = new Scanner(System.in);
System.out.print(mensagem);
String s = input.nextLine();
char ch = s.charAt(0);
return(ch);
}

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 {
public static void main(String[] args) {
String s = "abcdef";
Object objeto = "abcdef";
int n = s.length();

System.out.println("HashCode: " + s.hashCode());


int hash = 0;
for (int i = 0;i < s.length();i++) {
hash = 31 * hash + s.charAt(i);
}
System.out.println("Hash calculado: " + hash);
System.out.println("HashCode objeto: " + objeto.hashCode());

}
Resultado do Programa:
HashCode: -1424385949
Hash calculado: -1424385949
HashCode objeto: -1424385949

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
package progsimples;
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) {
Nodo ref = primeiro;
int posicao = 1;
while (ref != null) {
if (ref.info == valor) {
return (posicao);
}
ref = ref.elo;
posicao++;
}
} else {
System.out.println("ERRO: Lista Vazia");
}
return (-1);
}
// ----------------------------------------------------------- exibir
public void exibir() {
Nodo ref = primeiro;
System.out.print("Lista Encadeada Simples: [");
if (n == 0) {
System.out.println("Vazia]");
} else {
while (ref != null) {
System.out.print(ref.info + " ");
ref = ref.elo;
}
System.out.println("\b]");
}
}
// ----------------------------------------------------------- exibirDescritor
public void exibeDescritor() {
System.out.println("Descritor: | " + primeiro + " | " + n + " |");
}
// ----------------------------------------------------------- removeAll
public void removeAll() {
primeiro = null;
n = 0;
System.gc();
}
// ----------------------------------------------------------- consultar
public int consultar() {
if (n == 0) {
return (-999);
} else {
Nodo ref = primeiro;
int valor = ref.info;

196

return (valor);
}

// ---------------------- mtodos privados da classe


// ---------------------- mtodos estticos da classe
}
// ------------------------------------------------------------------------------------------------------------------------------- Classe: ProgSimples.java
package progsimples;
import java.util.Scanner;
public class ProgSimples {
public static void main(String[] args) {
ListaSimples simples = new ListaSimples();
Scanner input = new Scanner(System.in);
char op;
int valor, posicao;
do {
simples.exibeDescritor();
simples.exibir();
do {
System.out.print("[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: ");
String s = input.nextLine();
op = s.charAt(0);
} while (!strChr("IiEeCcPpRrFf", op));
if (strChr("Ff", op)) {
System.exit(0);
}
switch (op) {
case 'I':
case 'i':
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
simples.incluir(valor);
break;
case 'E':
case 'e':
valor = simples.excluir();
if (valor != -999) {
System.out.println("Valor Excludo Esquerda: " + valor);
} else {
System.out.println("ERRO: Lista vazia Esquerda");
}
break;
case 'P':
case 'p':
System.out.print("Valor Pesquisar: ");
s = input.nextLine();
int valorPesquisar = Integer.parseInt(s);
posicao = simples.pesquisar(valorPesquisar);
if (posicao != -1) {
System.out.println("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 {
System.out.println("ERRO: Lista vazia Esquerda");
}
break;
}
} while (!strChr("Ff", op));
}

public static boolean strChr(String s, char ch) {


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

Exemplo para testar o programa:


Descritor: | null | 0 |
Lista Encadeada Simples: [Vazia]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: 10 <enter>
Descritor: | progsimples.Nodo@77eec5fe | 1 |
Lista Encadeada Simples: [10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: 20 <enter>
Descritor: | progsimples.Nodo@5d08e435 | 2 |
Lista Encadeada Simples: [20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: 30 <enter>
Descritor: | progsimples.Nodo@72be834a | 3 |
Lista Encadeada Simples: [30 20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: 40 <enter>
Descritor: | progsimples.Nodo@399daa20 | 4 |
Lista Encadeada Simples: [40 30 20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: 40
Descritor: | progsimples.Nodo@72be834a | 3 |
Lista Encadeada Simples: [30 20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter>
Valor Pesquisar: 20 <enter>
Posio do Valor pesquisado: 2

198

Descritor: | progsimples.Nodo@72be834a | 3 |
Lista Encadeada Simples: [30 20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter>
Valor Consultado Esquerda: 30
Descritor: | progsimples.Nodo@72be834a | 3 |
Lista Encadeada Simples: [30 20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: 30
Descritor: | progsimples.Nodo@5d08e435 | 2 |
Lista Encadeada Simples: [20 10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: 20
Descritor: | progsimples.Nodo@77eec5fe | 1 |
Lista Encadeada Simples: [10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: 10
Descritor: | null | 0 |
Lista Encadeada Simples: [Vazia]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter>

11.2 Lista Encadeada 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
package progsimples;
public class Nodo<E> {
E element;
Nodo<E> elo;
}
// ------------------------------------------------------------------------------------------------------------- Classe: ListaSimplesGenerica.java
package progsimples;
public class ListaSimplesGenerica <E>{
// ---------------------- atributos da classe
private int n;
private Nodo primeiro;
// ---------------------- construtor
ListaSimplesGenerica() {
primeiro = null;
n = 0;
}
// ----------------------------------------------------------- mtodos pblicos da classe
// ----------------------------------------------------------- incluir
public void incluir(Object valor) {
Nodo ref = new Nodo();

199

ref.element = valor;
if (n != 0) {
ref.elo = primeiro;
}
n++;
primeiro = ref;
}
// ----------------------------------------------------------- excluir
public Object excluir() {
if (n == 0) {
return (-999);
} else {
Nodo ref = primeiro;
Object valor = ref.element;
primeiro = ref.elo;
n--;
if (n == 0) {
primeiro = null;
}
return (valor);
}
}
// ----------------------------------------------------------- pesquisar
public int pesquisar(Object valor) {
if (n != 0) {
Nodo ref = primeiro;
int posicao = 1;
while (ref != null) {
if (ref.element.equals(valor)) {
return (posicao);
}
ref = ref.elo;
posicao++;
}
} else {
System.out.println("ERRO: Lista Vazia");
}
return (-1);
}
// ----------------------------------------------------------- exibir
public void exibir() {
Nodo ref = primeiro;
System.out.print("Lista Encadeada Simples: [");
if (n == 0) {
System.out.println("Vazia]");
} else {
while (ref != null) {
System.out.print(ref.element + " ");
ref = ref.elo;
}
System.out.println("\b]");
}
}
// ----------------------------------------------------------- exibirDescritor
public void exibeDescritor() {

200

System.out.println("Descritor: | " + primeiro + " | " + n + " |");


}
// ----------------------------------------------------------- removeAll
public void removeAll() {
primeiro = null;
n = 0;
System.gc();
}
// ----------------------------------------------------------- consultar
public Object consultar() {
if (n == 0) {
return (-999);
} else {
Nodo ref = primeiro;
Object valor = ref.element;
return (valor);
}
}
// ---------------------- mtodos privados da classe
// ---------------------- mtodos estticos da classe
}
// ----------------------------------------------------------------------------------------------------------- Classe: ProgListaSimplesGenerica.java
package progsimples;
import java.util.Scanner;
public class ProgSimplesGenerica {
public static void main(String[] args) {
ListaSimplesGenerica<String> simples = new ListaSimplesGenerica<>();
// troque String por Integer ou Double e teste novamente
Scanner input = new Scanner(System.in);
char op;
int posicao;
Object valor;
do {
simples.exibeDescritor();
simples.exibir();
do {
System.out.print("[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: ");
String s = input.nextLine();
op = s.charAt(0);
} while (!strChr("IiEeCcPpRrFf", op));
if (strChr("Ff", op)) {
System.exit(0);
}
switch (op) {
case 'I':
case 'i':
System.out.print("Valor: ");
String s = input.nextLine();
simples.incluir(s);
break;

201

case 'E':
case 'e':
valor = simples.excluir();
if (valor.hashCode() != -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: ");
String valorPesquisar = input.nextLine();
posicao = simples.pesquisar(valorPesquisar);
if (posicao != -1) {
System.out.println("Posio do Valor pesquisado: " + posicao);
} else {
System.out.println("ERRO: Valor no encontrado");
}
break;
case 'R':
case 'r':
simples.removeAll();
break;
case 'C':
case 'c':
valor = simples.consultar();
if (valor.hashCode() != -999) {
System.out.println("Valor Consultado Esquerda: " + valor);
} else {
System.out.println("ERRO: Lista vazia Esquerda");
}
break;
}
} while (!strChr("Ff", op));
}

public static boolean strChr(String s, char ch) {


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

Exemplo para testar o programa:


Descritor: | null | 0 |
Lista Encadeada Simples: [Vazia]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: Ana <enter>
Descritor: | progsimples.Nodo@6d6f6e28 | 1 |
Lista Encadeada Simples: [Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: Beatriz <enter>

202

Descritor: | progsimples.Nodo@135fbaa4 | 2 |
Lista Encadeada Simples: [Beatriz Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
Valor: Carla <enter>
Descritor: | progsimples.Nodo@45ee12a7 | 3 |
Lista Encadeada Simples: [Carla Beatriz Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter>
Valor Pesquisar: Beatriz <enter>
Posio do Valor pesquisado: 2
Descritor: | progsimples.Nodo@45ee12a7 | 3 |
Lista Encadeada Simples: [Carla Beatriz Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter>
Valor Consultado Esquerda: Carla
Descritor: | progsimples.Nodo@45ee12a7 | 3 |
Lista Encadeada Simples: [Carla Beatriz Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: Carla
Descritor: | progsimples.Nodo@135fbaa4 | 2 |
Lista Encadeada Simples: [Beatriz Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: Beatriz
Descritor: | progsimples.Nodo@6d6f6e28 | 1 |
Lista Encadeada Simples: [Ana]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: e <enter>
Valor Excludo Esquerda: Ana
Descritor: | null | 0 |
Lista Encadeada Simples: [Vazia]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter>
ERRO: Lista vazia Esquerda
Descritor: | null | 0 |
Lista Encadeada Simples: [Vazia]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter>

12. Lista Duplamente Encadeada em Java


Na lista duplamente encadeada (Figura 16), cada elemento possui um elo para o
anterior (antecessor) e o posterior (sucessor), sendo que a lista pode ter ou no descritor.
Descritor: Estrutura que normalmente armazena o primeiro elemento, a quantidade de elementos e o ltimo elemento da Lista.
private Nodo primeiro;
private int n;
private Nodo ultimo;

Problema: Escrever um programa em Java que insere, exclui, pesquisa, consulta e remove
todos os dados em uma lista duplamente encadeada com descritor.

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

// ----------------------------------------------------------- mtodos pblicos da classe


// ----------------------------------------------------------- incluirEsquerda
public void incluirEsquerda(int valor) {
Nodo ref = new Nodo();
ref.info = valor;
if (descritor.n == 0) {
descritor.ultimo = ref;
} else {
ref.posterior = descritor.primeiro;
descritor.primeiro.anterior = ref;
}
descritor.n++;
descritor.primeiro = ref;
}
// ----------------------------------------------------------- incluirDireita
public void incluirDireita(int valor) {
Nodo ref = new Nodo();
ref.info = valor;
if (descritor.n == 0) {
descritor.primeiro = ref;
} else {
ref.anterior = descritor.ultimo;
descritor.ultimo.posterior = ref;
}
descritor.n++;
descritor.ultimo = ref;
}
// ---------------------------------------------------------------------- incluirPosicao
public void incluirPosicao(int valor, int posicao) {
if (posicao >= 0 && posicao <= descritor.n) {
Nodo ref = new Nodo();
ref.info = valor;
Nodo aux = descritor.primeiro;
if (posicao == 1) {
incluirEsquerda(valor);
} else {
if (posicao == descritor.n + 1) {
incluirDireita(valor);
} else {
for (int i = 1; i < posicao - 1; i++) {
aux = aux.posterior;
}
descritor.n++;
ref.anterior = aux;
ref.posterior = aux.posterior;
aux.posterior.anterior = ref;
aux.posterior = ref;
}
}
} else {
System.out.println("ERRO: Posio Invlida");
}
}
// ----------------------------------------------------------- excluirEsquerda
public int excluirEsquerda() {

205

if (descritor.n == 0) {
return (-999);
} else {
Nodo ref = descritor.primeiro;
int valor = ref.info;
descritor.primeiro = ref.posterior;
if (descritor.primeiro != null) {
descritor.primeiro.anterior = null;
}
descritor.n--;
if (descritor.n == 0) {
descritor.ultimo = null;
}
return (valor);
}

// ----------------------------------------------------------- excluirDireita
public int excluirDireita() {
if (descritor.n == 0) {
return (-999);
} else {
Nodo ref = descritor.ultimo;
int valor = ref.info;
descritor.ultimo = ref.anterior;
if (descritor.ultimo != null) {
descritor.ultimo.posterior = null;
}
descritor.n--;
if (descritor.n == 0) {
descritor.primeiro = null;
}
return (valor);
}
}
// ----------------------------------------------------------- excluirPosicao
public int excluirPosicao(int posicao) {
if (descritor.n == 0) {
return (-999);
} else {
if (posicao == 1) {
return (excluirEsquerda());
} else {
if (posicao == descritor.n) {
return (excluirDireita());
} else {
Nodo ref = descritor.primeiro;
Nodo aux = ref;
for (int i = 1; i < posicao; i++) {
aux = ref;
ref = ref.posterior;
}
int valor = ref.info;
aux.posterior = ref.posterior;
ref.posterior.anterior = aux;
descritor.n--;
if (descritor.n == 0) {
descritor.ultimo = null;

206

}
return (valor);

}
}

// ----------------------------------------------------------- pesquisar
public int pesquisar(int valor) {
if (descritor.n != 0) {
Nodo ref = descritor.primeiro;
int posicao = 1;
while (ref != null) {
if (ref.info == valor) {
return (posicao);
}
ref = ref.posterior;
posicao++;
}
} else {
System.out.println("ERRO: Lista Vazia");
}
return (-1);
}
// ----------------------------------------------------------- exibirEsquerda
public void exibirEsquerda() {
Nodo ref = descritor.primeiro;
System.out.print("Lista pela Esquerda: [");
if (descritor.n == 0) {
System.out.println("Vazia]");
} else {
while (ref != null) {
System.out.print(ref.info + " ");
ref = ref.posterior;
}
System.out.println("\b]");
}

// ----------------------------------------------------------- exibirDireita
public void exibirDireita() {
Nodo ref = descritor.ultimo;
System.out.print("Lista pela Direita: [");
if (descritor.n == 0) {
System.out.println("Vazia]");
} else {
while (ref != null) {
System.out.print(ref.info + " ");
ref = ref.anterior;
}
System.out.println("\b]");
}
}
// ----------------------------------------------------------- exibirDescritor
public void exibeDescritor() {
System.out.println("Descritor: | " + descritor.primeiro + " | " +

207

descritor.n + " | " + descritor.ultimo + " |");


}
// ----------------------------------------------------------- removeAll
public void removeAll() {
descritor = new Descritor(null, 0, null);
System.gc();
}
// ----------------------------------------------------------- consultarEsquerda
public int consultarEsquerda() {
if (descritor.n == 0) {
return (-999);
} else {
Nodo ref = descritor.primeiro;
int valor = ref.info;
return (valor);
}
}
// ----------------------------------------------------------- consultarDireita
public int consultarDireita() {
if (descritor.n == 0) {
return (-999);
} else {
Nodo ref = descritor.ultimo;
int valor = ref.info;
return (valor);
}
}
// ----------------------------------------------------------- consultarPosicao
public int consultarPosicao(int posicao) {
if (descritor.n == 0) {
return (-999);
} else {
if (posicao == 1) {
return (consultarEsquerda());
} else {
if (posicao == descritor.n) {
return (consultarDireita());
} else {
Nodo ref = descritor.primeiro;
for (int i = 1; i < posicao; i++) {
ref = ref.posterior;
}
int valor = ref.info;
return (valor);
}
}
}
}
// ---------------------- mtodos privados da classe
// ---------------------- mtodos estticos da classe
}
// ------------------------------------------------------------------------------------------------------------------- Programa Principal: ProgDupla.java

208

package progdupla;
import java.util.Scanner;
public class ProgDupla {
public static void main(String[] args) {
ListaDupla dupla = new ListaDupla();
Scanner input = new Scanner(System.in);
char ch = 'T', op;
int valor, posicao;
do {
dupla.exibeDescritor();
dupla.exibirDireita();
dupla.exibirEsquerda();
do {

System.out.print("[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: ");

String s = input.nextLine();
op = s.charAt(0);
} while (!strChr("IiEeCcPpRrFf", op));
if (strChr("Ff", op)) {
System.exit(0);
}
if (strChr("IiEeCc", op)) {
do {
System.out.print("[E]squerda, [D]ireita ou [P]osio: ");
String s = input.nextLine();
ch = s.charAt(0);
} while (!strChr("DdEePp", ch));
}
switch (op) {
case 'I':
case 'i':
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
switch (ch) {
case 'D':
case 'd':
dupla.incluirDireita(valor);
break;
case 'E':
case 'e':
dupla.incluirEsquerda(valor);
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
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) {
System.out.println("Valor Excludo Esquerda: " + valor);

} else {
System.out.println("ERRO: Lista vazia Esquerda");
}
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
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':
System.out.print("Valor Pesquisar: ");
s = input.nextLine();
int valorPesquisar = Integer.parseInt(s);
posicao = dupla.pesquisar(valorPesquisar);
if (posicao != -1) {
System.out.println("Posio do Valor pesquisado: " + posicao);
} else {
System.out.println("ERRO: Valor no encontrado");
}
break;
case 'R':
case 'r':
dupla.removeAll();
break;
case 'C':
case 'c':
switch (ch) {
case 'D':
case 'd':
valor = dupla.consultarDireita();
if (valor != -999) {
System.out.println("Valor Consultado Direita: " + valor);

} else {
System.out.println("ERRO: Lista vazia Direita");
}
break;
case 'E':

210

case 'e':
valor = dupla.consultarEsquerda();
if (valor != -999) {

System.out.println("Valor Consultado Esquerda: " + valor);

} else {
System.out.println("ERRO: Lista vazia Esquerda");
}
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
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;
}
} while (!strChr("Ff", op));
}
public static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}
}
Exemplo para testar o programa:
Descritor: | null | 0 | null |
Lista pela Direita: [Vazia]
Lista pela Esquerda: [Vazia]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
[E]squerda, [D]ireita ou [P]osio: e <enter>
Valor: 10 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 1 | progdupla.Nodo@3ed8d90c |
Lista pela Direita: [10]
Lista pela Esquerda: [10]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
[E]squerda, [D]ireita ou [P]osio: d <enter>
Valor: 20 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 2 | progdupla.Nodo@e91c310 |
Lista pela Direita: [20 10]
Lista pela Esquerda: [10 20]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
[E]squerda, [D]ireita ou [P]osio: d <enter>
Valor: 40 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 3 | progdupla.Nodo@39d56e9 |
Lista pela Direita: [40 20 10]

211

Lista pela Esquerda: [10 20 40]


[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: i <enter>
[E]squerda, [D]ireita ou [P]osio: p <enter>
Valor: 30 <enter>
Posio: 3 <enter>
Descritor: | progdupla.Nodo@3ed8d90c | 4 | progdupla.Nodo@39d56e9 |
Lista pela Direita: [40 30 20 10]
Lista pela Esquerda: [10 20 30 40]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: p <enter>
Valor Pesquisar: 30 <enter>
Posio do Valor pesquisado: 3
Descritor: | progdupla.Nodo@3ed8d90c | 4 | progdupla.Nodo@39d56e9 |
Lista pela Direita: [40 30 20 10]
Lista pela Esquerda: [10 20 30 40]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: c <enter>
[E]squerda, [D]ireita ou [P]osio: d <enter>
Valor Consultado Direita: 40
Descritor: | progdupla.Nodo@3ed8d90c | 4 | progdupla.Nodo@39d56e9 |
Lista pela Direita: [40 30 20 10]
Lista pela Esquerda: [10 20 30 40]
[I]ncluir, [E]xcluir, [P]esquisar, [C]onsultar, [R]emoveAll ou [F]im: f <enter>

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):
Exemplo para testar o programa:
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 {
public static void main(String[] args) {
EntradaDadosScanner entrada = new EntradaDadosScanner();

int inteiro = entrada.leInteiro("Digite um Inteiro: ");


System.out.println("Inteiro Digitado: " + inteiro);
Double real = entrada.leReal("Digite um Real: ");
System.out.println("Real Digitado: " + real);

}
// ------------------------------------------------------------------------------------------------------- Classe: EntradaDadosScanner.java
package progentradaDados;
import java.util.Scanner;
public class EntradaDadosScanner {

213

// ------------------------------------------------------ mtodos pblicos da classe


// -------------------------------------------------- leInteiro
public int leInteiro(String mensagem) {
Scanner input = new Scanner(System.in);
String s;
int limite, n;

do {
System.out.print(mensagem);
s = input.nextLine();
s = s.replaceAll("[^0-9\\-]", ""); // 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);
}
}
}
} while (s.isEmpty());
int inteiro = Integer.parseInt(s); // converso segura sem erros
return (inteiro);

// ----------------------------------------------------------- leReal
public double leReal(String mensagem) {
Scanner input = new Scanner(System.in);
String s;
do {
System.out.print(mensagem);
s = input.nextLine();
s = s.replaceAll("[^0-9\\-.,]", "");
// eliminar letras
s = verificaVirgulaPonto(s);
s = retiraNegativosForaLugar(s);
int n = s.length();
if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) {
s = "";
}
} while (s.isEmpty());
double real = Double.parseDouble(s);
// 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 {
public static void main(String[] args) {
EntradaDadosSwing entrada = new EntradaDadosSwing();
int inteiro = entrada.leInteiro("Digite um Inteiro: ");
JOptionPane.showMessageDialog(null, "Inteiro Digitado: " + inteiro);
Double real = entrada.leReal("Digite um Real: ");
JOptionPane.showMessageDialog(null, "Real Digitado: " + real);
}

// ---------------------------------------------------------------------------------------------------------------------- Classe: EntradaDadosSwing.java


package progentradadadosswing;
import javax.swing.JOptionPane;
public class EntradaDadosSwing {
// ----------------------------------------------------- mtodos pblicos da classe
// -------------------------------------------------- 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) {
s = retiraNegativosForaLugar(s);
if (s.charAt(0) == '-') {
limite = 11;
} else {
limite = 10;
}
if (n >= limite) {
s = verificaLimites(s);
}
}
} else {
s = "";
}
} while (s.isEmpty());
int inteiro = Integer.parseInt(s);
return (inteiro);
}
// ----------------------------------------------------------- leReal
public double leReal(String mensagem) {

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
s = retiraNegativosForaLugar(s);
int n = s.length();
if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) {
s = "";
}
} while (s.isEmpty());
double real = Double.parseDouble(s);
return (real);

// --------------------------------------------------------------------- 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

import java.util.Stack;
import java.util.Scanner;
public class ProgTorre {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int in, out;
Stack p1 = new Stack();
Stack p2 = new Stack();
Stack p3 = new Stack();
boolean ganhou, moveu = false;
p1.push(3);
p1.push(2);
p1.push(1);
exibePilhas(p1, p2, p3);
do {
do {
System.out.print("Move: ");
s = entrada.nextLine();
in = Integer.parseInt(s);
if (in == 0) {
System.exit(0);
}
} while (in < 1 || in > 3);
do {
System.out.print("Para: ");
s = entrada.nextLine();
out = Integer.parseInt(s);
if (in == 0) {
System.exit(0);
}
} while (out < 1 || out > 3);
if (testaMovimento(p1, p2, p3, in)) {
if (testaMaior(p1, p2, p3, in, out)) {
moveu = movePilha(p1, p2, p3, in, out);
}
}
exibePilhas(p1, p2, p3);
if (moveu) {
ganhou = testaVitoria(p1);
if (ganhou) {
System.out.println("Status: VENCEDOR (p1)");
System.exit(0);
}
ganhou = testaVitoria(p2);
if (ganhou) {
System.out.println("Status: VENCEDOR (p2)");
System.exit(0);
}
ganhou = testaVitoria(p3);
if (ganhou) {
System.out.println("Status: VENCEDOR (p3)");
System.exit(0);
}
}

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;
case 2: nodo = p2.peek();
a = nodo.hashCode();
break;
case 3: nodo = p3.peek();
a = nodo.hashCode();
break;
}
switch (out) {
case 1: if (p1.empty()) {
return(true);
}
else {
nodo = p1.peek();
b = nodo.hashCode();
}
break;
case 2: if (p2.empty()) {
return(true);
}
else {
nodo = p2.peek();
b = nodo.hashCode();
}
break;
case 3: if (p3.empty()) {
return(true);
}
else {
nodo = p3.peek();
b = nodo.hashCode();
}
break;

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) {
case 1: if (p1.empty()) {
System.out.println("Status: Impossivel mover (p1)");
}
else {
pode = true;
}
break;
case 2: if (p2.empty()) {
System.out.println("Status: Impossivel mover (p2)");
}
else {
pode = true;
}
break;
case 3: if (p3.empty()) {
System.out.println("Status: Impossivel mover (p3)");
}
else {
pode = true;
}
break;
}
return(pode);
}
// -------------------------------------------------------------------------------------------------- movePilha
static boolean movePilha(Stack p1, Stack p2, Stack p3, int a, int b) {
Object nodo;
int in = 0;
boolean moveu = false;
switch (a) {
case 1: if (!p1.empty()) {
nodo = p1.pop();
in = nodo.hashCode();
}
else {
in = 0;
}
break;
case 2: if (!p2.empty()) {
nodo = p2.pop();
in = nodo.hashCode();
}
else {
in = 0;

222

}
break;
case 3: if (!p3.empty()) {
nodo = p3.pop();
in = nodo.hashCode();
}
else {
in = 0;
}
break;
}
if (in != 0) {
switch (b) {
case 1: p1.push(in);
moveu = true;
break;
case 2: p2.push(in);
moveu = true;
break;
case 3: p3.push(in);
moveu = true;
break;
}
}
return(moveu);
}
// --------------------------------------------------------------------------------- exibePilhas
static void exibePilhas(Stack p1, Stack p2, Stack p3) {
System.out.println("p1: " + p1);
System.out.println("p2: " + p2);
System.out.println("p3: " + p3);
}

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';
}
nodo = p1.search(2);
a2 = nodo.toString().charAt(0);
if (a2 != '-') {
a2 = '2';
}
nodo = p1.search(3);
a3 = nodo.toString().charAt(0);
if (a3 != '-') {
a3 = '3';
}

223

nodo = p2.search(1);
b1 = nodo.toString().charAt(0);
if (b1 != '-') {
b1 = '1';
}
nodo = p2.search(2);
b2 = nodo.toString().charAt(0);
if (b2 != '-') {
b2 = '2';
}
nodo = p2.search(3);
b3 = nodo.toString().charAt(0);
if (b3 != '-') {
b3 = '3';
}
nodo = p3.search(1);
c1 = nodo.toString().charAt(0);
if (c1 != '-') {
c1 = '1';
}
nodo = p3.search(2);
c2 = nodo.toString().charAt(0);
if (c2 != '-') {
c2 = '2';
}
nodo = p3.search(3);
c3 = nodo.toString().charAt(0);
if (c3 != '-') {
c3 = '3';
}
if (c3 == '-' && c2 == '-' && c1 != '-') {
c3 = c1;
c1 = '-';
}
if (c3 == '-' && c2 != '-' && c1 == '-') {
c3 = c2;
c2 = '-';
}
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);
System.out.printf(" %c
%c
%c \n", a2, b2, c2);
System.out.printf(" %c
%c
%c \n", a3, b3, c3);
System.out.printf("--------- --------- ---------\n");
System.out.printf(" p1
p2
p3\n\n");

14.2 Analisador de 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;
import java.util.Stack;
import java.util.Scanner;
public class ProgAnalisaExpressao {
public static void main(String[] args) {
Stack numeros = new Stack();
Stack operadores = new Stack();
Scanner entrada = new Scanner(System.in);
String s;
float resp;
System.out.print("Expressao: ");
s = entrada.nextLine();
int n = s.length();
if (testaExpressao(s)) {
for (int i = 0;i < n;i++) {
if (s.charAt(i) == '(') {
continue;
}
if ("0123456789".indexOf(s.charAt(i)) != -1) {
char ch = s.charAt(i);
float t = (float) ch - 48;

225

numeros.push(t);
exibePilha(numeros);
exibePilha(operadores);
System.out.println();
}
else {
if ("+-*/".indexOf(s.charAt(i)) != -1) {
char op = s.charAt(i);
operadores.push(op);
}
}
if (s.charAt(i) == ')') {
Object nodo = numeros.pop();
String st = nodo.toString();
float y = Float.parseFloat(st);
nodo = numeros.pop();
st = nodo.toString();
float x = Float.parseFloat(st);
nodo = operadores.pop();
String temp = nodo.toString();
char op = temp.charAt(0);
resp = calculaOperacao(x, y, op);
numeros.push(resp);
exibePilha(numeros);
exibePilha(operadores);
}

}
System.out.println();
if (operadores.empty()) {
Object nodo = numeros.pop();
String st = nodo.toString();
resp = Float.parseFloat(st);
}
else {
resp = 0;
while (!operadores.empty()) {
Object nodo = numeros.pop();
String st = nodo.toString();
float y = Float.parseFloat(st);
nodo = numeros.pop();
st = nodo.toString();
float x = Float.parseFloat(st);
nodo = operadores.pop();
String temp = nodo.toString();
char op = temp.charAt(0);
resp = calculaOperacao(x, y, op);
numeros.push(resp);
exibePilha(numeros);
exibePilha(operadores);
}
}
System.out.println("Resposta: " + resp);
}
else {
System.out.println("Erro: Expressao Invalida");
}

// ---------------------------------------- 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] + " ");
}
System.out.println();
}

Exemplo para testar o programa:


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.
Exemplo para testar o programa:
Polonesa Reversa: <enter> abandona
3 <enter>
2 <enter>
/ <enter>
1.5
2 <enter>
* <enter>
3
<enter>
by Polonesa Reversa
// -------------------------------------------------------------------------------------- Programa Prinicpal: ProgPolonesaReversa.java
package progpolonesareversa;
public class ProgPolonesaReversa {
public static void main(String[] args) {
PolonesaReversa polonesa = new PolonesaReversa();

228

polonesa.calculaPolonesaReversa();

}
// -------------------------------------------------------------------------------------------------------- Classe: PolonesaReversa.java
package progpolonesareversa;
import java.util.Scanner;
public class PolonesaReversa {
// --------------------------------------------------- atributos da classe
private double x, y, resp = 0;
private char op;
private int erro;
// ----------------------------------------------------- mtodos pblicos da classe
public PolonesaReversa () { // construtor
erro = 0;
}
public void calculaPolonesaReversa() {
Scanner entrada = new Scanner(System.in);
String s;

System.out.println("Polonesa Reversa: <enter> abandonar");


do {
if (resp == 0) {
s = entrada.nextLine();
if (s.equals("")) {
System.out.println("by Polonesa Reversa");
System.exit(0);
}
s = s.replaceAll("[^0-9\\-.]", "");
// elimina letras digitadas incorretamente
x = Double.parseDouble(s);
}
else {
x = resp;
}
s = entrada.nextLine();
if (s.equals("")) {
System.out.println("by Polonesa Reversa");
System.exit(0);
}
s = s.replaceAll("[^0-9\\-.]", "");
// elimina letras digitadas incorretamente
y = Double.parseDouble(s);
do {
s = entrada.nextLine();
if (s.equals("")) {
System.out.println("by Polonesa Reversa");
System.exit(0);
}
op = s.charAt(0);
} while (!strChr("+-*/Pp", op));
operaCalculadora();
exibeCalculadora();
} while (!s.equals(""));

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++) {


if (s.charAt(i) == ch) {
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 {
public static void main(String[] args) {
Tabuleiro tabuleiro = new Tabuleiro();
tabuleiro.sorteiaNumeros();
tabuleiro.exibeTabuleiro();
tabuleiro.jogadasJogador();
}

// ---------------------------------------------------------------------------------------------------------------------- Classe: Tabuleiro.java


package progcabeca;
import java.util.Scanner;

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() {
Scanner input = new Scanner(System.in);
char tecla;

232

do {
System.out.print("Move (" + jogadas + "): ");
String s = input.nextLine();
tecla = s.charAt(0);
if (strChr("12345678", tecla)) {
verificaDeslocamento(tecla-48);
jogadas++;
if (jogadas == 99) {
System.out.println("Game Over");
System.exit(0);
}
}
} while (tecla != '0');
}
// --------------------------------------------- exibeTabuleiro
public void exibeTabuleiro() {
for (int l = 0;l < 3;l++) {
for (int c = 0;c < 3;c++) {
if (matriz[l][c] != 0) {
System.out.printf("%2d ", matriz[l][c]);
}
else {
System.out.printf(" ");
}
}
System.out.println();
}
}
// ----------------------------------------------- sorteiaNumeros
public void sorteiaNumeros() {
for (int i = 1;i <= 8;i++) {
boolean ok = false;
do {
int l = (int) (Math.random() * 3);
int c = (int) (Math.random() * 3);
if (matriz[l][c] == 0) {
matriz[l][c] = i;
ok = true;
}
} 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
package progcirculo;
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);
}
// ---------------------- mtodos privados da classe
// ---------------------- mtodos estticos da classe
}
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgCirculo.java
package progcirculo;
public class ProgCirculo {
public static void main(String[] args) {
Circulo circ = new Circulo();
circ.setRaio(3);
circ.calculaArea();
double area = circ.getArea();
System.out.printf("rea: %.2f\n", area);
}

1.4.2 ProgPeso
// ------------------------------------------------------------------------------------------------------------ Classe: PesoIdeal.java
package progpeso;

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;
this.altura = altura;
}
// -------------------------------------------------- mtodos pblicos da classe
public void calculaPesoIdeal() {
switch (sexo) {
case 'H':
case 'h':
pesoIdeal = 72.7 * altura - 58.0;
break;
case 'M':
case 'm':
pesoIdeal = 62.1 * altura - 44.7;
break;
default:
System.out.println("ERRO: Sexo Invlido");
}
}
public double getPesoIdeal() {
return (pesoIdeal);
}

// ------------------------ mtodos privados da classe


// ------------------------ mtodos estticos da classe

// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgPeso.java


package progpeso;
public class ProgPeso {
public static void main(String[] args) {
PesoIdeal piHomem = new PesoIdeal('H', 1.67);
PesoIdeal piMulher = new PesoIdeal('m', 1.65);

// 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

package progvalidacpf;
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;
System.out.println("CPF: " + cpf);
soma = 0;
x = 11;
n = cpf.length();
for (int i = 0;i < n;i++) {
soma = soma + (cpf.charAt(i) - 48) * x;
x--;
}
System.out.println("Soma: " + soma);
int digito2 = 11 - soma % 11;
if (digito2 == 10 || digito2 == 11) {
digito2 = 0;
}
System.out.println("Digito 2: " + digito2);
digito = digito1 * 10 + digito2;
return(digito);
}
// --------------------- mtodos privados da classe
// --------------------- mtodos estticos da classe
}
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java
package progvalidacpf;
public class ProgValidaCPF {
public static void main(String[] args) {
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
package progdiasemana;
public class DiaSemana {
// ------------------------------ atributos da classe
private int dia;
private int mes;
private int ano;
private String semana;
// ---------------------------------------------------- construtor
DiaSemana(int dia, int mes, int ano) {
this.dia = dia;
this.mes = mes;
this.ano = ano;
}
//------------------------------------------------------- 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
package progdiasemana;

237

public class ProgDiaSemana {


public static void main(String[] args) {
DiaSemana dia = new DiaSemana(10, 2, 1962);
dia.verificaDiaSemana();
dia.exibeDiaSemana();
}

1.4.5 ProgTestData
// ------------------------------------------------------------------------------------------------------------------------- Classe: Data.java
package progtestdata;
public class Data {
// ------------------------------ atributos da classe
private int dia;
private int mes;
private int ano;
// ------------------------------ construtor da classe
// ---------------------------------------- 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
package progtestdata;
public class ProgTestData {
public static void main(String[] args) {
Data data = new Data();

data.setData(25, 8, 2014);
data.extenso();

1.4.6 ProgVetorSort
// ----------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java
package progvetorsort;
public class Vetor {
// -------------------------- atributos da classe
private int[] vetor;
private int n;
private final int max;
// ------------------------------------------- construtor
Vetor(int numeroElementos) {
max = numeroElementos;
vetor = new int[max];
n = 0;
}
// --------------------------------------- add
public void add(int valor) {
if (n < max) {
vetor[n] = valor;
n++;
} else {
System.out.println("ERRO: Excedeu o Limite do Vetor");
}
}
// --------------------------- remove
public void del() {
if (n > 0) {
n--;
} else {
System.out.println("ERRO: Vetor Vazio");

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 {
System.out.println("ERRO: Vetor Vazio");
}
}
// ------------------------------------------------------------- removePosicao
public void removePosicao(int posicao) {
if (n > 0 && posicao > 0 && posicao < n) {
for (int j = posicao; j < n - 1; j++) {
vetor[j] = vetor[j + 1];
}
n--;
} else {
System.out.println("ERRO: Vetor Vazio");
}
}
// --------------------------------------- primeiro
public int primeiro() {
if (n > 0) {
return (vetor[0]);
} else {
return (-1);
}
}
// --------------------------------- ultimo
public int ultimo() {
if (n > 0) {
return (vetor[n - 1]);
} else {
return (-1);
}
}
// ----------------------------------- exibe
public void exibe() {
System.out.print("Vetor: [");
for (int i = 0; i < n - 1; i++) {
System.out.print(vetor[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++) {
if (vetor[i] == valor) {
return (true);
}
}
return (false);
}
// -------------------------------------- bubbleSort
public void bubbleSort() {
int u = n - 1;
boolean trocou;
int vezes = 0;
do {
trocou = false;
for (int i = 0; i < u; i++) {
if (vetor[i] > vetor[i + 1]) {
trocou = true;
int temp = vetor[i];
vetor[i] = vetor[i + 1];
vetor[i + 1] = temp;
}
}
u--;
} while (trocou);
}
// ------------------------------------ forcaBruta
public void forcaBruta() {
int u = n - 1;
for (int i = 0; i < u; i++) {
for (int j = i + 1; j <= u; j++) {
if (vetor[i] > vetor[j]) {
int temp = vetor[i];
vetor[i] = vetor[j];
vetor[j] = temp;
}
}
}
}
}
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java
package progvetorsort;
public class ProgVetorSort {
public static void main(String[] args) {
Vetor vetor = new Vetor(5);

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;
public class Pessoa {
// -------------------------------- atributos da classe
private String nome;
private int ano;
private int idade;
private char sexo;
// ---------------------- construtor
// -------------------------------------------------------- mtodos pblicos da classe
public void setNome(String nome) {
this.nome = nome;
}
public void setAno(int ano) {
this.ano = ano;
}
public void setSexo(char sexo) {
this.sexo = sexo;
}
public void setDados(String nome, int ano, char sexo) {
setNome(nome);
setAno(ano);
setSexo(sexo);
}
public void calculaIdade() {
Date date = new Date();
// carrega a data do sistema
String data = date.toString();
// converte para String
String [] partes = data.split(" ");
// parte a data em pedaos
int n = partes.length;
// 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("Nome: " + nome);
System.out.println("Idade: " + idade + " ano(s)");
switch (sexo) {
case 'M':
case 'm': System.out.println("Sexo: Masculino");
break;
case 'F':
case 'f': System.out.println("Sexo: Feminino");
break;
}
}
// ---------------------- mtodos privados da classe
// ---------------------- mtodos esttivos da classe
}
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java
package progpessoa;
public class ProgPessoa {
public static void main(String[] args) {
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa();
Pessoa p3 = new Pessoa();

p1.setDados("Paulo Roberto", 1962, 'm');


p2.setDados("Renato Luis", 1965, 'm');
p3.setDados("Francisco Carlos", 1959, 'm');
p1.calculaIdade();
p2.calculaIdade();
p3.calculaIdade();
p1.exibePessoa();
p2.exibePessoa();
p3.exibePessoa();

1.4.8 ProgPessoa2
// ----------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java
package progpessoa2;
import java.util.Date;
public class Pessoa {
// --------------------------------- atributos da classe
private String nome;
private int ano;
private int idade;
private char sexo;

243

// ---------------------- construtor
// ------------------------------------------------------ mtodos pblicos da classe
public void setNome(String nome) {
this.nome = nome;
}
public void setAno(int ano) {
this.ano = ano;
}
public void setSexo(char sexo) {
this.sexo = sexo;
}
public void setDados(String nome, int ano, char sexo) {
setNome(nome);
setAno(ano);
setSexo(sexo);
}
public void calculaIdade() {
Date date = new Date();
String data = date.toString();
String [] partes = data.split(" ");
int n = partes.length;
int anoAtual = Integer.parseInt(partes[n-1]);
idade = anoAtual - ano;
}

// carrega a data do sistema


// converte para String
// parte a data em pedaos
// descobre o nmero de pedaos
// pega o ltimo pedao, aonde est o ano atual

public void exibePessoa() {


System.out.println("Nome: " + nome);
System.out.println("Idade: " + idade + " ano(s)");
switch (sexo) {
case 'M':
case 'm': System.out.println("Sexo: Masculino");
break;
case 'F':
case 'f': System.out.println("Sexo: Feminino");
break;
}
}

// ---------------------- mtodos privados da classe


// ---------------------- mtodos esttivos da classe

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


package progpessoa2;
public class ProgPessoa2 {
public static void main(String[] args) {
Pessoa [] pessoa = new Pessoa[3];
pessoa[0] = new Pessoa();
pessoa[0].setDados("Paulo Roberto", 1962, 'm');
pessoa[0].calculaIdade();

244

pessoa[0].exibePessoa();
pessoa[1] = new Pessoa();
pessoa[1].setDados("Renato Luis", 1960, 'm');
pessoa[1].calculaIdade();
pessoa[1].exibePessoa();

pessoa[2] = new Pessoa();


pessoa[2].setDados("Francisco Carlos", 1959, 'm');
pessoa[2].calculaIdade();
pessoa[2].exibePessoa();

1.4.9 ProgPessoas
// ----------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java
package progpessoas;
public class Pessoa {
// ---------------------------------- atributos da classe
private String[] nome;
private int[] idade;
private int n;
private final int max;
// ------------------------------------------ construtor
Pessoa(int numeroPessoas) {
this.max = numeroPessoas;
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]);
}
}
public void sort() {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nome[i].compareTo(nome[j]) > 0) {
String temp = nome[i];

245

}
}

nome[i] = nome[j];
nome[j] = temp;
int t = idade[i];
idade[i] = idade[j];
idade[j] = t;

}
// ---------------------- mtodos privados da classe
// ---------------------- mtodos esttivos da classe
}
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java
package progpessoas;
public class ProgPessoas {
public static void main(String[] args) {
Pessoa pessoa = new Pessoa(7);

pessoa.insereDados("Beatriz", 11);
pessoa.insereDados("Debora", 13);
pessoa.insereDados("Ftima", 15);
pessoa.insereDados("Geni", 16);
pessoa.insereDados("Carla", 12);
pessoa.insereDados("Eva", 14);
pessoa.insereDados("Ana", 10);
pessoa.exibeDados();
pessoa.sort();
pessoa.exibeDados();

1.4.10 ProgAgenda
// ---------------------------------------------------------------------------------------------------------------------------- Classe: Agenda.java
package progagenda;
public class Agenda {
// ----------------------------- atributos da classe
private String [] nome;
private String [] fone;
private int n;
private final int max;
// --------------------------------------------- construtor
Agenda(int numeroPessoas) {
this.max = numeroPessoas;
nome = new String[this.max];
fone = new String[this.max];
this.n = 0;
}
// ----------------------------------------------------------------------------------------- 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 {
public static void main(String[] args) {
Agenda agenda = new Agenda(5);
agenda.insereTelefone("Ana", "9981-1234");
agenda.insereTelefone("Beatriz", "9981-2345");
agenda.insereTelefone("Carla", "9981-3456");
agenda.insereTelefone("Debora", "9981-4567");
agenda.insereTelefone("Eva", "9981-5678");
agenda.insereTelefone("Ftima", "9981-6789");
String fone = "99815678";
String nome = agenda.consultaNome(fone);
if (nome.compareTo("") != 0) {
System.out.println("Nome: " + nome + " - Telefone: " + fone);
} else {
System.out.println("ERRO: Usurio no Encontrado");
}
fone = "9981-0123";
nome = agenda.consultaNome(fone);
if (nome.compareTo("") != 0) {
System.out.println("Nome: " + nome + " - Telefone: " + fone);
} else {
System.out.println("ERRO: Usurio no Encontrado");
}
}

247

Anexo 2.3 Soluo da Lista: Interface e Polimorfismo


2.3.1 ProgInterface_1
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
package proginterface_1;
public class ProgInterface_1 {
public static void main(String[] args) {

Cardeal cardeal = new Cardeal("Cardeal", "Vermelho", "Cinza");


CardealBanhado cardealBanhado = new CardealBanhado("Cardeal Banhado", "Vermelho", "preto");

cardeal.exibeNome();
cardeal.exibeCores();
cardealBanhado.exibeNome();
cardealBanhado.exibeCores();

}
// ------------------------------------------------------------------------------------------------------------------------ Interface: Passaro.java
package proginterface_1;
public interface Passaro {
public final int numeroPatas = 2;
public abstract void exibeNome();
public abstract void exibeCores();
}
// ----------------------------------------------------------------------------------------------------------------------- Classe: Cardeal.java
package proginterface_1;
public class Cardeal implements Passaro {
// ---------------------------------------- atributos da classe
private final String nome;
private final String cor_topete;
private final String cor_corpo;
Cardeal(String nome, String cor_topete, String cor_corpo) {
this.nome = nome;
this.cor_topete = cor_topete;
this.cor_corpo = cor_corpo;
}
@Override
public void exibeNome() {
System.out.println("Nome do 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
package proginterface_1;
public class CardealBanhado implements Passaro {
// --------------------------------------- atributos da classe
private final String nome;
private final String cor_topete;
private final String cor_corpo;
CardealBanhado(String nome, String cor_topete, String cor_corpo) {
this.nome = nome;
this.cor_topete = cor_topete;
this.cor_corpo = cor_corpo;
}
@Override
public void exibeNome() {
System.out.println("Nome do 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);
}

2.3.2 ProgInterface_2
// ---------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
package proginterface_2;
public class ProgInterface_2 {
public static void main(String[] args) {
Homem homem = new Homem();
Mulher mulher = new Mulher();
homem.setDados("Paulo Roberto", 52, 'm');
mulher.setDados("Adriane Maria", 45, 'f');
System.out.println(homem);
System.out.println(mulher);
}
}
// ----------------------------------------------------------------------------------------------------------------------------- Interface: Pessoa.java
package proginterface_2;
public interface Pessoa {
public abstract void setDados(String nome, int idade, char sexo);
public abstract String toString();
}

249

// ------------------------------------------------------------------------------------------------------------------------- Classe: Homem.java


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

2.3.2 ProgInterface_3
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface_1.java
package proginterface_3;
public class ProgInterface_3 {
public static void main(String[] args) {
Pessoa pessoa1 = new Pessoa();
Pessoa pessoa2 = new Pessoa();
pessoa1.set("Paulo Roberto");
pessoa1.set(52);
pessoa1.set('m');
System.out.println("Pessoa1: " + pessoa1);
pessoa2.set("Adriane Maria");
pessoa2.set(45);
pessoa2.set('f');
System.out.println("Pessoa2: " + pessoa2);
}

// -------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java


package proginterface_3;
public class Pessoa {
private String nome;
private int idade;
private char sexo;
public void set(String nome) {
this.nome = nome;
}
public void set(int idade) {
this.idade = idade;
}
public void set(char sexo) {
this.sexo = sexo;
}

251

// ------------------------------- sobrecarga do mtodo toString


@Override
public String toString() {
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;
public class Pessoa {
protected String nome;
protected String cpf;
Pessoa() {
this.nome = "xxxx";
this.cpf = "xxx.xxx.xxx-xx";
}
Pessoa(String nome, String cpf) {
this.nome = nome;
this.cpf = cpf;
}

public void imprimePessoa() {


System.out.println("Nome: " + nome);
System.out.println("CPF: " + cpf);
}

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


package progtestapessoa;
public class Cliente extends Pessoa {
private double conta;
Cliente(String nome, String cpf, double conta) {
super(nome, cpf);
this.conta = conta;
}

public void imprimeCliente() {


System.out.println("Conta: " + conta);
}

// ------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaPessoa.java


package progtestapessoa;

252

public class ProgTestaHeranca {


public static void main(String[] args) {
Cliente cliente = new Cliente("Paulo Roberto", "123.456.789-09", 1234.56);
cliente.imprimePessoa();
cliente.imprimeCliente();
}

3.4.2 Herana (Segundo)


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

public void imprimePessoa() {


System.out.println("Altura: " + altura);
System.out.println("Sexo: " + sexo);
}

// -------------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java


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

253

// ------------------------------- mtodos privados da classe


// ------------------------------- mtodos estticos da classe
}
// ------------------------------------------------------------------------------------------------------ Classe Derivada: Mulher.java
package progtestahomem;
public class Mulher extends Pessoa {
// --------------------------------------- atributos da classe
private double pesoIdeal;
// ------------------------------------------------- construtor
Mulher(double altura, char sexo) {
super(altura, sexo);
}
// ------------------------------------------------------- mtodos pblicos da classe
public void calculaPesoIdealMulher() {
pesoIdeal = 62.1 * altura - 44.7;
}
public void imprimePesoIdealMulher() {
System.out.printf("Peso Ideal (Mulher): %.2f\n", pesoIdeal);
}
// ------------------------------- mtodos privados da classe
// ------------------------------- mtodos estticos da classe
}
// --------------------------------------------------------------------------------------------- Programa Principal: ProgTestaHomem.java
package progtestahomem;
public class ProgTestaHomem {
public static void main(String[] args) {
Homem homem = new Homem(1.64, 'm');
Mulher mulher = new Mulher(1.59, 'f');

homem.calculaPesoIdealHomem();
homem.imprimePessoa();
homem.imprimePesoIdealHomem();
mulher.calculaPesoIdealMulher();
mulher.imprimePessoa();
mulher.imprimePesoIdealMulher();

3.4.3 Herana (Terceiro)


// ------------------------------------------------------------------------------------------------------------------- Classe Base: Objeto.java
package progtestaobjetos;
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
package progtestaobjetos;
public class Linha extends Objeto {
private final Objeto p1;
private final Objeto p2;
Linha (int xi, int yi, int xf, int yf) {
p1 = new Objeto(xi, yi);
p2 = new Objeto(xf, yf);
}
public void imprimeLinha(String mensagem) {
System.out.println(mensagem);
System.out.println("x: " + p1.x + " | y: " + p1.y);
p1.imprimeObjeto("p1");
System.out.println("x: " + p2.x + " | y: " + p2.y);
p2.imprimeObjeto("p2");
}
}
// -------------------------------------------------------------------------------------------------- Classe Derivada: Retangulo.java
package progtestaobjetos;
public class Retangulo extends Objeto {
private final Objeto p1;
private final Objeto p2;
private final Objeto p3;
private final Objeto p4;
Retangulo (int xi, int yi, int xf, int yf) {
p1 = new Objeto(xi, yi);
p2 = new Objeto(xf, yi);
p3 = new Objeto(xf, yf);
p4 = new Objeto(xi, yf);
}
public void imprimeRetangulo(String mensagem) {
System.out.println(mensagem);
System.out.println("x: " + p1.x + " | y: " + p1.y);
p1.imprimeObjeto("p1");

255

System.out.println("x: " + p2.x + " | y: " + p2.y);


p2.imprimeObjeto("p2");
System.out.println("x: " + p3.x + " | y: " + p3.y);
p3.imprimeObjeto("p3");
System.out.println("x: " + p4.x + " | y: " + p4.y);
p4.imprimeObjeto("p4");
}

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


package progtestaobjetos;
public class ProgTestaObjetos {
public static void main(String[] args) {
Linha linha = new Linha(1, 2, 3, 4);
Retangulo retangulo = new Retangulo(1, 2, 3, 4);
linha.imprimeLinha("Linha");
retangulo.imprimeRetangulo("Retngulo");
}

Anexo 4.4 Soluo da Lista: Entrada e Sada Bufferizada


4.4.1 ProgBuffer_1
// ---------------------------------------------------------------------------------------------- Programa Principal: ProgBuffer_1.java
package progbuffer_1;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class ProgBuffer_1 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
String text = in.readLine();
String[] partes = text.split(" ");
int n = partes.length;
out.write("Quantidade de Valores Digitados: " + n);
out.newLine();
int soma = 0;
int maior = 0, menor = 9999;
for (int i = 0; i < n; i++) {
int t = Integer.parseInt(partes[i]);
soma = soma + t;
if (t > maior) {
maior = t;
}
if (t < menor) {
menor = t;

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;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
public class ProgBuffer_2 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
String text = in.readLine();
int n = Integer.parseInt(text);
int[] vetor = new int[n];
text = in.readLine();
String[] partes = text.split(" ");
int max = partes.length;
if (max == n) {
for (int i = 0; i < n; i++) {
vetor[i] = Integer.parseInt(partes[i]);
}
Arrays.sort(vetor);
for (int i = 0; i < n; i++) {
out.write(vetor[i] + " ");
}
} else {
out.write("Erro na Entrada dos valores");
}
out.newLine();
out.flush();
}
}

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;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_1 {
public static void main(String[] args) {
ArrayList letras = new ArrayList();
ArrayList inverso = new ArrayList();
Scanner input = new Scanner(System.in);
char letra;
do {
System.out.print("Letra: ");
String s = input.nextLine();
letra = s.charAt(0);
if (letra != 'F' && letra != 'f') {
letras.add(letra);
}
} while (letra != 'F' && letra != 'f');
int n = letras.size();
int u = n - 1;
for (int i = u;i >= 0;i--) {
inverso.add(letras.get(i));
}
System.out.println(letras);
System.out.println(inverso);
}

5.6.1.2 ProgVector_2
// ---------------------------------------------------------------------------------------------------- Programa Base: ProgVector_2.java
package progvector_2;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_2 {
public static void main(String[] args) {
ArrayList <Integer> idade = new ArrayList();
Scanner input = new Scanner(System.in);
System.out.print("Nmero de Idades: ");
String s = input.nextLine();
int n = Integer.parseInt(s);
int u = n - 1;
for (int i = 0; i <= u; i++) {
System.out.print("Idade: ");

258

s = input.nextLine();
int leIdade = Integer.parseInt(s);
idade.add(leIdade);
}
char ch;
do {
int antes = 0;
System.out.print("Idade para Consulta: ");
s = input.nextLine();
int idadeConsulta = Integer.parseInt(s);
// antes = idades.indexOf(idadeConsulta);
for (int i = 0; i < n; i++) {
if (idade.get(i) != idadeConsulta) {
antes++;
} else {
break;
}
}
System.out.println("Antes: " + antes);
int depois = n - antes - 1;
System.out.println("Depois: " + depois);
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
ch = s.charAt(0);
} while (!strChr("SsNn", ch));
} while (strChr("Ss", ch));

// Sugesto do Discente: Afrnio Peres da Fonseca

// ------------------------------------------ mtodo esttico: strChr


static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return(true);
}
}
return(false);
}

5.6.1.3 ProgVector_3
// ---------------------------------------------------------------------------------------------------------- Programa Base: ProgVector_3.java
package progvector_3;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_3 {
public static void main(String[] args) {
ArrayList <Integer> numeros = new ArrayList();
Scanner input = new Scanner(System.in);
int leNumero, valor;
do {
System.out.print("Nmero: ");

259

String s = input.nextLine();
leNumero = Integer.parseInt(s);
if (leNumero != 0) {
numeros.add(leNumero);
}
} while (leNumero != 0);
int n = numeros.size();
int u = n 1;
do {
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
/*
int posicao = numeros.indexOf(valor);
if (posicao == -1) {
System.out.println("ERRO: Nmero no encontrado");
} else {
System.out.println("Posio: " + posicao);
}
*/
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");
}
}
} while (valor != 0);
}

5.6.1.4 ProgVector_4
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_4.java
package progvector_4;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_4 {
public static void main(String[] args) {
ArrayList <Character> conceito = new ArrayList();
Scanner input = new Scanner(System.in);
char ch;
do {
System.out.print("Conceito: ");
String s = input.nextLine();
ch = s.charAt(0);
if (!strChr("Ff", ch)) {
if (strChr("AaBbCcDdEe", ch)) {

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


static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}

5.6.1.5 ProgVector_5
// ---------------------------------------------------------------------------------------------- Programa Prinicpal: ProgVector_5.java
package progvector_5;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_5 {
public static void main(String[] args) {
ArrayList nomes = new ArrayList();
Scanner input = new Scanner(System.in);
String s;
char letra;
do {
System.out.print("Nome: ");
s = input.nextLine();
if (!s.equals("")) {
nomes.add(s);
}
} while (!s.equals(""));
int n = nomes.size();

261

do {
System.out.print("Letra: ");
s = input.nextLine();
if (s.equals("")) {
System.exit(0);
}
letra = s.charAt(0);
for (int i = 0; i < n; i++) {
if (nomes.get(i).toString().charAt(0) == letra) {
System.out.println("Nome: " + nomes.get(i).toString());
}
}
} while (!s.equals(""));
System.out.println("Nomes: " + nomes.toString());
}

5.6.1.6 ProgVector_6
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_6.java
package progvector_6;
import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_6 {
public static void main(String[] args) {
ArrayList <String> nome = new ArrayList<>();
ArrayList <Integer> idade = new ArrayList();
Scanner input = new Scanner(System.in);
String s;
char ch;
do {
System.out.print("Nome: ");
s = input.nextLine();
nome.add(s);
System.out.print("Idade: ");
s = input.nextLine();
int idadeDigitada = Integer.parseInt(s);
idade.add(idadeDigitada);
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
ch = s.charAt(0);
} while (!strChr("SsNn", ch));
} while (strChr("Ss", ch));
Object [] nomes = nome.toArray();
Object [] idades = idade.toArray();
int n = nome.size();
int u = n - 1;
for (int i = 0; i < u; i++) {
for (int j = i+1; j <= u; j++) {
if (idades[i].hashCode() < idades[j].hashCode()) {
Object temp = nomes[i];
nomes[i] = nomes[j];
nomes[j] = temp;

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
public static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return(true);
}
}
return(false);
}

5.6.1.7 ProgVector_7
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_7.java
package progvector_7;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class ProgVector_7 {
public static void main(String[] args) {
ArrayList nome = new ArrayList();
Scanner input = new Scanner(System.in);
String s;
do {
System.out.print("Nome: ");
s = input.nextLine();
if (!s.equals("")) {
nome.add(s);
}
} while (!s.equals(""));
Object [] vetor = nome.toArray();
Arrays.sort(vetor);
System.out.println(Arrays.toString(vetor));
}
}

5.6.1.8 ProgVector_8
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_8.java
package progvector_8;

263

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class ProgVector_8 {
public static void main(String[] args) {
ArrayList <Integer> idade = new ArrayList();
Scanner input = new Scanner(System.in);
int leIdade;
do {
System.out.print("Idade: ");
String s = input.nextLine();
leIdade = Integer.parseInt(s);
if (leIdade != 0) {
idade.add(leIdade);
}
} while (leIdade != 0);
Object [] idades = idade.toArray();
Arrays.sort(idades);
System.out.print("Idades Ordenadas: ");
int n = idades.length;
double soma = 0.0;
for (int i = 0; i < n; i++) {
System.out.print(idades[i] + " ");
soma = soma + idades[i].hashCode();
}
System.out.println("\nMaior Idade: " + idades[n-1]);
System.out.println("Menor Idade: " + idades[0]);
double media = soma / n;
System.out.println("Mdia: " + media);
}
}

5.6.1.9 ProgVector_9
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVector_9.java
package progvector_9;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class ProgVector_9 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
String text = in.readLine();
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();

5.6.1.10 ProgVector_10
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_10.java
package progvector_10;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class ProgVector_10 {
public static void main(String[] args) {
ArrayList megaSena = new ArrayList();
Scanner input = new Scanner(System.in);
int numeroPalpites;
do {
System.out.print("Nmero de Palpites para a MegaSena: ");
String s = input.nextLine();
numeroPalpites = Integer.parseInt(s);
} while (numeroPalpites < 0);
for (int i = 1; i <= numeroPalpites; i++) {
int numeroAleatorio = 1 + (int) (Math.random() * 100);
megaSena.add(numeroAleatorio);
for (int j = 1; j <= 5; j++) {
numeroAleatorio = 1 + (int) (Math.random() * 100);
if (!testaRepetido(megaSena, numeroAleatorio)) {
megaSena.add(numeroAleatorio);
}
}
Object[] temp = megaSena.toArray();
Arrays.sort(temp);
megaSena.removeAll(megaSena);
int n = temp.length;
for (int k = 0; k < n; k++) {
megaSena.add(temp[k]);
}
System.out.println("Palpite para MegaSena " + megaSena.toString());

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

5.6.1.11 ProgVector_11
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_11.java
package progvector_11;
import java.util.LinkedList;
import java.util.Scanner;
public class ProgVector_11 {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
Scanner input = new Scanner(System.in);
char opcao, lado;
Object valor;
do {
do {
System.out.print("[I]ncluir, [C]onsultar, [R]emover ou [F]im: ");
String s = input.nextLine();
opcao = s.charAt(0);
} while (!strChr("IiCcRrFf", opcao));
if (strChr("Ff", opcao)) {
System.exit(0);
}
do {
System.out.print("[E]squerda ou [D]ireita ");
String s = input.nextLine();
lado = s.charAt(0);
} while (!strChr("EeDd", lado));
switch (opcao) {
case 'I':
case 'i':
System.out.print("Dado: ");
String s = input.nextLine();
int dado = Integer.parseInt(s);
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
lista.addFirst(dado);
break;

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();
System.out.println("Dado Consultado: " + valor);
break;
}
break;
case 'R':
case 'r':
switch (lado) {
case 'E':
case 'e':
if (!lista.isEmpty()) {
valor = lista.removeFirst();

System.out.println("Dado Removido esquerda: " + valor);

} else {
System.out.println("ERRO: Lista Vazia");
}
break;
case 'D':
case 'd':
if (!lista.isEmpty()) {
valor = lista.removeLast();
System.out.println("Dado Removido Direita: " + valor);
} else {
System.out.println("ERRO: Lista Vazia");
}
break;
}
break;

}
System.out.println("LinkedList: " + lista);
} while (true);

static boolean strChr(String s, char ch) {


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

267

5.6.1.12 ProgVector_12
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVector_12.java
package progvector_12;
import java.util.LinkedList;
import java.util.Scanner;
public class ProgVector_12 {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
Scanner input = new Scanner(System.in);
char opcao, lado;
Object valor;
int posicao;
do {
do {
System.out.print("[I]ncluir, [C]onsultar, [R]emover ou [F]im: ");
String s = input.nextLine();
opcao = s.charAt(0);
} while (!strChr("IiCcRrFf", opcao));
if (strChr("Ff", opcao)) {
System.exit(0);
}
do {
System.out.print("[E]squerda, [P]osio [D]ireita: ");
String s = input.nextLine();
lado = s.charAt(0);
} while (!strChr("EePpDd", lado));
switch (opcao) {
case 'I':
case 'i':
System.out.print("Dado: ");
String s = input.nextLine();
int dado = Integer.parseInt(s);
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
lista.addFirst(dado);
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
int n = lista.size();
if (posicao >= 0 && posicao < n) {
lista.add(posicao, dado);
} else {
System.out.println("ERRO: Posio Invlida");
}
break;

268

case 'D':
case 'd':
lista.addLast(dado);
break;
}
}
break;
case 'C':
case 'c':
switch (lado) {
case 'E':
case 'e':
valor = lista.getFirst();
System.out.println("Dado Consultado: " + valor);
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
int n = lista.size();
if (posicao >= 0 && posicao < n) {
valor = lista.get(posicao);
System.out.println("Dado Consultado: " + valor);
} else {
System.out.println("ERRO: Posio Invlida");
}
break;
case 'D':
case 'd':
valor = lista.getLast();
System.out.println("Dado Consultado: " + valor);
break;
}
break;
case 'R':
case 'r':
switch (lado) {
case 'E':
case 'e':
if (!lista.isEmpty()) {
valor = lista.removeFirst();
System.out.println("Dado Removido esquerda: " + valor);

} else {
System.out.println("ERRO: Lista Vazia");
}
break;
case 'P':
case 'p':
System.out.print("Posio: ");
s = input.nextLine();
posicao = Integer.parseInt(s);
int n = lista.size();
if (posicao >= 0 && posicao < n) {
valor = lista.remove(posicao);

System.out.println("Dado Removido da Posio: " + valor);

} else {
System.out.println("ERRO: Posio Invlida");
}

269

break;
case 'D':
case 'd':
if (!lista.isEmpty()) {
valor = lista.removeLast();
System.out.println("Dado Removido Direita: " + valor);
} else {
System.out.println("ERRO: Lista Vazia");
}
break;
}
break;

}
System.out.println("LinkedList: " + lista);
} while (true);

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


static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}
}

5.6.1.13 ProgVector_13
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_13.java
package progvector_13;
import java.util.LinkedList;
import java.util.Scanner;
public class ProgVector_13 {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
Scanner input = new Scanner(System.in);
char opcao, lado = 'E';
Object valor;
do {
do {
System.out.print("[I]ncluir, [E]lemento, [R]emover ou [F]im: ");
String s = input.nextLine();
opcao = s.charAt(0);
} while (!strChr("IiEeRrFf", opcao));
if (strChr("Ff", opcao)) {
System.exit(0);
}
if (strChr("IiRr", opcao)) {
do {
System.out.print("[E]squerda ou [D]ireita ");
String s = input.nextLine();

270

lado = s.charAt(0);
} while (!strChr("EeDd", lado));

}
switch (opcao) {
case 'I':
case 'i':
System.out.print("Dado: ");
String s = input.nextLine();
int dado = Integer.parseInt(s);
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
lista.addFirst(dado);
break;
case 'D':
case 'd':
lista.addLast(dado);
break;
}
}
break;
case 'E':
case 'e':
System.out.print("Elemento a Pesquisar: ");
s = input.nextLine();
int elemento = Integer.parseInt(s);
int indice = lista.indexOf(elemento);
if (indice - 1 >= 0) {
System.out.println("Antecessor: " + lista.get(indice - 1));
} else {
System.out.println("ERRO: SEM ANTECESSOR");
}
if (indice + 1 < lista.size()) {
System.out.println("Sucessor: " + lista.get(indice + 1));
} else {
System.out.println("ERRO: SEM SUCESSOR");
}
break;
case 'R':
case 'r':
switch (lado) {
case 'E':
case 'e':
if (!lista.isEmpty()) {
valor = lista.removeFirst();
System.out.println("Dado Removido esquerda: " + valor);

} else {
System.out.println("ERRO: Lista Vazia");
}
break;
case 'D':
case 'd':
if (!lista.isEmpty()) {
valor = lista.removeLast();
System.out.println("Dado Removido Direita: " + valor);
} else {
System.out.println("ERRO: Lista Vazia");
}

271

break;
}
break;
}
System.out.println("LinkedList: " + lista);
} while (true);
}

static boolean strChr(String s, char ch) {


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

5.6.1.14 ProgVector_14
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_14.java
package progvector_14;
import java.util.LinkedList;
import java.util.Scanner;
public class ProgVector_14 {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
Scanner input = new Scanner(System.in);
char opcao, lado = 'E';
Object valor;
do {
do {

System.out.print("[I]ncluir, [E]lemento, [R]emover, [P]esquisar ou [F]im: ");

String s = input.nextLine();
opcao = s.charAt(0);
} while (!strChr("IiEeRrPpFf", opcao));
if (strChr("Ff", opcao)) {
System.exit(0);
}
if (strChr("IiRr", opcao)) {
do {
System.out.print("[E]squerda ou [D]ireita: ");
String s = input.nextLine();
lado = s.charAt(0);
} while (!strChr("EeDd", lado));
}
switch (opcao) {
case 'I':
case 'i':
System.out.print("Dado: ");
String s = input.nextLine();
int dado = Integer.parseInt(s);
if (dado != 0) {

272

switch (lado) {
case 'E':
case 'e':
lista.addFirst(dado);
break;
case 'D':
case 'd':
lista.addLast(dado);
break;
}
}
break;
case 'E':
case 'e':
System.out.print("Elemento a Pesquisar: ");
s = input.nextLine();
int elemento = Integer.parseInt(s);
int indice = lista.indexOf(elemento);
if (indice - 1 >= 0) {
System.out.println("Antecessor: " + lista.get(indice - 1));
} else {
System.out.println("ERRO: SEM ANTECESSOR");
}
if (indice + 1 < lista.size()) {
System.out.println("Sucessor: " + lista.get(indice + 1));
} else {
System.out.println("ERRO: SEM SUCESSOR");
}
break;
case 'R':
case 'r':
switch (lado) {
case 'E':
case 'e':
if (!lista.isEmpty()) {
valor = lista.removeFirst();
System.out.println("Dado Removido esquerda: " + valor);

} else {
System.out.println("ERRO: Lista Vazia");
}
break;
case 'D':
case 'd':
if (!lista.isEmpty()) {
valor = lista.removeLast();
System.out.println("Dado Removido Direita: " + valor);
} else {
System.out.println("ERRO: Lista Vazia");
}
break;

}
break;
case 'P':
case 'p':
System.out.print("Indice: ");
s = input.nextLine();
indice = Integer.parseInt(s);
if (indice >= 0 && indice < lista.size()) {
valor = lista.get(indice);

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.printf("%3d ", i);
}
System.out.println("\nLinkedList: " + lista);
} while (true);
}
static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}
}

5.6.1.15 ProgVector_15
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgVector_15.java
package progvector_15;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;
public class ProgVector_15 {
public static void main(String[] args) {
LinkedList lista = new LinkedList();
Scanner input = new Scanner(System.in);
char opcao, lado = 'E';
Object valor;
do {
do {
System.out.print("[I]ncluir, [S]ort, [C]lear All ou [F]im: ");
String s = input.nextLine();
opcao = s.charAt(0);
} while (!strChr("IiSsCcFf", opcao));
if (strChr("Ff", opcao)) {
System.exit(0);
}
if (strChr("Ii", opcao)) {
do {
System.out.print("[E]squerda ou [D]ireita: ");
String s = input.nextLine();
lado = s.charAt(0);
} while (!strChr("EeDd", lado));
}

274

switch (opcao) {
case 'I':
case 'i':
System.out.print("Dado: ");
String s = input.nextLine();
int dado = Integer.parseInt(s);
if (dado != 0) {
switch (lado) {
case 'E':
case 'e':
lista.addFirst(dado);
break;
case 'D':
case 'd':
lista.addLast(dado);
break;
}
}
break;
case 'S':
case 's':
Object[] objetos = lista.toArray();
Arrays.sort(objetos);
lista.clear();
for (int i = 0; i < objetos.length; i++) {
lista.add(objetos[i]);
}
break;
case 'C':
case 'c':
lista.clear();
break;
}
System.out.print(" Indices: ");
for (int i = 0; i < lista.size(); i++) {
System.out.printf("%3d ", i);
}
System.out.println("\nLinkedList: " + lista);
} while (true);

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


static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}
}

5.6.1.16 ProgVector_16
// ----------------------------------------------------------------------------------------------- Programa Principal: ProgVector_16.java
package progvector_16;

275

import java.util.ArrayList;
import java.util.Scanner;
public class ProgVector_16 {
public static void main(String[] args) {
ArrayList<Integer> array = new ArrayList();
Scanner input = new Scanner(System.in);
Integer info = 999;
do {
System.out.print("Info: ");
String s = input.nextLine();
if (!s.equals("")) {
if (info == 999) {
array.add(Integer.parseInt(s));
info++;
} else {
info = Integer.parseInt(s);
if (info != 0) {
int posicao = verificaPosicao(array, info);
if (posicao != -1) {
array.add(posicao, info);
} else {
System.out.println("ERRO: 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;
import java.util.Scanner;
public class ProgString_1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int vogais = 0, consoantes, espacos = 0;
int maiusculas = 0, minusculas;

System.out.print("Nome: ");
String nome = input.nextLine();
int totalLetras = nome.length();
for (int i = 0;i < totalLetras;i++) {
if ("AaEeIiOoUu".indexOf(nome.charAt(i)) != -1) {
vogais++;
}
if (nome.charAt(i) == 32) {
// 32 o ' ' (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);

5.8.2.2 ProgString_2
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_2.java
package progstring_2;
import java.util.Scanner;
public class ProgString_2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
char digito;
do {
int contaLetras = 0;
System.out.print("Palavra: ");

277

String palavra = input.nextLine();


System.out.print("Letra: ");
String s = input.nextLine();
char letra = s.charAt(0);
int n = palavra.length();
for (int i = 0; i < n; i++) {
if (palavra.charAt(i) == letra) {
contaLetras++;
}
}
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? ");
s = input.nextLine();
digito = s.charAt(0);
} while ("SsNn".indexOf(digito) == -1);
} while ("Ss".indexOf(digito) != -1);
}

5.8.2.3 ProgString_3
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgString_3.java
package progstring_3;
import java.util.Scanner;
public class ProgString_3 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
char antecessora = 'X', sucessora = 'Y';
System.out.print("Palavra: ");
String palavra = input.nextLine();
System.out.print("Posio: ");
String s = input.nextLine();
int posicao = Integer.parseInt(s);
int n = palavra.length();
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);

}
}

5.8.2.4 ProgString_4
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_4.java
package progstring_4;
import java.util.Scanner;
public class ProgString_4 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
String [] partes = nome.split(" ");
int n = partes.length;
// 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]);
}
}

5.8.2.5 ProgString_5
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_5.java
package progstring_5;
import java.util.Scanner;
public class ProgString_5 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
String[] partes = nome.split(" ");
int n = partes.length;
int u = n - 1;
System.out.println(partes[u].toUpperCase());
}

5.8.2.6 ProgString_6
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgString_6.java
package progstring_6;

279

import java.util.Scanner;
public class ProgString_6 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
nome = corrigeNome(nome);
System.out.println("Nome corrigido: " + nome);
String[] partes = nome.split(" ");
int n = partes.length;
System.out.print(partes[n - 1] + ", " + partes[0] + " ");
for (int i = 1;i < n-1;i++) {
System.out.print(partes[i].charAt(0) + ". ");
}
System.out.println();
}
static String corrigeNome(String nome) {
nome = nome.toLowerCase();
int n = nome.length();
String temp = "";
temp = temp + Character.toUpperCase(nome.charAt(0));
for (int i = 1; i < n; i++) {
if (nome.charAt(i) == 32) {
temp = temp + " " + Character.toUpperCase(nome.charAt(i + 1));
i++;
} else {
temp = temp + nome.charAt(i);
}
}
return (temp);
}
}

5.8.2.7 ProgString_7
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgString_7.java
package progstring_7;
import java.util.Scanner;
public class ProgString_7 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Estado: ");
String estado = input.nextLine();
estado = converteString(estado);
System.out.println("Estado corrigido: " + estado);
String [] partes = estado.split(" ");
int n = partes.length;
if (n >= 2) {

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

5.8.2.8 ProgString_8
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgString_8.java
package progstring_8;
import java.util.Scanner;
public class ProgString_8 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Palavra: ");
String palavra = input.nextLine();
int n = palavra.length();
System.out.print("Incio: ");
String s = input.nextLine();
int inicio = Integer.parseInt(s);
if (inicio < 0) {
System.out.println("ERRO: Incio Invlido");
System.exit(0);
}
System.out.print("Fim: ");
s = input.nextLine();
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

}
System.out.println();

Anexo 6.4 Soluo da Lista: Listas Lineares


6.4.1 ProgLista_1
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_1.java
package proglista_1;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_1 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
String s;

do {
System.out.print("Nome: ");
s = input.nextLine();
} while (s.equals(""));
String [] partes = s.split(" ");
int n = partes.length;
for (int i = 0;i < n;i++) {
pilha.push(partes[i].charAt(0));
}
int totalLetras = 0;
System.out.print("Abreviatura: ");
do {
Character letra = (Character) pilha.pop();
System.out.print(letra);
totalLetras++;
} while (!pilha.empty());
System.out.println();
System.out.println("Pilha: " + pilha.toString());
System.out.println("Total de Letras: " + totalLetras);

// cast

6.4.2 ProgLista_2
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_2.java
package proglista_2;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class ProgLista_2 {

282

public static void main(String[] args) {


Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
int espacos = 0;
String s;
do {
System.out.print("Nome: ");
s = input.nextLine();
} while (s.equals(""));
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) != 32) {
fila.offer(s.charAt(i));
// insere na Fila
} else {
espacos++;
}
}
System.out.print("Nome Modificado: ");
do {
Character letra = (Character) fila.poll(); // remove da fila - cast
System.out.print(letra);
} while (!fila.isEmpty());
System.out.println();
System.out.println("Nmero de Espaos Eliminados: " + espacos);
}

6.4.3 ProgLista_3
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_3.java
package proglista_3;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_3 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
String nome;
int homens = 0, mulheres = 0, indeterminados = 0;
do {
System.out.print("Nome: ");
nome = input.nextLine();
if (nome.compareTo("") != 0) {
int n = nome.length();
int u = n - 1;
switch (nome.charAt(u)) {
case 'A':
case 'a':
pilha.push('f');
mulheres++;
break;
case 'O':
case 'o':

283

pilha.push('m');
homens++;
break;
default:
pilha.push('i');
indeterminados++;

}
}
} while (nome.compareTo("") != 0);
System.out.println("Pilha: " + pilha.toString());
System.out.println(homens + " homens");
System.out.println(mulheres + " mulheres");
System.out.println(indeterminados + " indeterminados");

6.4.4 ProgLista_4
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_4.java
package proglista_4;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class ProgLista_4 {
public static void main(String[] args) {
Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
String nome;
do {
System.out.print("Nome: ");
nome = input.nextLine();
if (!nome.equals("")) {
fila.offer(nome);
}
} while (!nome.equals(""));
Object [] temp = fila.toArray();
Arrays.sort(temp);
System.out.println("Fila: " + Arrays.toString(temp));
}

6.4.5 ProgLista_5
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgLista_5.java
package proglista_5;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class ProgLista_5 {

284

public static void main(String[] args) {


Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
Integer valor, quantidade;

do {
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
System.out.print("Quantidade: ");
s = input.nextLine();
quantidade = Integer.parseInt(s);
fila.offer(valor);
fila.offer(quantidade);
}
} while (valor != 0);
int totalImpresso = 0;
System.out.println("Fila: " + fila.toString());
do {
valor = (Integer) fila.poll();
// cast
quantidade = (Integer) fila.poll();
// cast
for (int i = 1;i <= quantidade;i++) {
System.out.print(valor + " ");
totalImpresso++;
}
} while (!fila.isEmpty());
System.out.println();
System.out.println("Total de Valores Impressos: " + totalImpresso);

6.4.6 ProgLista_6
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgLista_6.java
package proglista_6;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_6 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
String nome;
do {
System.out.print("Nome: ");
nome = input.nextLine();
if (!nome.equals("")) {
int n = nome.length();
pilha.push(n);
}
} while (!nome.equals(""));
System.out.println("Pilha: " + pilha.toString());
if (!pilha.isEmpty()) {

285

int i = 0;
int totalCaracteres = 0, totalNomes = 0;
do {
Integer tamanho = (Integer) pilha.pop();
totalCaracteres = totalCaracteres + tamanho;
totalNomes++;
} while (!pilha.empty());
System.out.println("Total de Caracteres: " + totalCaracteres + " letra(s)");
System.out.println("Total de Nomes: " + totalNomes);
System.out.println("Pilha: " + pilha.toString());
}

6.4.7 ProgLista_7
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_7.java
package proglista_7;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_7 {
public static void main(String[] args) {
Stack pilha = new Stack();
Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
int n = nome.length();
for (int i = 0; i < n; i++) {
if (strChr("AaEeIiOoUu", nome.charAt(i))) {
pilha.push(nome.charAt(i));
} else {
if (nome.charAt(i) != 32) {
fila.offer(nome.charAt(i));
}
}
}
System.out.println("Fila: " + fila.toString());
System.out.println("Pilha: " + pilha.toString());
}
static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ch) {
return (true);
}
}
return (false);
}
}

286

6.4.8 ProgLista_8
// ------------------------------------------------------------------------------------------- Programa Principal: ProgLista_8.java
package proglista_8;
import java.util.Scanner;
import java.util.Stack;
public class Lista_8 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
int n = nome.length();
for (int i = 0;i < n;i++) {
pilha.push(nome.charAt(i));
}
System.out.print("Nome Invertido: ");
do {
Character letra = (Character) pilha.pop();
System.out.printf("%c", letra);
} while (!pilha.empty());
System.out.println();
}

6.4.9 ProgLista_9
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_9.java
package proglista_9;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_9 {
public static void main(String[] args) {
Stack pilha = new Stack();
Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
int n = nome.length();
for (int i = 0;i < n;i++) {
if (strChr("AaEeIiOoUu", nome.charAt(i))) {
pilha.push(nome.charAt(i));
} else {
if (nome.charAt(i) != 32) {
fila.offer(nome.charAt(i));
}
}

287

}
System.out.println("Fila: " + fila.toString());
int consoantes = 0;
do {
fila.poll();
consoantes++;
} while (!fila.isEmpty());
System.out.println("Total de Consoantes: " + consoantes);
System.out.println("Fila: " + fila.toString());
System.out.println("Pilha: " + pilha.toString());
int vogais = 0;
do {
pilha.pop();
vogais++;
} while (!pilha.empty());
System.out.println("Total de Vogais: " + vogais);
System.out.println("Pilha: " + pilha.toString());
System.out.println("Total de Letras: " + (consoantes + vogais));
}
static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0;i < n;i++) {
if (s.charAt(i) == ch) {
return(true);
}
}
return(false);
}
}

6.4.10 ProgLista_10
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_10.java
package proglista_10;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_10 {
public static void main(String[] args) {
Stack pilha = new Stack();
Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
System.out.print("Nome: ");
String nome = input.nextLine();
String [] partes = nome.split(" ");
int n = partes.length;
for (int i = 0;i < n;i++) {
fila.offer(partes[i]);
pilha.push(partes[i].charAt(0));
}
System.out.println("Fila: " + fila.toString());
System.out.println("Pilha: " + pilha.toString());
}

288

6.4.11 ProgLista_11
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_11.java
package proglista_11;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_11 {
public static void main(String[] args) {
Stack p1 = new Stack();
Stack p2 = new Stack();
Scanner input = new Scanner(System.in);
int valor;

do {
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
p1.push(valor);
p2.push(valor * 2);
}
} while (valor != 0);
System.out.println("p1: " + p1.toString());
System.out.println("p2: " + p2.toString());
int n = p1.size();
Integer [] vetor = new Integer[n * 2];
int i;
for (i = 0;i < n;i++) {
vetor[i] = (Integer) p1.pop();
}
int j;
for (j = i;j < n * 2;j++) {
vetor[j] = (Integer) p2.pop();
}
Arrays.sort(vetor);
System.out.print("Pilhas: ");
for (i = 0;i < n*2;i++) {
System.out.print(vetor[i] + " ");
}
System.out.println();

6.4.12 ProgLista_12
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_12.java
package proglista_12;
import java.util.LinkedList;
import java.util.Queue;

289

import java.util.Scanner;
public class ProgLista_12 {
public static void main(String[] args) {
Queue f1 = new LinkedList();
Queue f2 = new LinkedList();
Scanner input = new Scanner(System.in);
int maior = 0, menor = 999;
Integer valor;

do {
System.out.print("Valor: ");
String s = input.nextLine();
valor = Integer.parseInt(s);
if (valor != 0) {
f1.offer(valor);
if (valor > maior) {
maior = valor;
}
if (valor < menor) {
menor = valor;
}
}
} while (valor != 0);
do {
valor = (Integer) f1.poll() * 3;
f2.offer(valor);
if (valor > maior) {
maior = valor;
}
if (valor < menor) {
menor = valor;
}
} while (!f1.isEmpty());
System.out.println("f1: " + f1.toString());
System.out.println("f2: " + f2.toString());
System.out.println("Maior: " + maior);
System.out.println("Menor: " + menor);

6.4.13 ProgLista_13
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_13.java
package proglista_13;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_13 {
public static void main(String[] args) {
Stack pilha = new Stack();
Scanner input = new Scanner(System.in);
System.out.print("Palavra: ");
String palavra = input.nextLine();

290

int n = palavra.length();
for (int i = 0;i < n;i++) {
pilha.push(palavra.charAt(i));
}
int totalLetras = 0;
System.out.print("Palavra Invertida: ");
do {
Character letra = (Character) pilha.pop();
System.out.print(letra);
totalLetras++;
} while (!pilha.empty());
System.out.println();
System.out.println("Total de Letras: " + totalLetras);

6.4.14 ProgLista_14
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_14.java
package proglista_14;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class ProgLista_14 {
public static void main(String[] args) {
Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);

do {
System.out.print("Valor Inicial: ");
String s = input.nextLine();
int valorInicial = Integer.parseInt(s);
if (valorInicial == 0) {
System.exit(0);
}
System.out.print("Valor Final: ");
s = input.nextLine();
int valorFinal = Integer.parseInt(s);
System.out.print("Intervalo: ");
s = input.nextLine();
int intervalo = Integer.parseInt(s);
if (valorInicial < valorFinal) {
for (int i = valorInicial; i <= valorFinal; i = i + intervalo) {
fila.offer(i);
}
} else {
for (int i = valorInicial; i >= valorFinal; i = i - intervalo) {
fila.offer(i);
}
}
System.out.println("Fila: " + fila.toString());
} while (true);

291

6.4.15 ProgLista_15
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgLista_15.java
package proglista_15;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class ProgLista_15 {
public static void main(String[] args) {
Stack pilha = new Stack();
Queue fila = new LinkedList();
Scanner input = new Scanner(System.in);
Integer nodo = 0;
do {
System.out.print("Nodo: ");
String s = input.nextLine();
if (!s.equals("")) {
nodo = Integer.parseInt(s);
if (nodo != 0) {
pilha.push(nodo);
fila.offer(nodo * 2);
}
}
} while (nodo != 0);
int n = pilha.size();
if (n > 0) {
System.out.println("Pilha: " + pilha);
System.out.println("Topo da Pilha: " + pilha.lastElement());
System.out.println("Base da Pilha: " + pilha.firstElement());
System.out.println("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.Arrays;
import java.util.LinkedHashMap;

292

public class ProgMap_1 {

public static void main(String[] args) {


LinkedHashMap pessoa = new LinkedHashMap();
pessoa.put(2, "Carla");
pessoa.put(4, "Eva");
pessoa.put(0, "Ana");
pessoa.put(1, "Beatriz");
pessoa.put(3, "Debora");
for (Object key : pessoa.keySet()) {
System.out.printf("%-7s -> (%d)\n", pessoa.get(key), key);
}
int n = pessoa.size();
String[] partes = new String[n];
String s = "";
for (int i = 0; i < partes.length; i++) {
partes[i] = pessoa.get(i).toString();
}
Arrays.sort(partes);
System.out.print("Mapa: ");
for (String parte : partes) {
System.out.print(parte + " ");
}
System.out.println();
}

7.2.2 ProgMap_2
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgMap_2.java
package progmap_2;
import java.util.TreeMap;
public class ProgMap_2 {
public static void main(String[] args) {
TreeMap<String, Integer> alunos = new TreeMap<>();
alunos.put("Carla", 67);
alunos.put("Debora", 68);
alunos.put("Beatriz", 66);
alunos.put("Ana", 65);
for (String key : alunos.keySet()) {
System.out.printf("%-7s -> %c\n",key, alunos.get(key));
}
System.out.println("keySet: " + alunos.keySet());
alunos.clear();
}

7.2.3 ProgMap_3
// ------------------------------------------------------------------------------------------------ Programa Principal: ProgMap_3.java
package progmap_3;

293

import java.util.HashMap;
import java.util.Map;
public class ProgMap_3 {
public static void main(String[] args) {
Map<Integer, String> mapa = new HashMap<>();
mapa.put(5, "Eva");
mapa.put(2, "Beatriz");
mapa.put(3, "Carla");
mapa.put(1, "Ana");
mapa.put(4, "Debora");
int n = mapa.size();
for (int i = 1; i <= n; i++) {
System.out.printf("Chave: %d | Pessoa: %-7s | Bytes: %d\n", i, mapa.get(i), mapa.get(i).length());
}
}
}

7.2.4 ProgMap_4
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgMap_4.java
package progmap_4;
import java.util.Hashtable;
public class ProgMap_4 {
public static void main(String[] args) {
Hashtable pessoa = new Hashtable();

pessoa.put(20, "Beatriz"); // chave, valor


pessoa.put(30, "Carla"); // chave, valor
pessoa.put(10, "Ana");
// chave, valor
System.out.println("Tamanho da Hashtable: " + pessoa.size());
System.out.println("Chaves: " + pessoa.keySet());
System.out.println("Valor: " + pessoa.values());

7.2.5 ProgMap_5
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgMap_5.java
package progmap_5;
import java.util.HashMap;
import java.util.Map;
public class ProgMap_5 {
public static void main(String[] args) {
Map<String, String> mapa = new HashMap<>();
mapa.put("E", "Eva");
mapa.put("B", "Beatriz");
mapa.put("C", "Carla");

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;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Nome do Arquivo Texto: ");
String nomeArquivo = input.nextLine();
try {
long bytes;
int linhas;
int brancas;
try (FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto)) {
bytes = 0;
linhas = 0;
brancas = 0;
while ((linha = leitor.readLine()) != null) {
System.out.println(linha);
bytes = bytes + linha.length();
linhas++;
if ("".equals(linha)) {
brancas++;
}
}
arqTexto.close();
}
System.out.println("(" + bytes + ") Bytes");
System.out.println("(" + linhas + ") Linhas");
System.out.println("(" + brancas + ") Brancas");
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}
}
}

295

8.6.2 ProgFile_2
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_2.java
package progfile_2;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Nome do Arquivo Texto: ");
String nomeArquivo = input.nextLine();
try {
int nl;
do {
try (FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto)) {
boolean encontrouLinha = false;
System.out.print("Linha: ");
String s = input.nextLine();
nl = Integer.parseInt(s);
int linhas = 0;
while ((linha = leitor.readLine()) != null) {
linhas++;
if (nl == linhas) {
System.out.println(nl + ": " + linha);
encontrouLinha = true;
}
}
if (!encontrouLinha && nl != 0) {
System.out.println("ERRO: Linha no existe");
}
if (nl == 0) {
arqTexto.close();
}

}
} while (nl != 0);
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}
}

8.6.3 ProgFile_3
// --------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_3.java
package progfile_3;
import java.io.BufferedReader;

296

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_3 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Arquivo Origem: ");
String arquivoOrigem = input.nextLine();
System.out.print("Arquivo Destino: ");
String arquivoDestino = input.nextLine();
long bytes = 0;
try {
FileWriter arqDestino;
try (FileReader arqOrigem = new FileReader(arquivoOrigem);
BufferedReader leitor = new BufferedReader(arqOrigem)) {
arqDestino = new FileWriter(arquivoDestino);
while ((linha = leitor.readLine()) != null) {
bytes = bytes + linha.length();
arqDestino.write(linha + "\n");
} System.out.println("(" + bytes + ") Bytes copiados");
arqOrigem.close();
}
arqDestino.close();
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo Origem");
}
}

8.6.4 ProgFile_4
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_4.java
package progfile_4;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_4 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Arquivo Origem: ");
String arquivoOrigem = input.nextLine();
System.out.print("Arquivo Destino: ");
String arquivoDestino = input.nextLine();
System.out.print("[+] Maisculo ou [-] Minsculo: ");
String s = input.nextLine();

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);
while ((linha = leitor.readLine()) != null) {
bytes = bytes + linha.length();
if (tipo == '+') {
arqDestino.write(linha.toUpperCase() + "\n");
} else {
arqDestino.write(linha.toLowerCase() + "\n");
}
} System.out.println("(" + bytes + ") Bytes copiados");
arqOrigem.close();
}
arqDestino.close();
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo Origem");
}
}

8.6.5 ProgFile_5
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_5.java
package progfile_5;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_5 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
boolean existe = false;
System.out.print("Nome do Arquivo Texto: ");
String nomeArquivo = input.nextLine();
System.out.print("Palavra: ");
String palavra = input.nextLine();
try {
try (FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto)) {
int line = 1;
while ((linha = leitor.readLine()) != null) {
if (linha.contains(palavra)) {
System.out.println(line + ": " + linha);
existe = true;
}
line++;
}
arqTexto.close();

298

if (!existe) {
System.out.println("Erro: Palavra no existe");
}

}
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}

8.6.6 ProgFile_6
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_6.java
package progfile_6;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_6 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Nome do Arquivo Texto: ");
String nomeArquivo = input.nextLine();
try {
int nli, nlf;
try (FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto)) {
boolean encontrouLinha = false;
System.out.print("Nmero inicial: ");
String s = input.nextLine();
nli = Integer.parseInt(s);
System.out.print("Nmero final: ");
s = input.nextLine();
nlf = Integer.parseInt(s);
if (nli > nlf) {
int temp = nli;
nli = nlf;
nlf = temp;
}
int line = 1;
while ((linha = leitor.readLine()) != null) {
if (line >= nli && line <= nlf) {
System.out.println(line + ": " + linha);
encontrouLinha = true;
}
line++;
}
arqTexto.close();
if (!encontrouLinha) {

299

System.out.println("ERRO: Linha no existe");


}

}
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}
}

8.6.7 ProgFile_7
// ------------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_7.java
package progfile_7;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_7 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String palavra;

System.out.print("Nome do Arquivo Texto: ");


String nomeArquivo = input.nextLine();
try {
try (FileWriter arqTexto = new FileWriter(nomeArquivo)) {
do {
System.out.print("Palavra: ");
palavra = input.nextLine();
if (!"".equals(palavra)) {
arqTexto.write(palavra + "\n");
}
} while (!"".equals(palavra));
arqTexto.close();
}
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}

8.6.8 ProgFile_8
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgFile_8.java
package progfile_8;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class ProgFile_8 {

300

public static void main(String[] args) {


Scanner input = new Scanner(System.in);
String linha;

System.out.print("Nome do Arquivo Texto: ");


String nomeArquivo = input.nextLine();
try {
try (FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto)) {
while ((linha = leitor.readLine()) != null) {
System.out.println(linha);
}
arqTexto.close();
}
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}

8.6.9 ProgFile_9
// --------------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_9.java
package progfile_9;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Scanner;
public class ProgFile_9 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Nome do Arquivo Texto Origem: ");
String arqOrigem = input.nextLine();
System.out.print("Nome do Arquivo Texto Destino: ");
String arqDestino = input.nextLine();
try {
FileWriter destino;
try (RandomAccessFile origem = new RandomAccessFile(arqOrigem, "r")) {
destino = new FileWriter(arqDestino);
int numeroLinhas = 0;
while (origem.readLine() != null) {
numeroLinhas++;
}
origem.seek(0);
// volta ao 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

for (int i = 0; i < numeroLinhas; i++) {


destino.write(nome[i] + "\n");
}
origem.close();
}
destino.close();
System.out.println("Ok, arquivo ordenado e copiado");
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}
}
static void sort(int n, String[] nome) {
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (nome[i].compareTo(nome[j]) > 0) {
String temp = nome[i];
nome[i] = nome[j];
nome[j] = temp;
}
}
}
}
}

8.6.10 ProgFile_10
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_10.java
package progfile_10;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;
public class ProgFile_10 {
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
String s;
System.out.print("Nome do arquivo texto: ");
String nomeArquivo = input.nextLine();
File arquivo = new File(nomeArquivo);
if (!arquivo.exists()) {
FileWriter file = new FileWriter(arquivo);
do {
System.out.print("Nome: ");
String nome = input.nextLine();
file.write(nome);
file.write(":");
System.out.print("Idade: ");
String idade = input.nextLine();
file.write(idade);
file.write(":");
System.out.print("Sexo [M/F]: ");
s = input.nextLine();
char sexo = s.charAt(0);
file.write(sexo);

302

file.write(":");
System.out.print("Continua [S/N]? ");
do {
s = input.nextLine();
} while (!"SsNn".contains(s));
} while ("S".equalsIgnoreCase(s));
file.close();
} else {
System.out.println("ERRO: Arquivo j existe");
}
}

8.6.11 ProgFile_11
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_11.java
package progfile_11;
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Scanner;
public class ProgFile_11 {
public static void main(String[] args) throws Exception {
Scanner input = new Scanner(System.in);
System.out.print("Nome do arquivo texto: ");
String nomeArquivo = input.nextLine();
File arquivo = new File(nomeArquivo);
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
if (arquivo.exists()) {
FileReader file = new FileReader(arquivo);
String linha = buffer.readLine();
// l todos os dados, ou seja, carrega toda a linha de dados
System.out.println("Buffer: " + linha);
// e joga numa String
String[] partes = linha.split(":");
int n = partes.length;
System.out.println("Partes: " + n);
for (int i = 0; i < n; i = i + 3) {
System.out.println("Nome: " + partes[i]);
System.out.println("Idade: " + Integer.parseInt(partes[i + 1]));
if (partes[i+1].equals("M") || partes[i+1].equals("m")) {
System.out.println("Sexo: MASCULINO");
} else {
System.out.println("Sexo: FEMININO");
}
}
file.close();
buffer.close();
} else {
System.out.println("ERRO: Arquivo no existe");
}
}

303

8.6.12 ProgFile_12
// ------------------------------------------------------------------------------------------------- Programa Principal: ProgFile_12.java
package progfile_12;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class ProgFile_12 {

public static void main(String[] args) throws FileNotFoundException, IOException {


Scanner input = new Scanner(System.in);
System.out.print("Nome do arquivo texto: ");
String nomeArquivo = input.nextLine();
File arquivo = new File(nomeArquivo);
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
if (arquivo.exists()) {
int homens, mulheres;
try (FileReader file = new FileReader(arquivo)) {
String linha = buffer.readLine();
// l todos os dados da linha do arquivo texto e joga numa String
System.out.println("Buffer: " + linha);
String[] partes = linha.split(":");
int n = partes.length;
homens = 0;
mulheres = 0;
for (int i = 0; i < n; i = i + 3) {
if ("M".equals(partes[i+2]) || "m".equals(partes[i+2])) {
homens++;
} else {
mulheres++;
}
}
}
buffer.close();
in.close();
conversor.close();
System.out.println("(" + homens + ") Homens");
System.out.println("(" + mulheres + ") Mulheres");
} else {
System.out.println("ERRO: Arquivo no existe");
}
}

304