Comparaçao de Strings [Resolvido]

Programação Java
#1

[code]
final static String[] ERROS = {“Ç”,“Á”,“À”,“Ô,“É”,“È”,“Í”,“Ì”,“Ó”,“Ò”,“Õ”,“Ú”,“Ù”};

public boolean possuiCaracteresInvalidos(String string){
	boolean retorno = false;
	for(int i = 0; i<string.length(); i++){
		for (int k = 0; k>&lt 10; k++){
			if (Manipuladores.ERROS[k].equals(string.charAt(i))){
				retorno = true;
			}
		}
	}
	return retorno;
}[/code]

Teoricamente deveria funcionar o metodo acima.

o objetivo, é que se faça uma busca pelo texto afim de encontar os caracteres inapropriados, que sao os descritos na constante ERROS.

Mas ele nao funciona.

alguem tem alguma sugestao? ou um metodo mais eficaz?

obrigado a todos que responderem.

#2

Quem é ‘Manipuladores’ ? Ou melhor, qual o código?

#3

Não é mais eficaz, mas é mais fácil de manter:

import java.util.regex.*;

class EncontrarInapropriados {
    // "Ç","Á","À","Ã","É","È","Í","Ì","Ó","Ò","Õ","Ú","Ù"
    static Pattern pat = Pattern.compile ("[ÇÁÀÃÉÈÍÌÓÒÕÚÙ]");

    public static boolean possuiCaracteresInvalidos (final String str) {
        Matcher mat = pat.matcher (str);
        return mat.find();
    }
    
    public static void main(String[] args) {
        System.out.println (possuiCaracteresInvalidos ("REALIZAÇÃO"));
        System.out.println (possuiCaracteresInvalidos ("CONFORMIDADE"));
    }
}

Se quiser que ignore a diferença entre minúsculas e maiúsculas, ponha um “(?i)” no início do padrão. Ou seja:

import java.util.regex.*;

class EncontrarInapropriados {
    // "Ç","Á","À","Ã","É","È","Í","Ì","Ó","Ò","Õ","Ú","Ù"
    static Pattern pat = Pattern.compile ("(?i)[ÇÁÀÃÉÈÍÌÓÒÕÚÙ]");

    public static boolean possuiCaracteresInvalidos (final String str) {
        Matcher mat = pat.matcher (str);
        return mat.find();
    }
    
    public static void main(String[] args) {
        System.out.println (possuiCaracteresInvalidos ("realização"));
        System.out.println (possuiCaracteresInvalidos ("conformidade"));
    }
}
#4

Solução mantendo o código:

final static String[] ERROS = {“Ç”,“Á”,“À”,“Ô,“É”,“È”,“Í”,“Ì”,“Ó”,“Ò”,“Õ”,“Ú”,“Ù”};

public boolean possuiCaracteresInvalidos(String string){
	boolean retorno = false;
	for(int i = 0; i<string.length(); i++){
		for (int k = 0; k>< 10; k++){
			if (Manipuladores.ERROS[k].equals(String.valueOf(string.charAt(i)))){
				retorno = true;
			}
		}
	}
	return retorno;
}

Só adiciona o String.valueOf(), por que vc esta comparando strings com chars usando o método equals.

flws

#5

[quote=thingol]Não é mais eficaz, mas é mais fácil de manter:

import java.util.regex.*;

class EncontrarInapropriados {
    // "Ç","Á","À","Ã","É","È","Í","Ì","Ó","Ò","Õ","Ú","Ù"
    static Pattern pat = Pattern.compile ("[ÇÁÀÃÉÈÍÌÓÒÕÚÙ]");

    public static boolean possuiCaracteresInvalidos (final String str) {
        Matcher mat = pat.matcher (str);
        return mat.find();
    }
    
    public static void main(String[] args) {
        System.out.println (possuiCaracteresInvalidos ("REALIZAÇÃO"));
        System.out.println (possuiCaracteresInvalidos ("CONFORMIDADE"));
    }
}

Se quiser que ignore a diferença entre minúsculas e maiúsculas, ponha um “(?i)” no início do padrão. Ou seja:

[code]
import java.util.regex.*;

class EncontrarInapropriados {
// “Ç”,“Á”,“À”,“Ô,“É”,“È”,“Í”,“Ì”,“Ó”,“Ò”,“Õ”,“Ú”,“Ù”
static Pattern pat = Pattern.compile ("(?i)[ÇÁÀÃÉÈÍÌÓÒÕÚÙ]");

public static boolean possuiCaracteresInvalidos (final String str) {
    Matcher mat = pat.matcher (str);
    return mat.find();
}

public static void main(String[] args) {
    System.out.println (possuiCaracteresInvalidos ("realização"));
    System.out.println (possuiCaracteresInvalidos ("conformidade"));
}

}
[/code][/quote]

muito obrigado. caiu comom uma luva.

mas posso te fazer uma pergunta.? É em nome de meu aprendizado.
Pra que nao fique só no copiar e colar.

O que exatamente eu fiz criando essa classe?

#6

Primeiramente você criou uma expressão regular, que fica encapsulada num objeto Pattern:
static Pattern pat = Pattern.compile ("[ÇÁÀÃÉÈÍÌÓÒÕÚÙ]");

Depois,você criou um Matcher, que é uma classe capaz de verificar se a expressão regular está dentro de uma String. No seu caso, a expressão diz que qualquer um daqueles símbolos deve ser encontrado. E é por isso que o matcher retorna true se isso ocorrer:
Matcher mat = pat.matcher (str);
return mat.find();

O Matcher ainda poderia te retornar a posição e permitiria que você encontra-se esse pattern várias vezes (num texto longo, por exemplo), mas no seu caso isso não é necessário.

Para mais informações leia sobre Expressões Regulares (também conhecidas como Regular Expressions ou REGEX) e sobre as classes Pattern, Matcher e Scanner.

#7

[quote=ViniGodoy]Primeiramente você criou uma expressão regular, que fica encapsulada num objeto Pattern:
static Pattern pat = Pattern.compile ("[ÇÁÀÃÉÈÍÌÓÒÕÚÙ]");

…[/quote]

Ok. brigadao pela força.

#8

Mesmo que você não trabalhe mais com Java, mas só com Perl ou outra linguagem de script, é importante aprender expressões regulares.
Elas resolvem muitos problemas (mas não se esqueça: elas não sabem contar. Eu lhe explico isso mais tarde.)

#9

[quote=thingol]Mesmo que você não trabalhe mais com Java, mas só com Perl ou outra linguagem de script, é importante aprender expressões regulares.
Elas resolvem muitos problemas (mas não se esqueça: elas não sabem contar. Eu lhe explico isso mais tarde.)
[/quote]

me explicar mais tarde nao é? sei…
olhe que eu cobro viu.
kkkkkkkkkkk

#10

Tá bom …

Ocorre o seguinte: muita gente quer usar expressões regulares para verificar se uma expressão contendo parênteses é válida. Exemplo:

(x + y) * z é válida (os parênteses que abrem fecham)
(x + (y * z não é válida (os parênteses que abrem não fecham)

Aí você tenta desenvolver uma expressão regular que faça isso (ou seja, verificar se os parênteses que abrem fecham).

Só que isso requer “contagem” - ou seja, digamos que você use o valor -1 para cada parêntese que abre e +1 para cada parêntese que fecha. Se você quer saber se todos os parênteses que abrem fecham, basta ir somando esses valores e ver se no final dá zero.

No primeiro caso, você tem -1 + 1 = 0, ou seja, está correto. No segundo, -1 -1 = -2, ou seja, os parênteses que abrem não fecham.

Pelo menos com as expressões regulares tradicionais (não as do Perl, que podem usar código Perl dentro delas) não dá para fazer essa verificação.

#11