tipos - saber si una cadena contiene numeros java

¿Cómo verificar si una cadena contiene letras minúsculas, letras mayúsculas, caracteres especiales y dígitos?

Question

He estado buscando mucho en Google y no encontré una respuesta para mi pregunta:

¿Cómo puedo verificar con una expresión regular si una cadena contiene al menos una de cada una de estas:

• Letra mayúscula
• Letra minúscula
• Dígito
• Carácter especial: ~`!@#$%^&*()-_=+/|[{]};:''",<.>/?

Así que necesito al menos una letra mayúscula y al menos una letra pequeña y al menos un dígito y al menos un carácter especial.

Estoy seguro de que la respuesta es muy simple, pero no puedo encontrarla. Cualquier ayuda es muy apreciada.

Answer 1

Debido a que estos no aparecerán en ningún orden en particular, necesitará afirmaciones anticipadas para cada clase de personaje requerida:

(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[~!@#$%/^&*()/-_=+/|/[{/]};:''",<.>/?])

(NOTA: debido a que la barra diagonal inversa, el caret, el guión y los corchetes pueden ser especiales dentro de un rango, se deben eliminar las barras invertidas si aparecen en el rango, como se muestra en la cuarta afirmación de búsqueda anticipada).

Esta construcción se puede hacer mucho más legible usando espacios en blanco y comentarios, si su variante de expresiones regulares admite el modificador x . En java.util.regex , puedes hacer:

(?x)         # extended syntax
(?=.*[A-Z])  # look ahead for at least one upper case
(?=.*[a-z])  # look ahead for at least one lower case
(?=.*[0-9])  # look ahead for at least one numeral
(?=.*[~!@#$%/^&*()/-_=+/|/[{/]};:''",<.>/?])
             # look ahead for at least one of the listed symbols

Answer 2

Estás buscando clases de personajes .

• Gran letra: [AZ]
• Letra pequeña: [az]
• Dígito: [0-9] o / d
• Carácter especial: [^ A-Za-z0-9] (Es decir, no ninguno de los otros, donde ^ niega la clase)

Si desea probar ''esto'' o ''eso'', puede combinar esos rangos. Por ejemplo, las letras grandes o pequeñas serían [A-Za-z] .

Answer 3

Esto hace lo que quiere en java como un solo regex, aunque personalmente usaría algo como la solución provista por Mark Rhodes. Esto se volverá ridículo rápidamente (si no lo está ya ...) ya que las reglas se vuelven más complicadas.

String regex = "^(?=.*?//p{Lu})(?=.*?[//p{L}&&[^//p{Lu}]])(?=.*?//d)" + 
               "(?=.*?[`~!@#$%^&*()//-_=+//////|//[{//]};:''/",<.>/?]).*$"

1. ^ Esto coincide con el principio de la cadena. No es estrictamente necesario para que esto funcione, pero me parece que ayuda a la legibilidad y la comprensión. Además, usarlo cuando a menudo se logra una gran mejora en el rendimiento y casi nunca es una penalización.

2. (? = X ) Esto se llama un lookahead positivo. Básicamente, lo que estamos diciendo es "El principio de la cadena (^) debe ir seguido de esta cosa X para que coincida, pero NO avance el cursor hasta el final de X , permanezca al principio de la línea. ( esa es la parte de "mirar hacia adelante".

3. . *? / p {Lu} come caracteres después del comienzo de la línea hasta que encuentres una letra mayúscula. Esto no podrá coincidir si no se encuentra una letra mayúscula. Utilizamos / p {Lu} en lugar de AZ porque no queremos que personas de otras partes del mundo se den por vencidos y se quejen de cómo nuestro software fue escrito por un estadounidense ignorante.

4. Ahora volvemos al principio de la línea (retrocedemos porque usamos lookahead) y comenzamos a buscar. *? [/ P {L} && [^ / p {Lu}]] abreviatura de "todas las letras, menos las capitales "(por lo tanto coincide con minúsculas).

5. . *? / d +. *? [`~! @ # $% ^ & * () / -_ = + /// | / [{/]};: ''/", <.> /?] repita Para dígitos y para tu lista de caracteres especiales.

6. . * $ Combina todo lo demás hasta el final de la línea. Hacemos esto solo debido a la semántica de los métodos de ''coincidencias'' en java que ven si la cadena completa es una coincidencia para la expresión regular. Puede dejar esta parte y usar el método Matcher # find () y obtener el mismo resultado.

7. The Owl es uno de los mejores libros jamás escritos sobre cualquier tema técnico. Y es corto y rápido de leer. No puedo recomendarlo lo suficiente.

Answer 4

Estoy de acuerdo en que la respuesta de @ Alnitak es la más fácil de leer, sin embargo, se debe al hecho de que tiene que evaluar las expresiones regulares cada vez que se ejecuta. Dado que las expresiones regulares son fijas, tiene sentido compilarlas y compararlas. Por ejemplo, algo como:

    private static final Pattern [] passwordRegexes = new Pattern[4];
    {
        passwordRegexes[0] = Pattern.compile(".*[A-Z].*");
        passwordRegexes[1] = Pattern.compile(".*[a-z].*");
        passwordRegexes[2] = Pattern.compile(".*//d.*");
        passwordRegexes[3] = Pattern.compile(".*[~!].*");
    }
    public boolean isLegalPassword(String pass) {

        for(int i = 0; i < passwordRegexes.length; i++){
            if(!passwordRegexes[i].matcher(pass).matches())
                return false;
        }
        return true;
    }

Cuando se ejecutó 100,000 veces con una contraseña de 10 caracteres, el código anterior fue dos veces más rápido. Aunque, supongo que ahora puedes decir que este código es más difícil de leer. ¡No importa!

Answer 5

Las expresiones regulares no son muy buenas para las pruebas en las que se requieren todas las condiciones.

Por lo tanto, la respuesta más simple no es probar y probarlos todos al mismo tiempo, sino probar cada una de las cuatro clases sucesivamente.

Su código podría ser un poco más lento, pero será más fácil de leer y mantener, por ejemplo,

public boolean isLegalPassword(String pass) {

     if (!pass.matches(".*[A-Z].*")) return false;

     if (!pass.matches(".*[a-z].*")) return false;

     if (!pass.matches(".*//d.*")) return false;

     if (!pass.matches(".*[~!.......].*")) return false;

     return true;
}

EDITAR comillas fijas - estado haciendo demasiada maldita programación JS ...

Answer 6

/w : se usa para hacer coincidir alfanuméricos (los alfabetos pueden ser grandes o pequeños)
/W : se usa para hacer coincidir caracteres especiales

Creo que este RegEx será útil para usted:

[/w|/W]+

Aquí hay un buen RegEx Simulator , puede usarlo para construir su propio RegEx.