Java Controleer een tekenreeks op kleine letters / hoofdletters, speciale tekens en cijfers

1. Overzicht

In deze korte tutorial laten we zien hoe we dat kunnen controleer of a Draad bevat ten minste een van de volgende elementen: hoofdletter, kleine letter, cijfer of speciaal teken in Java.

2. Reguliere expressies gebruiken

Een van de manieren om onze controle uit te voeren, is door reguliere expressies te gebruiken. Lees dit artikel om vertrouwd te raken met reguliere expressies.

Laten we eerst de reguliere expressie definiëren voor elk van de vereiste tekengroepen. Aangezien reguliere expressies zijn opgelost, is het niet nodig om ze bij elke run te evalueren, dus we compileren ze voordat we ze vergelijken:

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

We moeten ook een eenvoudige methode maken die we gaan gebruiken om te testen of onze Draad voldoet aan de voorwaarden:

privé statische boolean isMatchingRegex (String-invoer) {boolean inputMatches = true; voor (Patroon inputRegex: inputRegexes) {if (! inputRegex.matcher (input) .matches ()) {inputMatches = false; }} return inputMatches; }

2.1. Enkele reguliere expressie

Het vorige voorbeeld is redelijk leesbaar en stelt ons in staat om indien nodig slechts enkele van de patronen gemakkelijk te gebruiken. Maar in het geval dat we er alleen om geven dat aan alle voorwaarden wordt voldaan, is het veel efficiënter om één enkele reguliere expressie te gebruiken.

Op die manier hebben we geen statisch blok nodig om al onze meerdere expressies te initialiseren en te compileren. Het zou ook niet nodig zijn om ze allemaal te herhalen en te zoeken welke overeenkomsten en welke niet.

Het enige wat we hoeven te doen is onze regex declareren:

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

En compileer en vergelijk het dan:

@Test openbare ongeldig gegevenSingleRegex_whenMatchingCorrectString_thenMatches () {String validInput = "Ab3;"; assertTrue (Pattern.compile (regex) .matcher (validInput) .matches ()); }

Er zijn een paar dingen die we moeten opmerken met betrekking tot onze reguliere expressie.

Ten eerste hebben we een positieve lookahead gebruikt (? = X) voor elke groep karakters. Dat betekent dat we verwachten X te vinden na het begin van de string (gemarkeerd met ^) om te matchen, maar we willen niet naar het einde van X, we willen liever aan het begin van de lijn blijven.

Een ander ding om op te merken is dat we deze keer niet hebben gebruikt [A-Z] of [a-z] voor lettergroepen, maar \ p {Lu} en \ p {Ll} in plaats daarvan. Deze komen overeen met elk type letter (in ons geval respectievelijk hoofdletters en kleine letters) uit elke taal, niet alleen Engels.

3. Core Java gebruiken

Laten we nu kijken hoe we dezelfde controle kunnen uitvoeren als we geen reguliere expressies willen gebruiken. We zullen profiteren van Karakter en Draad klassen en hun methoden om te controleren of alle vereiste tekens aanwezig zijn in onze Draad:

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. bevat (String.valueOf (currentCharacter))) {specialCharacterPresent = true;}} retour numberPresent && upperCasePresent && lowerCasePresent && specialCharacterPresent;}

We moeten hier een paar dingen opmerken. Het basisidee is dat we door onze Draad en controleer of de karakters van het vereiste type zijn. Door het gebruiken van Karakter class, kunnen we gemakkelijk controleren of een bepaald teken een cijfer, een hoofdletter of een kleine letter is.

Helaas is er geen vergelijkbare methode die ons zou vertellen of we te maken hebben met een van de speciale tekens. Het betekent dus dat we een andere benadering moeten kiezen.

We hebben een Draad met alle speciale tekens die we nodig hebben en vervolgens gecontroleerd of het ons specifieke teken bevat.

4. Conclusie

In dit korte artikel hebben we laten zien hoe u kunt controleren of een Draad bevat vereiste tekens. In het eerste scenario gebruikten we reguliere expressies, terwijl we in het tweede scenario gebruik maakten van Java-kernklassen.

Zoals gewoonlijk is de volledige broncode te vinden op GitHub.