Java Überprüfen Sie eine Zeichenfolge auf Kleinbuchstaben / Großbuchstaben, Sonderzeichen und Ziffern

1. Übersicht

In diesem kurzen Tutorial, werden wir zeigen , wie wir können prüfen , ob ein String ist mindestens eine von jedem der folgenden enthalten: Großbuchstaben, Kleinbuchstaben, Ziffer oder ein Sonderzeichen in Java .

2. Verwenden regulärer Ausdrücke

Eine Möglichkeit, unsere Prüfung durchzuführen, ist die Verwendung regulärer Ausdrücke. Um sich mit regulären Ausdrücken vertraut zu machen, lesen Sie bitte diesen Artikel.

Definieren wir zunächst den regulären Ausdruck für jede der erforderlichen Zeichengruppen. Da reguläre Ausdrücke festgelegt sind, müssen sie nicht bei jedem Lauf ausgewertet werden. Daher werden sie kompiliert, bevor wir sie vergleichen :

private static final Pattern[] inputRegexes = new Pattern[4]; static { inputRegexes[0] = Pattern.compile(".*[A-Z].*"); inputRegexes[1] = Pattern.compile(".*[a-z].*"); inputRegexes[2] = Pattern.compile(".*\\d.*"); inputRegexes[3] = Pattern.compile(".*[`[email protected]#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",/?].*"); }

Außerdem sollten wir eine einfache Methode erstellen, mit der wir testen, ob unser String den Bedingungen entspricht:

private static boolean isMatchingRegex(String input) { boolean inputMatches = true; for (Pattern inputRegex : inputRegexes) { if (!inputRegex.matcher(input).matches()) { inputMatches = false; } } return inputMatches; }

2.1. Einzelner regulärer Ausdruck

Das vorherige Beispiel ist ziemlich lesbar und ermöglicht es uns, bei Bedarf nur einige der Muster einfach zu verwenden. In einem Fall, in dem es uns nur darum geht, alle Bedingungen zu erfüllen, ist es jedoch viel effizienter, einen einzelnen regulären Ausdruck zu verwenden.

Auf diese Weise benötigen wir keinen statischen Block, um alle unsere mehreren Ausdrücke zu initialisieren und zu kompilieren. Es wäre auch nicht nötig, alle zu durchlaufen und herauszufinden, welche Übereinstimmungen und welche nicht.

Alles was wir tun müssen, ist unsere Regex zu deklarieren:

String regex = "^(?=.*?\\p{Lu})(?=.*?\\p{Ll})(?=.*?\\d)" + "(?=.*?[`[email protected]#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",/?]).*$";

Und dann kompilieren und vergleichen:

@Test public void givenSingleRegex_whenMatchingCorrectString_thenMatches() { String validInput = "Ab3;"; assertTrue(Pattern.compile(regex).matcher(validInput).matches()); }

Es gibt einige Dinge, auf die wir in Bezug auf unseren regulären Ausdruck hinweisen sollten.

Zuerst haben wir für jede Gruppe von Zeichen einen positiven Lookahead ( ? = X ) verwendet . Das bedeutet, dass wir erwarten, dass X nach dem Anfang des Strings (markiert mit ^ ) gefunden wird, um übereinzustimmen, aber wir wollen nicht zum Ende von X gehen , sondern am Anfang der Zeile bleiben .

Eine andere bemerkenswerte Sache ist, dass wir diesmal nicht [AZ] oder [az] für Buchstabengruppen verwendet haben, sondern stattdessen \ p {Lu} und \ p {Ll} . Diese entsprechen jeder Art von Buchstaben (in unserem Fall Groß- und Kleinbuchstaben) aus jeder Sprache, nicht nur Englisch.

3. Verwenden von Core Java

Lassen Sie uns nun sehen, wie wir dieselbe Prüfung durchführen können, wenn wir keine regulären Ausdrücke verwenden möchten. Wir nutzen Charakter und String - Klassen und ihre Methoden , wenn alle erforderlichen Zeichen in unserer Gegenwart sind zu überprüfen String :

private static boolean checkString(String input) { String specialChars = "~`[email protected]#$%^&*()-_=+\\|[{]};:'\",/?"; char currentCharacter; boolean numberPresent = false; boolean upperCasePresent = false; boolean lowerCasePresent = false; boolean specialCharacterPresent = false; for (int i = 0; i < input.length(); i++) { currentCharacter = input.charAt(i); if (Character.isDigit(currentCharacter)) { numberPresent = true; } else if (Character.isUpperCase(currentCharacter)) { upperCasePresent = true; } else if (Character.isLowerCase(currentCharacter)) { lowerCasePresent = true; } else if (specialChars.contains(String.valueOf(currentCharacter))) { specialCharacterPresent = true; } } return numberPresent && upperCasePresent && lowerCasePresent && specialCharacterPresent; }

Wir sollten hier einige Dinge beachten. Die Grundidee ist, dass wir unseren String durchlaufen und prüfen, ob seine Zeichen vom erforderlichen Typ sind. Mithilfe der Zeichenklasse können wir leicht überprüfen, ob ein bestimmtes Zeichen eine Ziffer, ein Groß- oder Kleinbuchstabe ist.

Leider gibt es keine ähnliche Methode, die uns sagen würde, ob es sich um eines der Sonderzeichen handelt. Das bedeutet, dass wir einen anderen Ansatz wählen müssen.

Wir haben eine erstellt String enthält alle Sonderzeichen wir brauchen , und dann überprüft , ob es unsere spezifischen Charakter enthält.

4. Fazit

In diesem kurzen Artikel haben wir gezeigt, wie Sie überprüfen, ob ein String die erforderlichen Zeichen enthält. Im ersten Szenario haben wir reguläre Ausdrücke verwendet, während wir im zweiten die Java-Kernklassen genutzt haben .

Wie üblich finden Sie den vollständigen Quellcode auf GitHub.