Expressao Regular

Programação Java
#1

Bom dia amigos, preciso resolver um problema mas esta dificil…
tenho que montar uma expressa regular para aceitar letras maisculas, minuscula e 0/9 porem obriga-los pelo menos um desses caracteres exemplo

se eu digitar fernando1 nao passa porem se difitar Fernando1 ou fernandO1 tudo bem é aceitavel, porem nao tenho ideia de como fazer ja
tentei [A-z][a-z][0-9] depois de A-Za-z0-9 mas nao rola

Aguem pode me ajudar…

Abraços

Fernando Oliveira

#2

Tenta isso…

[a-Z0-9]+

O mais significa ao menos 1 caractere de dentro das chaves

#3

Pode tentar tbm

[\w\d]+
#4

Pelo que entendi, ele quer garantir pelo menos um caractere de cada grupo que ele falou, então acho que seria + - assim:

[a-z]+[A-Z]+[0-9]+

T+

#5

[quote=gr_marco]Pode tentar tbm

[\w\d]+ [/quote]
Neste caso, não pode. É que o “\w” inclui o caractere underscore ("_").
Em tempo: “\w” engloba “\d”, tornando a expressão acima equivalente a \w+

#6

É vero…
Não li direito o enunciado…
Fernando, vc poderia especificar melhor o que precisa?

#7

[quote=diego2005]Pelo que entendi, ele quer garantir pelo menos um caractere de cada grupo que ele falou, então acho que seria + - assim:

[a-z]+[A-Z]+[0-9]+

T+[/quote]
Também não funciona… A regex acima só aceita Strings em que pelo menos o primeiro caractere seja de “a” até “z”, termine com pelo menos um caratere entre “0” e “9”, e no meio tenha pelo menos um caractere de “A” até “Z”.
Infelizmente, creio que a solução buscada pelo OP não possa se dar através de regex. O mais próximo que consegui chegar foi:

[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*

E mesmo assim, ela não funciona legal, pois só aceita Strings que tenham pelo menos 1 letra maiúscula, uma minúscula e um número nesta ordem.
Talvez se você fizer uma combinação de regex como acima, alternando a ordem dos trechos significativos ("[A-Z]+", “[a-z]+” e “[0-9]+”) e intercalando-as com um “|”, pode até dar certo, mas que vai ficar super feio, não tenha dúvidas… Talvez seja melhor procurar uma outra alternativa para solucionar este problema…

#8

Algo assim talvez funcione:

String regex = "[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*" + "[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*" + "[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*" + "[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*" + "[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*" + "[a-zA-Z0-9]*[0-9]+[a-zA-Z0-9]*[A-Z]+[a-zA-Z0-9]*[a-z]+[a-zA-Z0-9]*" ;
Mas… Convenhamos… Tréxi demais…

#9

Ou então ele faz uma expressão pra cada restrição, e se as três expressões obtiveram sucesso, quer dizer que texto está no formato que ele quer.

Mas convenhamos também, acho que não ficaria legal, rsrsrsrs…

T+

#10

[quote=diego2005]Ou então ele faz uma expressão pra cada restrição, e se as três expressões obtiveram sucesso, quer dizer que texto está no formato que ele quer.

Mas convenhamos também, acho que não ficaria legal, rsrsrsrs…

T+[/quote]
Ah, mas fica muito melhor que o monstrinho que eu coloquei lá em cima… :lol:

boolean isValid(String texto){
	String 
		regexMinuscula = "[\w&&[^_]]*[a-z]+[\w&&[^_]]*",
		regexMaiuscula = "[\w&&[^_]]*[A-Z]+[\w&&[^_]]*",
		regexDigito = "[\w&&[^_]]*[0-9]+[\w&&[^_]]*"
	;
	return
		texto.matches(regexMaiuscula) &&
		texto.matches(regexMinuscula) &&
		texto.matches(regexDigito)
	;
}

Aff…

#11

por que nao fazer 3 expressões regulares simples ?

se casar com [A-Z]
E casar com [a-z]
E casar com [0-9]

então ta certo.

melhor do que fazer expressões complexas que podem demorar demais para seres verificadas.

#12

[quote=peczenyj]por que nao fazer 3 expressões regulares simples ?

se casar com [A-Z]
E casar com [a-z]
E casar com [0-9]

então ta certo.

melhor do que fazer expressões complexas que podem demorar demais para seres verificadas.[/quote]

Então acho que seria:

se casar com [A-Z]+
E casar com [a-z]+
E casar com [0-9]+

Por que tem que ter pelo menos um caractere de cada grupo…

T+

#13

galera seguinte estava ate pensando em fazer assim mesmo existe A-Z && a-z && 0-9

porem como é feito isso, pois se uso A-Z ele quer q tudo fiquei Maisculo e assim para todos correto??

abçs

#14

Por isso deve-se colocar o +, que significa uma ou mais vezes…

T+

#15

Do jeito que eu implementei a idéia do diego2005 no meu último post não deu certo? Alguém testou?

#16

entendi mas assim se eu faço isso me retorna false tem ideia ?

exemplo
[A-Z]+[a-z]+[0-9]

mesmo assim nao funciona
minha string esta como Fernando!28

Pattern.compile("[A-Z]+[a-z]+[0-9]+").matcher(“Fernando!28”).matches()

Abraços
Fernando

#17

É o que o Mantu falou anteriormente, essa expressão junta não vai funcionar, você tem que separá-la em 3.

T+

#18

[quote=diego2005]É o que o Mantu falou anteriormente, essa expressão junta não vai funcionar, você tem que separá-la em 3.

T+[/quote]
Mas não é só pegar a expressão [A-Z]+[a-z]+[0-9] e separar em 3…
Se simplesmente fazer uma regex [A-Z]+, uma [a-z]+ e outra [0-9]+, não vai funcionar como estão esperando, uma vez que estas três expressões são exclusivas entre si.
Se a intenção do foliveira81 é só aceitar Strings atendam simultaneamente às restrições:
[list]ter apenas letras ou números[/list]
[list]ter pelo menos 1 letra maiúscula[/list]
[list]ter pelo menos 1 letra minúscula[/list]
[list]ter pelo menos 1 dígito[/list]

Creio que as regex ficariam como escrevi há pouco neste tópico

#19

Tem um programa muito util chamado kodos. Ele serve para testes de expressões regulares.

Segue tb um material basico

http://guia-er.sourceforge.net/

#20

Usar uma única expressão regular ficou muito complicado. Melhor usar três, como o Mantu indicou.


import java.util.regex.*;

class TestePadrao {
	public static void main(String[] args) {
// Não recomendaria usar um padrão só, mas os três do Mantu,
// que são mais fáceis de manter.
                Pattern pat = Pattern.compile (
".*"
+ "("
+ "[A-Z]+[^A-Za-z0-9]*[a-z]+[^A-Za-z0-9]*[0-9]+" 
+ "|" 
+ "[a-z]+[^A-Za-z0-9]*[A-Z]+[^A-Za-z0-9]*[0-9]+"
+ "|" 
+ "[0-9]+[^A-Za-z0-9]*[a-z]+[^A-Za-z0-9]*[A-Z]+"
+ "|" 
+ "[a-z]+[^A-Za-z0-9]*[0-9]+[^A-Za-z0-9]*[A-Z]+"
+ "|" 
+ "[0-9]+[^A-Za-z0-9]*[A-Z]+[^A-Za-z0-9]*[a-z]+"
+ "|"
+ "[A-Z]+[^A-Za-z0-9]*[0-9]+[^A-Za-z0-9]*[a-z]+"
+ ")"
+ ".*");

                String [] fileStr = {
                    "Marcelo23", // bate
                    "23Marcelo", // bate
                    "jaj@asdas33", // não bate
                    "josé da silva", // não bate
                    "12 tiradentes 23", // não bate
                    "12 Tiradentes 23", // bate
                };
                
		for (int i = 0; i &lt fileStr.length; ++i) {
		    if (pat.matcher (fileStr[i]).matches()) {
			System.out.println (fileStr[i]);
		    }
		}
	}
}