Descobrir numeros na string

Programação Java
#1

Ola.
Gostaria de saber como posso validar uma string para que ela n tenha numeros.
estou tentando assim:

boolean b = minhaString.matches("^[0-9]*$"); boolean b = minhaString.contains("^[0-9]*$");
mas não funcionam se eu der uma string assim “sdae7yaea”.
dei uma pesquisada e parece que este é o jeito correto, mas n esta funcionando …
eu consigo fazer isso com Array de char … mas acho que o codigo fica mais limpo com matches/contain.
tentei com Pattern.matcher mas obtive o mesmo resultado, mas deste jeito não tenho certeza se fiz corretamente…

String p="^[0-9]*$";
String s="asd6asd7asd"
Pattern.matcher(p,s);
#2

Opa
testei tb e nao consegui usando o str.matches
mas tenta assim :

import java.util.regex.Matcher;
import java.util.regex.Pattern;		
		....
String sem = "asdafgsfdbs";
String com = "66fsdfsf21v13sdf";
		
System.out.println(com.matches("\d+"));
System.out.println(sem.matches("\d+"));
				
Pattern p = Pattern.compile("\d+");
Matcher m1 = p.matcher(com);
Matcher m2 = p.matcher(sem);
		
System.out.println(m1.find());
System.out.println(m2.find());
#3

Uma forma de fazer seria:

[code]String[] strs = {
“abc”,
“4”,
“a”,
“33”,
“ade3”,
“a5x”,
“4weasdsad”,
“asdasdasd45sdfsdf455sdf4”,
“aaa4ddd4f”,
“asddfdfger”
};

for ( String s : strs ) {
System.out.println( s + " - " + s.matches( “^(\D*\d+)(\D*\d*)*$” ) );
}[/code]
PS: Tenho certeza que dá para melhorar a expressão regular que usei.

[]'s

#4 
//retorna false caso a string tenha algum caractere numerico
private static boolean campoAlfabetico(String campo){           
        return campo.matches("[A-Z a-z Çç]{"+campo.length()+"}");   
}
#5

[code]static final String[] num = {“0”,“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”};

boolean containNum(String arg){
String str = new String("");

for(int i = 0; i < arg.length; i++){
	str = Character.toString(arg.charAt(i));

	for(int j = 0; j < num.length; j++){
		if(str.equals(num[j])) return true;					
	}
}
return false;

}[/code]

Pensei em algo mais simples, apenas percorrer a string fazendo comparações com os números

#6

[quote=utroz][code]static final String[] num = {“0”,“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”};

boolean containNum(String arg){
String str = new String("");

for(int i = 0; i < arg.length; i++){
	str = Character.toString(arg.charAt(i));

	for(int j = 0; j < num.length; j++){
		if(str.equals(num[j])) return true;					
	}
}
return false;

}[/code]

Pensei em algo mais simples, apenas percorrer a string fazendo comparações com os números[/quote]

Isso é reinventar a roda. Um algoritimo O(N²) como o seu, numa aplicação que valida milhares de campos, mata seu processador. Você realmente acha que é mais simples?

Se queres saber se a string contém algum elemento do seu array, troque seu array por um array list:

[code]
private static boolean contemNumero(String string){
List numeros = new ArrayList();
numeros.add(“0”);
numeros.add(“1”);
numeros.add(“2”);
numeros.add(“3”);
numeros.add(“4”);
numeros.add(“5”);
numeros.add(“6”);
numeros.add(“7”);
numeros.add(“8”);
numeros.add(“9”);

	for (String numero: numeros) {
		if (string.contains(numero))
			return true;
	}
	return false;
}[/code]

Nota: a lista nao precisa ser inicializada ali.

De qualquer forma, nao vejo por quê verificar se uma string comtém algum número char a char sendo que o regex faz isso pra você em uma linha de codigo. Não sei como funciona internamente, mas creio que seja mais rápido do que um for encadeado.

boolean naoContemNumeros = campo.matches("[A-Z a-z Çç]{"+campo.length()+"}");
#7

A idéia é boa, mas existe um jeito mais otimizado de fazer:

boolean temNumeros(String texto) { for (int i = 0; i < texto.length; i++) { if (Character.isDigit(texto.charAt(i))) return true; } return false; }

A vantagem é que o isNumeric testa o número pelo código da tecla, evitando aquele if interno ali.

#8

Usar o ArrayList mantém a mesma performance péssima do array primitivo. Aliás, pode ser até ligeiramente pior, pelo overhead da própria classe. A performance do método contains continua sendo O(N), já que ele faz a comparação com um for, igual estavamos fazendo.
A alternativa com collections que seria mais rápida é usar um Set. O método contains dele sim, tem performance de O(1), ou O(Log(n)) se ordenado.

#9

[quote=JhowTroMundo]
De qualquer forma, nao vejo por quê verificar se uma string comtém algum número char a char sendo que o regex faz isso pra você em uma linha de codigo. Não sei como funciona internamente, mas creio que seja mais rápido do que um for encadeado.

boolean naoContemNumeros = campo.matches("[A-Z a-z Çç]{"+campo.length()+"}"); [/quote]

Talvez para ter certeza? Seu regex, por exemplo, retorna false também caso a string tenha coisas diferentes de letras: virgulas, travessão, caracteres especiais, etc… ela não está negando só números.
Sem falar que a performance do método que indiquei é maior que a do Regex. Expressões regulares, por mais otimizadas que sejam, são bastante lentas, principalmente se houver uma execução esporádica.

Se brincar seu código, em termos de tempo de execução, é ainda pior do que a alternativa do colega, com um if dentro de outro.

Não esqueça que a expressão tem de ser parseada e interpretada (você pode ganhar performance se fizer isso uma vez só, mas na maioria das vezes criamos o regex dentro do método).
Elas só são úteis porque, na maioria das vezes, não precisamos de tanta performance assim e é preferível usar um código claro e sucinto do que um código otimizado e complexo.

Finalmente, vale lembrar as dicas quando o assunto é performance: http://www.guj.com.br/java/31346-regras-de-programacao/2#989991

#10

[quote=ViniGodoy][quote=JhowTroMundo]
De qualquer forma, nao vejo por quê verificar se uma string comtém algum número char a char sendo que o regex faz isso pra você em uma linha de codigo. Não sei como funciona internamente, mas creio que seja mais rápido do que um for encadeado.

boolean naoContemNumeros = campo.matches("[A-Z a-z Çç]{"+campo.length()+"}"); [/quote]

Talvez para ter certeza? Seu regex, por exemplo, retorna false também caso a string tenha coisas diferentes de letras: virgulas, travessão, caracteres especiais, etc… ela não está negando só números.
Sem falar que a performance do método que indiquei é maior que a do Regex. Expressões regulares, por mais otimizadas que sejam, são bastante lentas, principalmente se houver uma execução esporádica.

Se brincar seu código, em termos de tempo de execução, é ainda pior do que a alternativa do colega, com um if dentro de outro.

Não esqueça que a expressão tem de ser parseada e interpretada (você pode ganhar performance se fizer isso uma vez só, mas na maioria das vezes criamos o regex dentro do método).
Elas só são úteis porque, na maioria das vezes, não precisamos de tanta performance assim e é preferível usar um código claro e sucinto do que um código otimizado e complexo.

Finalmente, vale lembrar as dicas quando o assunto é performance: http://www.guj.com.br/java/31346-regras-de-programacao/2#989991[/quote]

Acho melhor eu reconsiderar minhas validações com regex então :shock:

Eu considerei que ele queria apenas caracteres alfabeticos quando montei o regex.

Tentei implementar seu método aqui, mas Character não possui o metodo isNumeric. Estranho isso

#11

Sorry, o método chama-se isDigit
http://download.oracle.com/javase/1,5.0/docs/api/java/lang/Character.html#isDigit(char)

#12