Elaboração:

 J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
FICHA  DE  REVISÃO  
(Resumo.  Breve)  
 
TEMAS  
Páginas  
Tema  #   TEMA  
 
1   TIPOS  DE  DADOS,  VARIÁVEIS  E  OPERAÇÕES.   2  
o   Tipos  de  dados  primitivos;  
o   Declaração  de  Variáveis;    
o   Inicialização  de  variáveis;  
o   Atribuição  de  valores;  
o   Conversão  e  Casting;  
o   Tipos  de  dados  não  primitivos.  
2   COMUNICAÇÃO  BÁSICA  COM  O  UTILIZADOR:    3  
o   Input  do  teclado    em  JAVA;    
o   Output  para  o  ecrã  em  JAVA;  
 
3   OPERADORES  (E  OPERAÇÕES):      
a.   (1)  Aritméticos;     4  -­‐  5  
b.   (2)  Relacionais;    
c.   (3)  Lógicos.  

4   ESTRUTURAS  DE  SELECÇÃO/DECISÃO:    

o   If  (simples  e  encadeado);   6  
o   If-­‐else.  
o   switch-­‐case.  
5   ESTRUTURAS  DE  REPETIÇÃO/CÍCLICAS:    
o   Ciclo  while;     7  
o   ciclo  do-­‐while;    
o   ciclo  for.  
6   VECTORES  estáticos  –  ARRAYS  Unidimensionais    
o   Array  e  manipulação  sem  ciclo  de   8  -­‐  9  
repetição  
o   Array  e  manipulação  com  ciclo  de  
repetição  
7   MÓDULOS  EM  JAVA:  MÉTODOS  E  CLASSES  pré-­‐definidas.   10  -­‐  13  
(Subprogramas  em  Java):  
a)  Classe  (e  Métodos):  a  Classe  Math  e  seus  
métodos;  
b)  Classe  (e  Métodos):  a  Classe  String  e  seus  
métodos;  
8   MÓDULOS  EM  JAVA:  MÉTODOS  E  CLASSES   14  -­‐  16  
(Subprogramas  em  Java):  
a)  Métodos  criados  pelo  programador.  
b)  Classes  criadas  pelo  programador.  
9   A  Classe  String  Tokenizer   17  -­‐  18  
o  sem  array  e  com  ciclo  de  repetição.  
o  com  array  e  com  ciclo  de  repetição.  
 
 

Página  1  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
1.  TIPOS  DE  DADOS,  VARIÁVEIS  E  OPERAÇÕES.    
o   Tipos  de  dados  primitivos;  
o   Declaração  de  Variáveis;    
o   Inicialização  de  variáveis;  
o   Atribuição  de  valores;  
o   Conversão  e  Casting;  
o   Tipos  de  dados  não  primitivos.  
 
 
1.1  –  Declaração  e  atribuição  de  valores  (Tipos  de  dados  primitivos)    
byte n1 = 3; // ocupa 8 bits
short num1=5; // ocupa 16 bits

int num2 =2; // ocupa 32 bits ;

long num22 = 56; // ocupa 64 bits

float num3 = 4.5f; // ocupa 32 bits

double num4 = 5.6; // ocupa 64 bits

char caracter = 'p'; // ocupa 16 bits

boolean vouF = true; // ocupa 1 bit  

 
 
 
 
1.2  –  Declaração  e  atribuição  de  valores  (Tipos  de  dados  não  primitivos)    
 
String mensagem1 = "Mensagem 1";

 
 
 
 
 
1.3  –  Conversão  sem  perda  e  Conversão  com  perda  (Casting)    
                                                       // Conversão sem perda
int numI1=4;
double numD1 =0;

numD1 = numI1;
// Conversão com perda de informação (Casting)
int numI2=10;
double numD2 =16.55;

numI2 = (int) numD2;

 
 
 
 
 
 

Página  2  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
2.  COMUNICAÇÃO  BÁSICA  COM  O  UTILIZADOR:    
o   Input  do  teclado    em  JAVA;    
o   Output  para  o  ecrã  em  JAVA;  

 
   
2.1  –  o  Input  do  teclado    em  JAVA    
public static void metodoLeituraTeclado()
{
String mensagem1 = "";

// criacao de um objecto da classe Scanner

Scanner lerDoTeclado = new Scanner(System.in);

System.out.println("Intrpduza a mensagem");

// leitura do teclado
mensagem1 = lerDoTeclado.nextLine();

lerDoTeclado.close(); // fecho

System.out.println(mensagem1);

}  
 
 
   
2.2  –  o  Output  para  o  ecrã  em  JAVA    
public static void imprimeNoEcra()
{
System.out.println("Mensagem ");

}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Página  3  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
3.  OPERADORES  (E  OPERAÇÕES):      
a.   (1)  Aritméticos;    
b.   (2)  Relacionais;    
c.   (3)  Lógicos.  

 
3.1  –  operadores  (e  operações)  aritméticas    
+   -­‐   *   /   %   ++   -­‐-­‐    
adição   subtração   multiplicação   divisão   Resto  da  divisão   Incrementa  a  1   Decrementa  a  1    
int soma = 0, num1=0, num2=0;  
soma = num1+num2; // adição

int subtrai = 0, num3=0, num4=0;

subtrai = num3-num4; // subtração

int multiplica = 0, num5=0, num6=0;

multiplica = num5 * num6; // multiplicação

double divide = 0, num7=0, num8=0;

divide = num7/num8; // divisão

int restoDivisao = 0, num9=0, num10 =2;

restoDivisao = num9 % num10; // resto da divisão
 
 
3.2  –  operadores  (e  operações)  Lógicos  (as)  e  Bitwise    
Lógicos     Bitwise    
!   ||   &&   |   &   ^    
complement     Conditional-­‐OR   Conditional-­‐AND     bitwise  inclusive  OR     bitwise  AND  operator   bitwise  exclusive  OR      
                                                             boolean VouF1;
VouF1 = !(5>10); // Complemento; operador not
System.out.println("F1: "+VouF1);

boolean VouF2;
VouF2 = (5>10) || (3>=3); // OU Condicional
System.out.println("F2: "+VouF2);

boolean VouF3;
VouF3 = (5>10) && (3>=3); // OU Condicional
System.out.println("F3: "+VouF3);

boolean VouF4;
VouF4 = (5>10) | (3>=3); // bitwise inclusive OR
System.out.println("F4: "+VouF4);

boolean VouF5;
VouF5 = (5>10) & (3>=3); // bitwise AND operator
System.out.println("F5: "+VouF5);

boolean VouF6;
VouF6 = (6==6) ^ (3==4); // bitwise exclusive OR
System.out.println("F6: "+VouF6);
 
 

Página  4  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
3.3  –  operadores  (e  operações)  Relacionais  e  Igualdade    
>   <   >=   <=   !=   ==    
maior   menor   Maior  ou  igual   Menor  ou  igual   diferente   Igual    
boolean VouF1;
VouF1 = 5>10; // maior que
System.out.println("F1: "+VouF1);

boolean VouF2;
VouF2 = 5<10; // menor que
System.out.println("F2: "+VouF2);

boolean VouF3;
VouF3 = 5>=10; // maior ou igual
System.out.println("F3: "+VouF3);

boolean VouF4;
VouF4 = 5<=10; // menor ou igual
System.out.println("F4: "+VouF4);

boolean VouF5;
VouF5 = 5!=10; // diferente ou igual
System.out.println("F5: "+VouF5);

boolean VouF6;
VouF6 = 5!=10; // diferente ou igual
System.out.println("F6: "+VouF6);  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Página  5  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
4.  ESTRUTURAS  DE  SELECÇÃO/DECISÃO:    
o   If  (simples  e  encadeado);  
o   If-­‐else.  
o   switch-­‐case.  
 
 
4.1  –  estruturas  de  selecção/decisão:  If  (simples  e  encadeado)    
if (5>3)
{
System.out.println("Maior");
}

if (5>3)
{
if(4>3)
{
System.out.println("Menor");  
}
}
 
 
 
 
4.2  –  estruturas  de  selecção/decisão:  If-­‐else    
 
if (5>3)
{
System.out.println("Maior");

} else {

System.out.println("Menor");
}  
 
 
 
 
 
 
4.3  –  estruturas  de  selecção/decisão:  switch-­‐case.    
switch (opcao)
{ case (1):
System.out.println("Opcao 1");
break;

case (2):
System.out.println("Opcao 2");
break;
}  
 
 

Página  6  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
5.  ESTRUTURAS  DE  REPETIÇÃO/CÍCLICAS:    
o   Ciclo  while;    
o   ciclo  do-­‐while;    
o   ciclo  for.  
 
5.1  –  Estruturas  de  Repetição/Cíclicas:  Ciclo  while    
public void ciclo_do_while_simples()
{
int i=0; // contador

do{
System.out.println(" Valor de i: "+i );
i++; // incrementa uma unidade

}while(i < 3);

}
 
5.2  –  Estruturas  de  Repetição/Cíclicas:  Ciclo  do-­‐while    
public void ciclo_while_simples()
{
int i=0; // contador

while(i < 3)
{
System.out.println(" Valor de i: "+i);

i++;// incrementa uma unidade

}
}
 
5.3  –  Estruturas  de  Repetição/Cíclicas:  Ciclo  for    
public void ciclo_for_simples()//ciclo for - simples
{
for(int i = 0; i < 3; i++)
{
System.out.println(" Valor de i: "+i);
}
}
public void ciclo_for_encadeado() //ciclo for – encadeado
{
for(int i = 0; i < 3; i++)
{ System.out.println(i + " Valor de i: " );

for(int j = 0; j < 2; j++)

{
System.out.println(" Valor de j: " + j);
}

System.out.println("");
}
}  
 

Página  7  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
6.  VECTORES  estáticos  –  ARRAYS  Unidimensionais    
o   Array  e  manipulação  sem  ciclo  de  repetição.  
o   Array  e  manipulação  com  ciclo  de  repetição.  
 
   
6.1  –  ARRAYS  Unidimensionais:  Array  e  manipulação  sem  ciclo  de  repetição.    
//----------------------------------------------------------
// EXEMPLO 1 - Array de int - sem uso de estruturas de repetição
//----------------------------------------------------------

// Forma 1 - para declarar e inicializar

int[] num = new int[2]; // Forma 1 - variante 1

int[] idades;
idades = new int[2]; // Forma 1 - 1variante 2

// Atribuição de valores via índices do Array

idades[0] = 5;
idades[1] = 7;

System.out.println("Imp1-valor do conteudo array: "+idades[0]);

System.out.println("Imp1-valor do conteudo array: "+idades[1]);
System.out.println("");
 
 
   
6.2  –  ARRAYS  Unidimensionais:  Array  e  manipulação  COM  Ciclo  de  Repetição.    
//----------------------------------------------------------
// EXEMPLO 2 - Array de int - com uso de estruturas de repetição.
//----------------------------------------------------------
// Forma 2 - para declarar e inicializar

int numeros[] = {10, 20, 30, 40};

for (int i = 0; i < 4; i++)

{
System.out.println("Imp2-valor do conteudo array:
"+numeros[i]);
}

System.out.println("");
//------------------------------------------------------------

Página  8  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

//----------------------------------------------------------
// EXEMPLO 3 - Array de String - com uso de estruturas de repetição
//----------------------------------------------------------

String[] carros = {"Jeep", "Toyota", "Nissan", "Ractis"};

int tamanhoArray = 0;

tamanhoArray = carros.length;
System.out.println("Tamanho: "+tamanhoArray);

for (int i = 0; i < tamanhoArray; i++)

{
System.out.println("valor do conteudo array: "+i+"
"+carros[i]);

}
//----------------------------------------------------------

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Página  9  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
7.  MÓDULOS  EM  JAVA:  MÉTODOS  E  CLASSES  pré-­‐definidas.    
         (Subprogramas  em  Java):  
a.   Classe  (e  Métodos):  a  Classe  Math  e  seus  métodos;  
b.   Classe  (e  Métodos):  a  Classe  String  e  seus  métodos;  
 
   
7.1  –  Métodos  e  Classes  pré-­‐definidas:  a  Classe  Math  e  seus  Métodos    
//Math.sqrt(parâmetro) ->
// para calcular a raiz quadrada de um número.
double raizQuadrada1 = Math.sqrt(18);
System.out.println(raizQuadrada1);

// Math.pow(parametro) -> ara calcular o expoente de um número.

double expoente1 = Math.pow(2,3); //dois elevado a três
System.out.println(expoente1);

// Para Trigonometria. Math.sin(x) -> para calcular o seno

System.out.println("seno: "+Math.sin(0.0));

//Calcular co-seno. Math.cos(x) -> para calcular o co-seno

System.out.println("coseno: "+Math.cos(0.0));

// Calcular a tangente
double valTangente = Math.tan(0.0);
System.out.println("a tangente de zero: "+valTangente);

// log(x) -> Para Calcular o logaritmo natural de base e

double logBaseE = Math.log(2.71828);
System.out.println("logaritmo de base e: "+logBaseE);

// Math.log10(x) -> Para Calcular o logaritmo natural de base 10

double logBase10 = Math.log10(20);
System.out.println("logaritmo de base 10: "+logBase10);

// Math.round(x) -> Para arredondar valores

System.out.println("Arredondamento: "+ Math.round(3.9));

// Math.random() -> Para gerar números aleatoriamente, de 0 a 1.

double numeroAleatorio = Math.random();
System.out.println("Arredondamento: "+numeroAleatorio);

// Math.max(4,2) -> Para determinar qual o maior valor/número.

System.out.println("Maior valol: "+Math.max(3, 10));

// Math.min(4, 2) -> Para determinar qual o maior valor/número

System.out.println("Menor valor (classe math): "+Math.min(4, 6));

 
 
 
 
 

Página  10  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
 
 
7.2  –  Métodos  e  Classes  pré-­‐definidas:  A  Classe  String  e  seus  métodos    
//---------------------------------------------------
// O Método length() -> .length()
// O que faz: determina o tamanho da cadeia;
// input (recebe): nada.
// output (devolve/retorna): o tamanho (uma numero inteiro)

int tamanho2 = 0;
String frase4 = new String ("Je ep");

tamanho2 = frase4.length();

//System.out.println("Resultado4: "+tamanho2);
//System.out.println( "Resultado4: "+frase4.length() );

// O Método indexOf() -> .indexOf()

// O que faz: permite obter o indice
// input (recebe): a cadeia de caracteres (a palavra) a comparar
// output (devolve/retorna): o indice da primeira letra da palavra

int valorDoIndice = 0;
String frase5 = "Jeep Toyota Nissan";

valorDoIndice = frase5.indexOf("Toyota");
//System.out.println("O indice: "+valorDoIndice);

/*
if(valorDoIndice == -1){
System.out.println("Palavra não existe");
}else {
System.out.println("O índice: "+valorDoIndice);
}
*/

// O Método equals(): -> .equals()

// O que faz: verifica se a cadeia de caracteres do
// objecto é igual a uma outra cadeiafornecida
// input: cadeia de caracteres a comparar
// output: true se forem iguais, false se foram diferentes

boolean tof;
String frase6 = new String ("Progamar em Java");
String frase7 = "Progamar em Java";

tof = frase6.equals(frase7);
//System.out.println("Retorno: "+tof);

Página  11  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

// O Método equalsIgnoreCase() -> .equalsIgnoreCase()

// O que faz: verifica se a cadeia de caracteres do
// objecto é igual a uma outra cadeiafornecida
// Sem ter em conta se sao maisculas ou minusculas
// input: cadeia de caracteres a comparer
// output: true se forem iguais, false se foram diferentes

boolean tof2;
String frase8 = new String ("PROGRAMAR EM JAVA");
String frase9 = "programar em java";

tof2 = frase8.equalsIgnoreCase(frase9);

//System.out.println("Retorno 8e9: "+tof2);

// O Método compareTo() -> .compareTo()

// O que faz: compara a cadeia de caracteres

// do objecto com uma fornecida
// input (recebe): cadeia de caracteres a comparar.
// output (devolve/retorna): 0 se forem iguais
// (todos caracteres iguais).
// Positivo se for posterior. Negativo de for anterior.

int valor = 0;
String frase10 = "PROGRAMA ALGA GEOMETRIA";
String fase11 = "PROGRAMA ALGA GEOMETRIA";

valor = frase10.compareTo(fase11);

//System.out.print("Resultado: "+valor);

// O Método concat() -> .concat()

// O que faz: unir/juntar cadeia de caracteres
// input (recebe): as cadeia de caracteres a unir(cadeiaC1+cadeiaC2)
// output (devolve/retorna): Cadeia de caracteres resultante

String frase11 = "Toyota ";

String fase12 = "Jeep";
String fraseResult = "";

fraseResult = frase11.concat(fase12);

//System.out.print("Resultado12: "+ fraseResult);

Página  12  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

//---------------------------------------------------

// O Método toLowerCase() -> .toLowerCase()

// O que faz: faz com que a cadeia esteja em letras minustculas
// input (recebe): uma cadeia de caracteres
// output (devolve/retorna):
// cadeia de caracteres em letras minusculas

String frase13 = "OLA Toyota";

String fraseResult13 = "";

fraseResult13 = frase13.toLowerCase();
//System.out.print("Resultado13: "+ fraseResult13);

// O Método toUpperCase() -> .toUpperCase()

// O que faz: faz com que a cadeia esteja em letras maiusculas
// input (recebe): uma cadeia de caracteres
// output (devolve/retorna): cadeia de caracteres em letras
// maiusculas

String frase14 = "OLA Jeep";

String fraseResult14 = "";

fraseResult14 = frase14.toUpperCase();
//System.out.print("Resultado14: "+ fraseResult14);

// O Método subString() -> .subString()

// O que faz: obter uma cadeia especifica de caracteres de um objecto
// input (recebe): uma cadeia de caracteres; o indice pc; o indice uc;
// output (devolve/retorna): uma cadeia de caracteres contida na cadeia
// de caracteres do objecto

String frase15 = "Jeep Toyota Nissan";

String frase16 = frase15.substring(5,11);

//System.out.print("Resultado16: "+frase16);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Página  13  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
8.  MÓDULOS  EM  JAVA:  MÉTODOS  E  CLASSES    
         (Subprogramas  em  Java):  
a.   Métodos  criados  pelo  programador.  
b.   Classes  criadas  pelo  programador.  
 
   
8.1  –  Métodos  e  Classes  definidas  pelo  programador:  Definição  de  Métodos    
// Metodo do tipo void (sem retorno). SEM Passagem de parâmetro.
// Soma dois numero
public static void somaDoisNumeros_1()
{
int num1 = 10;
int num2 = 5;
int result1 = 0;

result1 = num1+num2;
System.out.println("Res_1: "+result1);
}

// Metodo do tipo void (sem retorno). COM Passagem de parâmetro.

// Subtrai dois numero
public static void somaDoisNumeros_2(int num1,int num2)
{ int result1 = 0;
int a=num1;
int b=num2;

result1 = a-b;
System.out.println("Res_2: "+result1);
}

// Método Com Retorno (valor inteiro). Com passagem de parâmetro.

// Multiplica dois numero
public static int multiplica3(int num1, int num2)
{ int resultado = 0;

resultado = num1*num2;

return resultado;
}

// Método Com Retorno (valor inteiro). Sem passagem de parâmetro.

// Retorna uma mensagem
public static String recebeNome()
{ String msg = "Numero 1";

return msg;
}

 
 
 
 

Página  14  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
   
8.2  –  Métodos  e  Classes  definidas  pelo  programador:  Definição  de  Classes    
/*
Exemplo de Classe, método main e com
método definido pelo programador
*/
 
public class ExemploComMain {

public static void main(String []args)

{
mensagem_1();
}

public static void mensagem_1()

{
System.out.println("Exemplo de Classe com metodo main");
}

}  
/*
Exemplo de Classe, método main e com
método definido pelo programador
*/

public class ExemploSemMain {

public static void mensagem_1()

{
System.out.println("Exemplo de Classe com metodo main");
}

}  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Página  15  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
8.2.1  –  Métodos  e  Classes  definidas  pelo  programador:  Definição  de  Classes
Classe  sem  o  Método  Main    
(com  construtor  definido  pelo  programador)  
public class SemMain {

// variavel global não-privada (possivel aceder em outras classe)

static int varG1 = 1111;

// variavel global privada (não é possivel aceder em outras classe)

private static int varG2 = 2222;

//constructor (definido pelo programador)

public SemMain() {}

// Este metodo pode ser chamado em outras classes

public static void metodoCSM_1() {
System.out.println("Numero");
}

// Este metodo pode ser chamado em outras classes

public static void metodoCSM_2(int x) {
System.out.println("Numero passado: "+x);
}

// Este metodo pode ser chamado em outras classes

public static int metodoCSM_3(int x) {
return x*2;
}

// Este metodo pode ser chamado em outras classes

public static String metodoCSM_4(String frase) {
return (frase+" Met");
}

Classe  com  o  método  Main  (chama  métodos  de  outra  classe)

//Exemplo de Classe com metodo main

public class ExemploComMain {

public static void main(String []args)

{
SemMain ac1 = new SemMain();
ac1.metodoCSM_1();
}

}
 
 
 
 

Página  16  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
 
9.  A  Classe  String  Tokenizer    
o  sem  array  e  com  ciclo  de  repetição.  
o  com  array  e  com  ciclo  de  repetição.  
 
 
   
9.1  –  A  Classe  String  Tokenizer  –  Sem  Array  e  com  ciclo  de  repetição.    
// Separa tendo como referência os espaços entre Tokens
public static void exemploDeTokenizer_1()
{
String frase55 = "a andar de bicicleta aprende-se andando";

StringTokenizer divideAFrase = new StringTokenizer(frase55);

while (divideAFrase.hasMoreElements())
{
String palavra66 = divideAFrase.nextToken();

System.out.println(palavra66);

}
}
 

// Separa tendo como referência o sinal ponto e vírgula

public static void exemploDeTokenizer_2()
{
String frase55 = "nomeE;numE;idadeE;nota1;nota2";

StringTokenizer divideAFrase = new StringTokenizer(frase55, ";");

while (divideAFrase.hasMoreElements())
{
String palavra66 = divideAFrase.nextToken();

System.out.println(palavra66)

}
}
 
 
 
 
 
 
 
 
 
 
 
 

Página  17  de  18  

 
Elaboração:  J.  Mota.  Todos  os  direitos  reservados.  Para  uso  exclusivo  dos  estudantes.  Versão:  alfa  1.4.  
 

 
 
 
   
9.2  –  A  Classe  String  Tokenizer  –  COM  Array  e  com  ciclo  de  repetição.    
// Separa tendo como referência os espaços entre Tokens
public static void exemploDeTokenizer_3 ()
{
String frase1 = "O Meu Telemovel Estragou-se";
StringTokenizer divideAFrase = new StringTokenizer(frase1);

// Array 4 posições/regiões. Índices: 0; 1; 2; 3.

String a[] = new String [4];

int contador=0;

while (divideAFrase.hasMoreElements()) // sim

{
String palavraAux = divideAFrase.nextToken();

a[contador] = palavraAux;

contador++;
}

for (int i=0; i<contador; i++)

{
System.out.println("Token " + i + ": " +a[i]);
}

}
 
 
 
 
 
 
 
 
 
 

Página  18  de  18