Java vérifie une chaîne pour les lettres minuscules / majuscules, les caractères spéciaux et les chiffres

1. Vue d'ensemble

Dans ce rapide didacticiel, nous illustrerons comment nous pouvons vérifier si une chaîne contient au moins l'un des éléments suivants: lettre majuscule, lettre minuscule, chiffre ou caractère spécial en Java .

2. Utilisation d'expressions régulières

L'une des façons d'effectuer notre vérification consiste à utiliser des expressions régulières. Pour vous familiariser avec les expressions régulières, veuillez consulter cet article.

Tout d'abord, définissons l'expression régulière pour chacun des groupes de caractères requis. Les expressions régulières étant fixes, il n'est pas nécessaire de les évaluer à chaque exécution, nous les compilerons donc avant de les comparer :

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]#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",/?].*"); }

De plus, nous devons créer une méthode simple que nous allons utiliser pour tester si notre chaîne correspond aux conditions:

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

2.1. Expression régulière unique

L'exemple précédent est assez lisible et nous permet de n'utiliser que certains des modèles facilement si nécessaire. Mais, dans un cas où nous ne nous soucions que de remplir toutes les conditions, il est beaucoup plus efficace d'utiliser une seule expression régulière.

De cette façon, nous n'aurions pas besoin d'un bloc statique pour initialiser et compiler toutes nos expressions multiples. En outre, il ne serait pas nécessaire de les parcourir tous et de trouver les correspondances et celles qui ne le sont pas.

Tout ce que nous devons faire est de déclarer notre regex:

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

Et puis compilez et comparez-le:

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

Il y a quelques points que nous devrions souligner concernant notre expression régulière.

Tout d'abord, nous avons utilisé une anticipation positive ( ? = X ) pour chaque groupe de caractères . Cela signifie que nous nous attendons à ce que X soit trouvé après le début de la chaîne (marqué par ^ ) afin de correspondre, mais nous ne voulons pas aller à la fin de X , nous voulons plutôt rester au début de la ligne .

Une autre chose à noter est que cette fois nous n'avons pas utilisé [AZ] ou [az] pour les groupes de lettres, mais \ p {Lu} et \ p {Ll} à la place. Celles-ci correspondront à tout type de lettre (dans notre cas, respectivement majuscules et minuscules) de n'importe quelle langue, pas seulement l'anglais.

3. Utilisation de Core Java

Voyons maintenant comment nous pouvons effectuer la même vérification si nous ne voulons pas utiliser d'expressions régulières. Nous allons profiter des classes Character et String et de leurs méthodes pour vérifier si tous les caractères requis sont présents dans notre 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; }

Nous devrions noter quelques points ici. L'idée de base est que nous parcourons notre chaîne et vérifions si ses caractères sont des types requis. En utilisant la classe Character , nous pouvons facilement vérifier si un certain caractère est un chiffre, une majuscule ou un caractère minuscule.

Malheureusement, il n'existe aucune méthode similaire qui nous dirait si nous avons affaire à l'un des caractères spéciaux. Donc, cela signifie que nous devons adopter une autre approche.

Nous avons créé une chaîne contenant tous les caractères spéciaux dont nous avons besoin, puis vérifié si elle contient notre caractère spécifique.

4. Conclusion

Dans cet article rapide, nous avons montré comment vérifier si une chaîne contient les caractères requis. Dans le premier scénario, nous avons utilisé des expressions régulières tandis que dans le second, nous avons profité des classes Java de base .

Comme d'habitude, le code source complet peut être trouvé sur GitHub.