Java Controlla una stringa per lettere minuscole / maiuscole, caratteri speciali e cifre

1. Panoramica

In questo rapido tutorial, illustreremo come possiamo verificare se una stringa contiene almeno uno dei seguenti elementi: lettera maiuscola, lettera minuscola, cifra o carattere speciale in Java .

2. Utilizzo di espressioni regolari

Uno dei modi per eseguire il nostro controllo è utilizzare espressioni regolari. Per acquisire familiarità con le espressioni regolari, consulta questo articolo.

Prima di tutto, definiamo l'espressione regolare per ciascuno dei gruppi di caratteri richiesti. Poiché le espressioni regolari sono fisse, non è necessario valutarle ad ogni esecuzione, quindi le compileremo prima di confrontarle con esse :

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

Inoltre, dovremmo creare un metodo semplice che useremo per verificare se la nostra stringa soddisfa le condizioni:

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

2.1. Espressione regolare singola

L'esempio precedente è abbastanza leggibile e ci consente di utilizzare facilmente solo alcuni dei modelli, se necessario. Ma, nel caso in cui ci preoccupiamo solo di soddisfare tutte le condizioni, è molto più efficiente usare una singola espressione regolare.

In questo modo non avremmo bisogno di un blocco statico per inizializzare e compilare tutte le nostre espressioni multiple. Inoltre, non ci sarebbe bisogno di iterarli su tutti e trovare quali corrispondenze e quali no.

Tutto quello che dobbiamo fare è dichiarare la nostra regex:

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

E poi compilarlo e confrontarlo:

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

Ci sono alcune cose che dovremmo sottolineare riguardo alla nostra espressione regolare.

Innanzitutto, abbiamo utilizzato un lookahead positivo ( ? = X ) per ogni gruppo di caratteri . Ciò significa che ci aspettiamo che X venga trovato dopo l'inizio della stringa (contrassegnato con ^ ) per corrispondere, ma non vogliamo andare alla fine di X , piuttosto vogliamo rimanere all'inizio della riga .

Un'altra cosa da notare è che questa volta non abbiamo usato [AZ] o [az] per i gruppi di lettere, ma invece \ p {Lu} e \ p {Ll} . Questi corrisponderanno a qualsiasi tipo di lettera (nel nostro caso, rispettivamente maiuscole e minuscole) da qualsiasi lingua, non solo dall'inglese.

3. Utilizzo di Core Java

Vediamo ora come possiamo eseguire lo stesso controllo se non vogliamo usare espressioni regolari. Approfitteremo delle classi Character e String e dei loro metodi per verificare se tutti i caratteri richiesti sono presenti nella nostra 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; }

Dovremmo notare alcune cose qui. L'idea di base è che iteriamo attraverso la nostra stringa e controlliamo se i suoi caratteri sono dei tipi richiesti. Usando la classe Character , possiamo facilmente controllare se un certo carattere è una cifra, un carattere maiuscolo o minuscolo.

Sfortunatamente, non esiste un metodo simile che ci dica se abbiamo a che fare con uno dei caratteri speciali. Quindi, significa che dobbiamo adottare un altro approccio.

Abbiamo creato una stringa contenente tutti i caratteri speciali di cui abbiamo bisogno e quindi abbiamo verificato se contiene il nostro carattere specifico.

4. Conclusione

In questo rapido articolo, abbiamo mostrato come verificare se una stringa contiene i caratteri richiesti. Nel primo scenario, abbiamo utilizzato espressioni regolari mentre nel secondo abbiamo sfruttato le classi Java principali .

Come al solito, il codice sorgente completo può essere trovato su GitHub.