Java >> Java tutorial >  >> Tag >> char

Java Tjek en streng for små/store bogstaver, specialtegn og ciffer

char

1. Oversigt

I dette hurtige selvstudie illustrerer vi, hvordan vi kan kontrollere, om en streng indeholder mindst én af hver af følgende:stort bogstav, lille bogstav, ciffer eller specialtegn i Java .

2. Brug af regulære udtryk

En af måderne at udføre vores check på er ved at bruge regulære udtryk. For at blive fortrolig med regulære udtryk, tjek venligst denne artikel.

Lad os først og fremmest definere det regulære udtryk for hver af de påkrævede tegngrupper. Da regulære udtryk er rettet, er der ingen grund til at evaluere dem ved hver kørsel, så vi kompilerer dem, før vi sammenligner med dem :

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

Vi bør også oprette en simpel metode, som vi skal bruge til at teste, om vores String matcher betingelserne:

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

2.1. Enkelt regulært udtryk

Det forrige eksempel er ret læsbart og giver os mulighed for nemt at bruge nogle af mønstrene, hvis det er nødvendigt. Men i et tilfælde, hvor vi kun bekymrer os om at opfylde alle betingelserne, er det meget mere effektivt at bruge et enkelt regulært udtryk.

På den måde ville vi ikke have brug for en statisk blok for at initialisere og kompilere alle vores multiple udtryk. Det ville heller ikke være nødvendigt at gentage dem alle og finde, hvilke matcher og hvilke der ikke gør.

Alt vi skal gøre er at erklære vores regex:

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

Og kompilér og sammenlign det derefter:

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

Der er et par ting, vi bør påpege vedrørende vores regulære udtryk.

For det første har vi brugt positivt lookahead (?=X ) for hver gruppe af tegn . Det betyder, at vi forventer X findes efter begyndelsen af ​​strengen (markeret med ^ ) for at matche, men vi ønsker ikke at gå til slutningen af ​​X , snarere ønsker vi at blive ved begyndelsen af ​​linjen.

En anden ting at bemærke er, at denne gang brugte vi ikke [A-Z] eller [a-z] for bogstavgrupper, men \p{Lu} og \p{Ll} i stedet. Disse vil matche enhver form for bogstav (i vores tilfælde, henholdsvis store og små bogstaver) fra ethvert sprog, ikke kun engelsk.

3. Brug af Core Java

Lad os nu se, hvordan vi kan udføre den samme kontrol, hvis vi ikke ønsker at bruge regulære udtryk. Vi vil drage fordel af Karakter  og streng klasser og deres metoder til at kontrollere, om alle nødvendige tegn er til stede i vores streng :

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

Vi bør bemærke et par ting her. Grundtanken er, at vi gentager vores streng og kontroller, om dens tegn er af den påkrævede type. Ved at bruge Tegn klasse, kan vi nemt kontrollere, om et bestemt tegn er et ciffer, et stort eller et lille tegn.

Desværre er der ingen lignende metode, der vil fortælle os, om vi har at gøre med en af ​​specialkaraktererne. Så det betyder, at vi er nødt til at tage en anden tilgang.

Vi har oprettet en streng indeholdende alle specialtegn, vi har brug for, og derefter kontrolleret, om det indeholder vores specifikke tegn.

4. Konklusion

I denne hurtige artikel har vi vist, hvordan du kontrollerer, om en streng indeholder påkrævede tegn. I det første scenarie brugte vi regulære udtryk, mens vi i det andet udnyttede kerne Java-klasser .

Som sædvanlig kan komplet kildekode findes på GitHub.


Java tag