Expresión regular para alfanumérico

Question

Quiero una expresión regular en java que debe contener al menos un alfabeto y un número en cualquier posición. Es por la contraseña que contiene los dígitos y los números.

Esto debería funcionar para:

"1a1b23nh" aceptado

"bc112w" Aceptado

"abc" No aceptó

"123" No se aceptan

caracteres especiales están No permitido.

Answer 1

(([a-z]+[0-9]+)+|(([0-9]+[a-z]+)+))[0-9a-z]* 

---

¿Qué tal un simple control de contenido? Compruebe si hay un número (s) y el carácter (s)

String input = "b45z4d"; 
boolean alpha = false; 
boolean numeric = false; 
boolean accepted = true; 
for (int i = 0; i < input.length(); ++i) 
{ 
    char c = input.charAt(i); 
    if (Character.isDigit(c)) 
    { 
     numeric = true; 
    } else if (Character.isLetter(c)) 
    { 
     alpha = true; 
    } else 
    { 
     accepted = false; 
     break; 
    } 
} 

if (accepted && alpha && numeric) 
{ 
    // Then it is correct 
} 

Answer 2

([0-9]+[a-zA-Z][0-9a-zA-Z]*)|([a-zA-Z]+[0-9][0-9a-zA-Z]*) 

Answer 3

Ésta es Python, mismo patrón debe trabajar en Java:

>>> import re 
>>> re.compile('[0-9a-z]*[0-9][0-9a-z]*[a-z][0-9a-z]*|[0-9a-z]*[a-z][0-9a-z]*[0-9][0-9a-z]*', re.I) 
<_sre.SRE_Pattern object at 0x830fbd0> 
>>> p=_ 
>>> for s in '1a1b23nh', 'bc112w', 'abc', '123': 
... print s, p.match(s) 
... 
1a1b23nh <_sre.SRE_Match object at 0xb73a3d78> 
bc112w <_sre.SRE_Match object at 0xb73a3d78> 
abc None 
123 None 

en segundo pensamiento, mejor añadir '$' al final, o coincidirá con 'ab12 /'

Answer 4

disculpe el ejemplo de javascript Lo descompongo para evitar una expresión regular difícil de leer.

function valid(s) { 
    return /^[a-z0-9]+$/i.test(s) && 
     /[a-z]+/i.test(s) && 
     /[0-9]+/.test(s) 
} 

valid('123a87') ; //# => true 
valid('A982') ; //# => true 
valid('$54 ') ; //# => false 
valid('123') ; //# => false 
valid('abd') ; //# => false 

Answer 5

sé que la cuestión ya han sido contestadas, y aceptado, pero esto es lo que haría: (? I)

Pattern pattern = Pattern.compile("(?i)(?:((?:\\d+[a-z]+)|(?:[a-z]+\\d+))\\w*)"); 

Object[][] tests = new Object[][] { 
     { "1a1b23nh", Boolean.valueOf(true) }, 
     { "bc112w", Boolean.valueOf(true) }, 
     { "abc", Boolean.valueOf(false) }, 
     { "123", Boolean.valueOf(false) } 
}; 

for (Object[] test : tests) { 
    boolean result = pattern.matcher((String)test[0]).matches(); 
    boolean expected = ((Boolean)test[1]).booleanValue(); 
    System.out.print(test[0] + (result ? "\t " : "\t not ") + "accepted"); 
    System.out.println(result != expected ? "\t test failed" : ""); 
} 
System.out.println("\nAll checks have been executed"); 

hace que el caso de expresiones regulares insensibles.