Cómo validar una contraseña usando expresiones regulares en Java

Dada una contraseña, la tarea es validar la contraseña con la ayuda de la expresión regular.
Una contraseña se considera válida si se cumplen todas las siguientes restricciones:

• Contiene al menos 8 caracteres y como máximo 20 caracteres.
• Contiene al menos un dígito.
• Contiene al menos un alfabeto en mayúsculas.
• Contiene al menos un alfabeto en minúsculas.
• Contiene al menos un carácter especial que incluye !@#$%&*()-+=^ .
• No contiene ningún espacio en blanco.

Ejemplos:

Entrada: Str = «Geeks@portal20»
Salida: Verdadero.
Explicación: Esta contraseña cumple con todas las restricciones mencionadas anteriormente.

Entrada: Str = «Geeksforgeeks»
Salida: Falso.
Explicación: contiene letras mayúsculas y minúsculas, pero no contiene dígitos ni caracteres especiales.

Entrada: Str = «Geeks@ portal9»
Salida: Falso.
Explicación: contiene letras en mayúsculas, letras en minúsculas, caracteres especiales, dígitos y espacios en blanco que no son válidos.

Entrada: Str = “12345”
Salida: Falso.
Explicación: contiene solo dígitos, pero no contiene alfabeto en mayúsculas, alfabeto en minúsculas, caracteres especiales y 8 caracteres.

Enfoque: Este problema se puede resolver usando Regular Expression .

1. Obtén la contraseña.
2. Cree una expresión regular para verificar que la contraseña sea válida o no, como se menciona a continuación:
   

   expresión regular = «^(?=.*[0-9])(?=.*[az])(?=.*[AZ])(?=.*[@#$%^&-+=() ])(?=\\S+$).{8, 20}$”

   dónde:

   • ^ representa el carácter inicial de la string.
   • (?=.*[0-9]) representa un dígito que debe aparecer al menos una vez.
   • (?=.*[az]) representa un alfabeto en minúsculas que debe aparecer al menos una vez.
   • (?=.*[AZ]) representa un alfabeto en mayúsculas que debe aparecer al menos una vez.
   • (?=.*[@#$%^&-+=()] representa un carácter especial que debe aparecer al menos una vez.
   • (?=\\S+$) no se permiten espacios en blanco en toda la string.
   • .{8, 20} representa al menos 8 caracteres y como máximo 20 caracteres.
   • $ representa el final de la string.
3. Haga coincidir la string dada con Regex. En Java, esto se puede hacer usando Pattern.matcher() .
4. Devuelve verdadero si la string coincide con la expresión regular dada; de lo contrario, devuelve falso.

A continuación se muestra la implementación del enfoque anterior:

// Java program to validate
// the password using ReGex
  
import java.util.regex.*;
class GFG {
  
    // Function to validate the password.
    public static boolean
    isValidPassword(String password)
    {
  
        // Regex to check valid password.
        String regex = "^(?=.*[0-9])"
                       + "(?=.*[a-z])(?=.*[A-Z])"
                       + "(?=.*[@#$%^&+=])"
                       + "(?=\\S+$).{8,20}$";
  
        // Compile the ReGex
        Pattern p = Pattern.compile(regex);
  
        // If the password is empty
        // return false
        if (password == null) {
            return false;
        }
  
        // Pattern class contains matcher() method
        // to find matching between given password
        // and regular expression.
        Matcher m = p.matcher(password);
  
        // Return if the password
        // matched the ReGex
        return m.matches();
    }
  
    // Driver Code.
    public static void main(String args[])
    {
  
        // Test Case 1:
        String str1 = "Geeks@portal20";
        System.out.println(isValidPassword(str1));
  
        // Test Case 2:
        String str2 = "Geeksforgeeks";
        System.out.println(isValidPassword(str2));
  
        // Test Case 3:
        String str3 = "Geeks@ portal9";
        System.out.println(isValidPassword(str3));
  
        // Test Case 4:
        String str4 = "1234";
        System.out.println(isValidPassword(str4));
  
        // Test Case 5:
        String str5 = "Gfg@20";
        System.out.println(isValidPassword(str5));
  
        // Test Case 6:
        String str6 = "geeks@portal20";
        System.out.println(isValidPassword(str6));
    }
}

true
false
false
false
false
false