Validieren das Passwort in Java

Beim Erstellen einer Anmeldeseite müssen wir oft das Passwort validieren und prüfen, ob es dem richtigen Standard entspricht oder nicht.
Die Validierung des Passworts umfasste die Überprüfung des Passworts, ob es gemäß der unten beschriebenen Passwortrichtlinie korrekt ist oder nicht:

1. Ein Standardpasswort besteht aus mindestens acht Zeichen
2. Ein normales Passwort enthält mindestens zwei Großbuchstaben
3. Ein Standardpasswort enthält zwei Kleinbuchstaben
4. Ein Standardpasswort enthält zwei Sonderzeichen

Algorithmus zum Validieren von Passwörtern in Java

1. Vor der Überprüfung unseres Passworts müssen wir angeben, wie viele Großbuchstaben, Kleinbuchstaben, Sonderbuchstaben oder Ziffern ein ideales Passwort enthalten sollte. Dazu definieren wir die Variablen MAX, MIN_Uppercase, MIN_Lowercase, Num_Digits und Special vom Typ int.
2. Um zu zählen, wie viele Großbuchstaben, Kleinbuchstaben, Ziffern oder Sonderzeichen unser Passwort enthält, deklarieren wir die Variablen uppercaseCounter, lowercaseCounter, special und digitCounter vom Typ Integer.
3. Nachdem wir die Zählervariablen deklariert haben, initialisieren wir sie mit 0. Indem wir die Zählervariablen mit 0 initialisieren, stellen wir sicher, dass sie keinen Müllwert enthalten.
4. Wir werden den Benutzer zuerst bitten, ein Passwort einzugeben, um das angegebene Passwort zu validieren. Um Benutzereingaben entgegenzunehmen, importieren wir zuerst die Scannerklasse in unser Programm und erstellen dann ein Objekt. In unserem Programmobjekt des Scanners wird Klasse eingegeben.
5. Die Scannerfunktion hat eine Standardfunktion von .nextLine(), die Benutzereingaben liest und diese dann in einer Zeichenfolge speichert.
6. Wir iterieren dann alle Passwortzeichen und speichern jedes Zeichen in einer c-Variablen vom Typ char.
7. Der Zeichendatentyp hat eine Standardfunktion isUpperCase, isLowerCase und isDigit. Anhand dieser Standardfunktionen berechnen wir, wie viele Groß- und Kleinbuchstaben, Sonderzeichen oder Zahlen unser Passwort enthält.
8. Wenn ein in der Variable c gespeichertes Zeichen ein Großbuchstabe ist, inkrementieren wir die Variable uppercaseCount um 1.
9. Wenn ein in einer c-Variable gespeichertes Zeichen ein Kleinbuchstabe ist, erhöhen wir die Variable lowercaseCounter um 1.
10. Wenn ein in c gespeichertes Zeichen eine Zahl ist, inkrementieren wir die Variable digitCounter um 1.
11. Wenn ein in c gespeichertes Zeichen ein Sonderzeichen ist, erhöhen wir einen Sonderzähler um 1.
12. Danach führen wir die bedingte Anweisung aus, um zu prüfen, ob unser Passwort die angegebenen Zeichen wie @#%, Klein- und Großbuchstaben und Ziffern enthält oder nicht.
13. Wenn das Passwort unsere angegebenen Kriterien erfüllt, drucken wir die Erklärung Validate password.
14. Falls das Passwort nicht alle oder einige unserer Bedingungen erfüllt, zeigen wir zuerst die Aussage Your password doesn't contain the following an.
15. Zuletzt prüfen wir, welche Bedingung(en) das Passwort nicht erfüllt, und zeigen dann die entsprechende Meldung an.

package sampleProject;
import java.util.*;
import java.util.Scanner;

public class Codesample {
  public static void main(String[] args) {
    // Specify the maximum number of letters in a password
    final int MAX = 8;

    // Specifying the number of uppercase letters in password
    final int MIN_Uppercase = 2;
    // Specifying the minimum lowercase letters in password
    final int MIN_Lowercase = 2;
    // Specifying the number of digits in a password
    final int NUM_Digits = 2;
    // Specify the minimum number of special case letters
    final int Special = 2;
    // Count number of uppercase letters in a password
    int uppercaseCounter = 0;
    // Counter lowercase letters in a password
    int lowercaseCounter = 0;
    // Count digits in a password
    int digitCounter = 0;
    // count special case letters in a password
    int specialCounter = 0;

    // Take input of password from the user

    System.out.println("Enter the password\n");

    Scanner input = new Scanner(System.in);

    // Take password input from the user and save it in the string password

    String password = input.nextLine();

    for (int i = 0; i < password.length(); i++) {
      char c = password.charAt(i);
      if (Character.isUpperCase(c))
        uppercaseCounter++;
      else if (Character.isLowerCase(c))
        lowercaseCounter++;
      else if (Character.isDigit(c))
        digitCounter++;
      if (c >= 33 && c <= 46 || c == 64) {
        specialCounter++;
      }
    }

    if (password.length() >= MAX && uppercaseCounter >= MIN_Uppercase
        && lowercaseCounter >= MIN_Lowercase && digitCounter >= NUM_Digits
        && specialCounter >= Special) {
      System.out.println("Valid Password");
    } else {
      System.out.println("Your password does not contain the following:");
      if (password.length() < MAX)
        System.out.println(" atleast 8 characters");
      if (lowercaseCounter < MIN_Lowercase)
        System.out.println("Minimum lowercase letters");
      if (uppercaseCounter < MIN_Uppercase)
        System.out.println("Minimum uppercase letters");
      if (digitCounter < NUM_Digits)
        System.out.println("Minimum number of numeric digits");
      if (specialCounter < Special)
        System.out.println("Password should contain at lest 3 special characters");
    }
  }
}

Ausgabe:

Your password does not contain the following:
At least 8 characters
Minimum lowercase letters
Minimum, uppercase letters
Minimum number of numeric digits
Password should contain at least 3 special characters

Enter the password

DElft@#90
Valid Password