TOC

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

Vérification par une chaîne Java d'une lettre minuscule / majuscule, d'un caractère spécial et d'un chiffre

1. Vue d'ensemble

Dans ce rapide didacticiel, nous allons illustrer comment nous pouvonscheck if a String is containing at least one of each of the following: uppercase letter, lowercase letter, digit or special character in Java.

2. Utiliser des expressions régulières

L’une des façons de procéder à notre vérification consiste à utiliser des expressions régulières. Pour vous familiariser avec les expressions régulières, veuillez consulterthis article.

Tout d’abord, définissons l’expression régulière pour chacun des groupes de caractères requis. Since regular expressions are fixed, there is no need to evaluate them at each run, so we’ll compile them before we compare against them: 

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 notreString 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 simple

L'exemple précédent est assez lisible et nous permet d'utiliser seulement certains motifs facilement si nécessaire. Toutefois, dans un cas où nous ne souhaitons remplir que 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. De plus, il n’était pas nécessaire de les parcourir tous et de trouver les correspondances et les autres.

Tout ce que nous avons à faire est de déclarer notre expression rationnelle: 

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 convient de souligner quelques points concernant notre expression régulière.

First, we’ve used positive lookahead (?=X) for every group of characters. Cela signifie que nous nous attendons à ce queX soit trouvé après le début de la chaîne (marqué avec^) afin de correspondre, mais nous ne voulons pas aller à la fin deX , nous voulons plutôt rester au début de la ligne.

Une autre chose à noter est que cette fois, nous n’avons pas utilisé[A-Z] ou[a-z] pour les groupes de lettres, mais\p{Lu} et\p{Ll} à la place. Ceux-ci correspondront à n'importe quel type de lettre (dans notre cas, respectivement majuscule et minuscule) 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 classesCharacter andString et de leurs méthodes pour vérifier si tous les caractères requis sont présents dans nosString: 

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 choses ici. L'idée de base est que nous parcourons nosString et vérifions si ses caractères sont des types requis. En utilisant la classeCharacter, nous pouvons facilement vérifier si un certain caractère est un chiffre, une majuscule ou une minuscule.

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

Nous avons créé unString contenant tous les caractères spéciaux dont nous avons besoin, puis vérifié s’il contient notre caractère spécifique.

4. Conclusion

Dans cet article rapide, nous avons montré comment vérifier si unString contient les caractères obligatoires. In the first scenario, we used regular expressions while in the second we took advantage of core Java classes.

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

Related