Datautvinning eller validering är en viktig aspekt av varje programmeringsspråk. Ett av de mest populära sätten för datavalidering är att använda reguljära uttryck. använder dessaregelbundna uttryck för att beskriva ett teckenmönster. Denna artikel om Java Regex kommer att lista ut de olika metoderna för att använda uttryck i följande sekvens:
- Vad är reguljära uttryck?
- Vad är Java Regex?
- Matcher Class
- Mönster klass
- Regex karaktärsklass
- Regex-kvantifierare
- Regex metatecken
Låt oss börja!
Vad är reguljära uttryck?
TILL Vanligt uttryck är en sekvens av tecken som konstruerar ett sökmönster. När du söker efter data i en text kan du använda det här sökmönstret för att beskriva vad du letar efter.
Ett regelbundet uttryck kan vara en enstaka tecken eller ett mer komplicerat mönster. Den kan användas för alla typer av textsökning och textbyte. Ett Regex-mönster består av enkla tecken, till exempel / abc / , eller en kombination av enkla och specialtecken, till exempel / ab * c / eller /exempel(d+).d*/ .
Vad är Java Regex?
De Java Regex är ett API som är van vid definiera ett mönster för sökning eller manipulering . Det används ofta för att definiera begränsningar för strängar som lösenord och e-postvalidering.
Det finns olika metoder för att använda Java Regex. Så låt oss gå vidare och titta på de olika uttrycken.
Matcher Class
Den här klassen används för att utföra matchningsoperationer på en teckenföljd. Nedanstående tabell representerar olika metoder i Matcher-klassen.
hur man använder anaconda python
| Metod | Beskrivning |
|---|---|
| booleska tändstickor () | Testar om det angivna reguljära uttrycket matchar mönstret |
| booleska hitta () | Används för att hitta nästa uttryck som matchar mönstret |
| boolean hitta (int start) | Söker efter nästa uttryck som matchar mönstret från det angivna startnumret |
| Stränggrupp () | Används för att returnera matchad sekvens |
| int start () | Returnerar startindex för matchad sekvens |
| int slutet () | Returnerar slutindex för matchad sekvens |
| int groupCount () | Returnerar det totala antalet matchade sekvenser |
Mönster klass
Mönsterklass är en sammanställd version av reguljärt uttryck som används för att definiera mönstret för regex-motorn.
| Metod | Beskrivning |
|---|---|
| statisk mönsterkompilering (String regex) | Den sammanställer den givna regexen och returnerar förekomsten av mönstret |
| Matcher matcher(CharSequence input) | Den används för att skapa en matchare som matchar den angivna ingången med mönstret |
| statiska booleska matchningar (String regex, CharSequence input) | Det fungerar som en kombination av kompilerings- och matchningsmetoder. Det sammanställer det reguljära uttrycket och matchar den angivna inmatningen med mönstret |
| Sträng [] split (CharSequence input) | Används för att dela den givna ingångssträngen runt matchningar av ett visst mönster |
| Strängmönster () | Hjälper till att returnera regexmönstret |
Låt oss nu ta ett litet exempel för att förstå hur man skriver ett reguljärt uttryck.
importera java.util.regex. * offentlig klass RegexExempel {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('String matchar den givna Regex - + matcher.matches ())}}I det här fallet använder den mönster och matcher internt regex-klasser för att göra behandlingen men uppenbarligen,det minskar kodraderna. Mönsterklassen innehåller också matchningsmetod som tar regex och matar in sträng som argument och returnerar ett booleskt resultat efter att ha matchat dem. Så koden fungerar bra för matchande ingång med ett reguljärt uttryck i Java. Därför kommer produktionen att vara sant som visas nedan.
Produktion:
Sann
Låt oss nu se några fler kategorier av Java Regular Expressions.
Regex karaktärsklass
Nedanstående tabell representerar olika teckenklasskombinationer.
| Karaktärsklass | Beskrivning |
|---|---|
| [abc] | a, b eller c (enkel klass) |
| [^ abc] | Alla tecken utom a, b eller c (negation) |
| [a-zA-Z] | a till z eller A till Z, inklusive (intervall) |
| [a-d [m-p]] | a till d, eller m till p: [a-dm-p] (union) |
| [a-z && [def]] | d, e eller f (korsning) |
| [a-z && [^ bc]] | a till z, utom b och c: [ad-z] (subtraktion) |
| [a-z && [^ m-p]] | a till z, och inte m till p: [a-lq-z] (subtraktion) |
Exempel:
importera java.util.regex. * public class CharacterExample {public static void main (String args []) {// false (not x or y or z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (bland x eller y eller z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (x och y kommer mer än en gång) System .out.println (Mönstermatchningar ('[xyz]', 'xxyyyyyz'))}Regex-kvantifierare
Kvantifierarna anger antalet förekomster av ett tecken. Nedanstående tabell representerar olika kvantifierare.
| Regex | Beskrivning |
|---|---|
| X? | X förekommer en gång eller inte alls |
| X + | X förekommer en eller flera gånger |
| X * | X förekommer noll eller flera gånger |
| X {n} | X förekommer endast n gånger |
| X {n,} | X förekommer n eller flera gånger |
| X och Z} | X förekommer åtminstone y gånger men mindre än z gånger |
Exempel:
importera java.util.regex. * public class Exempel {public static void main (String args []) {System.out.println ('? quantifier ....') // (a eller y eller z kommer en gång) System.out.println (Pattern.matches ('[ayz]?', 'A')) // output: true System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay och z kommer mer än en gång) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // output: false // (a kommer mer än en gång) System. out.println (Pattern.matches ('[ayz]?', 'amnta')) // output: false // (a eller y eller z måste komma en gång) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // output: false System.out.println (' + kvantifierare .... ') // (a eller y eller z en eller flera gånger) System.out.println (Mönster .matches ('[ayz] +', 'a')) // output: true // (a kommer mer än en gång) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a eller y eller z kommer mer än en gång) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z och t är inte matchande mönster) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // output: false System.out.println ('* quantifier ....') // (a eller y eller z kan komma noll eller flera gånger ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // output: true}}I grund och botten kommer den att söka efter matchande kvantifierare och matcha sökresultatet.
Regex metatecken
Metatecken för reguljära uttryck fungerar som kortkoder. Låt oss titta på tabellen nedan för att förstå olika typer av metatecken.
| Regex | Beskrivning |
|---|---|
| . | Det kan vara vilken karaktär som helst (kanske eller inte matchar terminatorn) |
| d | Representerar alla siffror, mindre än [0-9] |
| D | Representerar alla icke-siffriga, kort för [^ 0-9] |
| s | Representerar alla blankstegstecken, kort för [tnx0Bfr] |
| S | Det kan vara en icke-blankstegstecken, förkortning för [^ s] |
| i | Det kan vara ett ordtecken, förkortat för [a-zA-Z_0-9] |
| I | Representerar alla tecken utan ord, förkortning för [^ w] |
| b | Representerar en ordgräns |
| B | Det är en gräns utan ord |
Exempel:
importera java.util.regex. * public class MetacharExample {public static void main (String args []) {// d betyder siffra System.out.println ('metacharacters d ....') // (icke-siffra) System.out.println (Pattern.matches ('d', 'abc')) // Output: false // (siffran kommer en gång) System.out.println (Pattern.matches ('d', '1') ) // Output: true // (siffror men kommer mer än en gång) System.out.println (Pattern.matches ('d', '4443')) // Output: false // (siffror och tecken) System.out .println (Pattern.matches ('d', '323abc')) // Output: false // D betyder icke-siffrigt System.out.println ('metatecken D ....') // (icke-siffrigt men kommer mer än en gång) System.out.println (Pattern.matches ('D', 'abc')) // Output: false // Its a Digit System.out.println (Pattern.matches ('D', '1 ')) // Output: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Output: false // (siffror och tecken) System.out.println (Pattern.matches (' D ',' 323abc ')) // Utgång: falsk // (icke-siffra och kommer en gång) System.out.println (Pattern.matches (' D ',' m ')) // Output: true System.out .pr intln ('metatecken D med kvantifierare ....') // (icke-siffra och kan komma 0 eller fler gånger) System.out.println (Mönstermatchningar ('D *', 'abc')) // Output : Sann } }Baserat på ovannämnda förhållanden kommer den att visa utdata. Så fungerar det. Så det handlade om olika typer av Regex. Med detta kommer vi till slutet av den här artikeln. Jaghoppas att du tyckte att det var informativt. Om du vill lära dig mer kan du kolla in vår också.
Kolla in av Edureka, ett pålitligt inlärningsföretag online med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen. Vi är här för att hjälpa dig med varje steg på din resa, för att bli en förutom de här Java-intervjufrågorna, kommer vi med en läroplan som är utformad för studenter och yrkesverksamma som vill vara Java-utvecklare.
ms sql tutorials för nybörjare
Har du en fråga till oss? Vänligen nämna det i kommentarsektionen i denna “Java Regex” -artikel så kommer vi tillbaka så snart som möjligt.