TOC

Java Verifique uma sequência de caracteres para letra minúscula/maiúscula, caractere especial e dígito

Java Verifique uma sequência de caracteres para letra minúscula / maiúscula, caractere especial e dígito

1. Visão geral

Neste tutorial rápido, vamos ilustrar como podemoscheck if a String is containing at least one of each of the following: uppercase letter, lowercase letter, digit or special character in Java.

2. Usando expressões regulares

Uma das maneiras de executar nossa verificação é usando expressões regulares. Para se familiarizar com as expressões regulares, verifiquethis article.

Em primeiro lugar, vamos definir a expressão regular para cada um dos grupos de caracteres necessários. 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]#$%^&*()\\-_=+\\\\|\\[{\\]};:'\",<.>/?].*");
}

Além disso, devemos criar um método simples que vamos usar para testar se nossoString corresponde às condições: 

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

2.1. Expressão regular única

O exemplo anterior é bastante legível e nos permite usar apenas alguns dos padrões facilmente, se necessário. Porém, em um caso em que nos preocupamos apenas em cumprir todas as condições, é muito mais eficiente usar uma única expressão regular.

Dessa forma, não precisaríamos de um bloco estático para inicializar e compilar todas as nossas múltiplas expressões. Além disso, não haveria necessidade de iterar sobre todos eles e encontrar quais correspondências e quais não.

Tudo o que precisamos fazer é declarar nossa regex: 

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

E então compile e compare: 

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

Há algumas coisas que devemos destacar em relação à nossa expressão regular.

First, we’ve used positive lookahead (?=X) for every group of characters. Isso significa que esperamos queX seja encontrado após o início da string (marcado com^) para corresponder, mas não queremos ir para o final deX , em vez disso, queremos ficar no início da linha.

Outra coisa a notar é que desta vez não usamos[A-Z] ou[a-z] para grupos de letras, mas\p{Lu}e\p{Ll} em vez disso. Elas corresponderão a qualquer tipo de letra (no nosso caso, maiúsculas e minúsculas, respectivamente) de qualquer idioma, não apenas o inglês.

3. Usando Core Java

Vamos agora ver como podemos realizar a mesma verificação se não quisermos usar expressões regulares. Aproveitaremos as classesCharacter andString e seus métodos para verificar se todos os caracteres obrigatórios estão presentes em nossoString: 

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;
}

Devemos observar algumas coisas aqui. A ideia básica é iterarmos por meio de nossoStringe verificar se seus caracteres são dos tipos necessários. Usando a classeCharacter, podemos facilmente verificar se um determinado caractere é um dígito, maiúsculo ou minúsculo.

Infelizmente, não existe um método semelhante que nos diga se estamos lidando com um dos caracteres especiais. Então, isso significa que precisamos adotar outra abordagem.

Criamos umString contendo todos os caracteres especiais de que precisamos e, em seguida, verificamos se ele contém nosso caractere específico.

4. Conclusão

Neste artigo rápido, mostramos como verificar seString contém caracteres obrigatórios. In the first scenario, we used regular expressions while in the second we took advantage of core Java classes.

Como de costume, o código-fonte completo pode ser encontradoover on GitHub.

Related