Problema na comparação de caracteres com acento e ç/Ç [RESOLVIDO]
1. Problema na comparação de caracteres com acento e ç/Ç [RESOLVIDO]
meldenne
(usa Linux Mint)
Enviado em 21/09/2012 - 17:28h
Olá Pessoal,Há um tempo atrás eu estava criando este algoritmo, é algo bem simples, a ideia inicial era que ele lê-se uma frase digitada pelo usuário e contasse quantas consoantes e vogais ali existem. A única exceção era que o usuário não deveria digitar os acentos e nem o ç/Ç (pois seriam ignorados). Bom, isso ele já faz... Mas então 'eu resolvi' que ele deveria ler os acentos e o ç/Ç. E aí começaram os problemas...
Vejam bem, eu testei comparando char... Deu errado!
Testei, comparando o valor que eles assumem na tabela ASCII, uau... Deu errado de novo!
Testei comparando o valor UTF-16... E deu errado de novo!
Estes testes foram os que lembro de ter feito, pesquisei bastante na internet e as soluções que encontrei tentei implementar mas não deram certo.
Vocês sabem de algo que possa me ajudar?
Também há outro problema, na leitura, caso uma letra acentuada ou ç/Ç sejam a última letra da frase, o usuário deve digitar 2 'enter' para que a execução continue... Queria poder solucionar isso. Alguém sabe o porque isso acontece ou como solucionar?
Não peço código, apenas um caminho para que eu possa seguir... Já deixei este algoritmo parado por bastante tempo e gostaria de terminá-lo para postar aqui.
Abaixo segue o código completo, está meio extenso pois não retirei os comentários que eu havia feito. No mais, o código em si é bem simples. Nada que lhes vá render muita dor de cabeça. Caso seja um erro no próprio código, ficaria feliz que me dissessem, mas ele está funcionando perfeitamente (cumpre o que promete, conta as vogais e as consoantes de uma frase com no máximo 80 caracteres e mostra o resultado na saída).
Desde já agradeço.
//Importa a classe Scanner para realizar leituras do teclado.
import java.util.Scanner;
/**
* Este algoritmo recebe uma palavra ou frase e conta quantas vogais e consoantes
* há nesta palavra/frase. Nota-se que por ser um algoritmo simples ele não reconhece
* acentos, nem 'ç' ou 'Ç', ou seja... Ele irá ignorá-los. Caso uma letra acentuada ou
* um ç/Ç sejam a última entrada, ele esperará um segundo 'enter' depois da indicação
* de fim de linha para iniciar a execução.
* O tamanho máximo da palavra/frase deverá ser de 80 caracteres.
* É um algoritmo simples, e eu particulamente não gosto muito de 'switch', mas o preferi
* aos vetores e suas comparações. Achei ser mais eficiente. Estou aberta a outras dicas.
* Caso hajam erros, por favor avisem, para que eu os possa corrigir.
*/
public class LetrasASCII {
/**
* Este método estático, recebe um char e retorna true, caso o char seja
* encontrado nas comparações do switch. Neste caso, não é necessário utilizar
* o break, pois, assim que o char é encontrado da lista ele é retornado e a
* verificação termina.
* @param v
* @return boolean
*/
public static boolean verificaVogal(char v) {
switch (v) {
case 'a':
return true;
case 'e':
return true;
case 'i':
return true;
case 'o':
return true;
case 'u':
return true;
}
return false;
}
/**
* Este método recebe uma String como parametro e conta quantas consoantes e
* quantas vogais existem nessa String. Lá em cima, eu criei um método para
* fazer a contagem das vogais e um para as consoantes porque assim facilitaria
* aqui neste método fazer a contagem das mesmas. E também diminuiria o número
* de comparações do 'char atual' caso fosse uma vogal, como veremos mais abaixo.
* @param frase
*/
public static void contaLetras(String frase) {
//Inicialização de variáveis
int vogal = 0, consoante = 0;
/**
* Este for irá percorrer toda a extensão da String enquanto o contador
* for menor que o tamanho da String.
*/
for (int cont = 0; cont < frase.length(); cont++) {
//Verifica se o caracter na posição cont da palavra/frase está entre 'A' e 'Z' ou 'a' e 'z'
if (((frase.toLowerCase().charAt(cont) >= 'a') && (frase.toLowerCase().charAt(cont) <= 'z'))) {
/**
* Se ele passar no teste acima ele chama o método verificaVogal()
* para descobrir se este char é uma vogal. Se o método retornar
* true, +1 é adicionado à variavel vogal. Senão, +1 é adicionado
* à consoante.
*/
if (verificaVogal(frase.toLowerCase().charAt(cont))) {
vogal++;
} else {
consoante++;
}
}
}
//Lista quantas vogais e consoantes há na frase.
System.out.println("Vogais: " + vogal + " Consoante: " + consoante);
/**
* xD Não deixa o algoritmo terminar de qualquer forma. Chama o menu
* que pergunta ao usuário se ele deseja continuar com a execução.
*/
retornoMenu();
}
/**
* Este método cria um pequeno menu que é chamada ao fim do programa. Assim o
* usuário poderá indicar se quer finalizar se quer terminar o programa ou
* continuar com uma nova frase.
*/
public static void retornoMenu() {
//Instancia um objeto Scanner para leitura do teclado.
Scanner in = new Scanner(System.in);
System.out.println("Deseja fazer outro teste? [s/n]");
//Lê do teclado a resposta do usuario.
String teste = in.nextLine();
/**
* Aqui é testado se o usuário digitou corretamente as opções
* para que a execução continue ou não.
*/
if (teste.toLowerCase().equals("s") || teste.toLowerCase().equals("n")) {
/**
* Caso ele passe no teste acima, ele verifica se o usuário digitou
* 's' ou 'n'. Caso seja 's', ele apenas chama o método início e volta
* para o início do fluxo de execução. Se for 'n', ele imprime na saída
* que é o fim do programa e termina.
*/
if (teste.toLowerCase().equals("s")) {
inicio();
} else {
System.out.println("Fim do programa...");
}
/**
* Caso ele não não digite as opções corretamente, o programa avisa que
* ouve um erro e chama esta função novamente.
*/
} else {
System.out.println("Informação Inválida! Digite apenas 's' ou 'n'.");
retornoMenu();
}
//Fim
}
/**
* Este método dá início ao programa, é ele quem faz a leitura da frase
*/
public static void inicio() {
//Variável para guardar a frase.
String frase;
//Instancia um objeto da classe Scanner para ler as entradas do teclado.
Scanner in = new Scanner(System.in);
//Gera uma saída na tela
System.out.println("Entre com a frase, por favor. Não utilize acentos e não ultrapasse o limite de 80 caracteres");
/**
* Aqui a variável frase receberá o que o usuário digitar. A instancia da classe Scanner, que no caso é 'in',
* chamará o método nextLine() que retornará para a variável o que está na entrada.
*/
frase = in.nextLine();
/**
* Faz uma verificação para confirmar que a frase não tem mais de 80 caracteres.
* Caso tenha ela retorna uma mensagem de aviso e retorna ao início do algoritmo para que
* o usuário possa realizar outra entrada.
*/
if (frase.length() > 80) {
System.out.println("A frase contém mais que 80 caracteres. ");
inicio();
}
//Chama o método que irá contar as letras da frase, caso ela esteja ok.
contaLetras(frase);
}
public static void main(String[] args) {
//Chama o método inicio(), onde começa o algoritmo.
inicio();
}
}