java regex tutorial with regular expression examples
Denna Java Regex-handledning förklarar vad som är ett reguljärt uttryck i Java, varför vi behöver det och hur man använder det med hjälp av exempel på reguljärt uttryck:
TILL vanligt uttryck i Java som förkortas som “ regex ”Är ett uttryck som används för att definiera ett sökmönster för strängar.
Sökmönstret kan vara en enkel karaktär eller ett substrat eller det kan vara en komplex sträng eller ett uttryck som definierar ett visst mönster som ska sökas i strängen.
Vidare kan mönstret behöva matcha en eller flera gånger till strängen.
=> Besök här för att se Java Training Series för alla.
Vad du kommer att lära dig:
Vanligt uttryck: Varför vi behöver det
Ett vanligt uttryck används främst för att söka efter ett mönster i en sträng. Varför söker vi efter ett mönster i en sträng? Vi kanske vill hitta ett visst mönster i en sträng och sedan manipulera det eller redigera det.
Så i en datorprogram kan vi ha ett kontinuerligt krav på att manipulera olika mönster. Därför kräver vi alltid regex för att underlätta sökandet efter mönstret.
Nu får du ett mönster att söka efter, hur exakt fungerar regex?
När vi analyserar och ändrar texten med hjälp av en regex säger vi att ”vi har tillämpat regex på strängen eller texten”. Vad vi gör är att vi tillämpar mönstret på texten i 'vänster till höger' -riktning och källsträngen matchas med mönstret.
Till exempel, överväga en sträng “ ababababab ”. Låt oss anta att en regex 'aba' definieras. Så nu måste vi tillämpa denna regex på strängen. Tillämpa regex från vänster till höger, regex matchar strängen “ aba_aba___ ”, På två platser.
Så snart en källtecken används i en matchning kan vi inte återanvända den. Efter att ha hittat den första matchen aba återanvänds inte den tredje karaktären ”a”.
testmall i Excel i Excel
java.util.regex
Java-språket innehåller ingen inbyggd klass för regex. Men vi kan arbeta med reguljära uttryck genom att importera java.util.regex ”Paket.
Paketet java.util.regex har ett gränssnitt och tre klasser som visas nedan:
Mönster klass: En mönsterklass representerar den sammanställda regexen. Mönsterklassen har inga offentliga konstruktörer men den ger statiska kompileringsmetoder () som returnerar mönsterobjekt och kan användas för att skapa ett mönster.
Matcher Class: Matcher-klassobjektet matchar regex-mönstret till strängen. Liksom mönsterklassen tillhandahåller denna klass inte heller några offentliga konstruktörer. Det tillhandahåller matcher () -metoden som returnerar ett Matcher-objekt.
MönsterSyntaxException: Denna klass definierar ett okontrollerat undantag. Ett objekt av typen PatternSyntaxException returnerar ett okontrollerat undantag som indikerar ett syntaxfel i regex-mönster.
MatchResult-gränssnitt: MatchResult-gränssnittet bestämmer resultatet för regexmönstermatchning.
Java Regex Exempel
Låt oss implementera ett enkelt exempel på regex i Java. I programmet nedan har vi en enkel sträng som mönster och sedan matchar vi den med en sträng. Utgången skriver ut start- och slutpositionen i strängen där mönstret finns.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //define a pattern to be searched Pattern pattern = Pattern.compile('Help.'); // Search above pattern in 'softwareTestingHelp.com' Matcher m = pattern.matcher('softwareTestingHelp.com'); // print the start and end position of the pattern found while (m.find()) System.out.println('Pattern found from position ' + m.start() + ' to ' + (m.end()-1)); } } Produktion:
Mönster hittat från 15 till 19
Regex Matcher In Java
Matcher-klassen implementerar MatchResult-gränssnittet. Matcher fungerar som en regex-motor och används för att utföra den exakta matchningen av en teckenföljd.
Nedan följer de vanliga metoderna i Matcher-klassen. Det har fler metoder men vi har listat endast de viktiga metoderna nedan.
| Nej | Metod | Beskrivning |
|---|---|---|
| 7 | int start () | Ger startindex för matchad sekvens och returnerar det. |
| ett | booleska tändstickor () | Kontrollerar om regexen matchar mönstret. |
| två | Mönstermönster () | Returnerar det mönster som matcharen tolkar. |
| 3 | booleska hitta () | Den här metoden hittar nästa uttryck som ska matchas till mönstret. |
| 4 | boolean hitta (int start) | Samma som find () men hittar uttrycket som ska matchas från den givna startpositionen. |
| 5 | Stränggrupp () | Returnerar den sekvens som matchar mönstret. |
| 6 | Stränggrupp (strängnamn) | Returnerar ingångssekvensen. Detta fångas i den tidigare matchningsoperationen genom att fånga gruppen med det angivna namnet. |
| 8 | int slutet () | Returnerar slutposition / index för matchad sekvens. |
| 9 | int groupCount () | Returnera det totala antalet matchade sekvenser. |
| 10 | Sträng ersättare Alla (Strängbyte) | Ersätt alla sekvenser av ingångssekvensen som matchar mönstret med en given ersättningssträng. |
| elva | Sträng ersättaFörsta (Strängbyte) | Ersätt den första matchande sekvensen av inmatningssekvensen med den angivna ersättningssträngen. |
| 12 | String toString () | Returnera strängrepresentationen för den aktuella matcharen. |
Exempel på implementering av reguljärt uttryck
Låt oss se ett exempel på användningen av några av dessa metoder.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherDemo { public static void main(String() args) { String inputString = 'She sells sea shells on the sea shore with shells'; //obtain a Pattern object Pattern pattern = Pattern.compile('shells'); // obtain a matcher object System.out.println('input string: ' + inputString); Matcher matcher = pattern.matcher(inputString); inputString = matcher.replaceFirst('pearls'); System.out.println('
replaceFirst method:' + inputString); //use replaceAll method to replace all occurrences of pattern inputString = matcher.replaceAll('pearls'); System.out.println('
replaceAll method:' + inputString); } } Produktion:
inmatningssträng: Hon säljer snäckskal på stranden med skal
Ersätt den första metoden: Hon säljer havspärlor på stranden med skal
ersätt Alla metoden: Hon säljer havspärlor på stranden med pärlor
Regex Mönster Klass I Java
Mönsterklass definierar mönstret för regex-motorn som sedan kan användas för att matcha ingångssträngen.
standard gateway inte tillgängligt Windows 10 fix
Följande tabell visar de metoder som tillhandahålls av mönsterklassen som ofta används.
| Nej | Metod | Beskrivning |
|---|---|---|
| 7 | Sträng () split (CharSequence input, int limit) | Inmatningssträngen delas runt matchningar som hittats av ett visst mönster. |
| ett | statisk mönsterkompilering (String regex) | Returnerar kompilerad representation av regex. |
| två | statisk mönsterkompilering (String regex, int-flaggor) | Kompilerar angiven regex med angivna flaggor och returmönster. |
| 3 | Matcher matcher(CharSequence input) | Returnerar en matchare genom att matcha inmatningssekvensen med mönstret. |
| 4 | statiska booleska matchningar (String regex, CharSequence input) | Kompilerar den givna regexen och matchar mönstret med en given ingång. |
| 5 | int-flaggor () | Returnerar flaggor för det mönster som matchningen görs med. |
| 6 | Sträng () split (CharSequence input) | Inmatningssträngen delas runt matchningar som hittats av ett visst mönster. |
| 8 | Strängmönster () | Returnerar det reguljära uttrycksmönstret. |
| 9 | statisk strängoffert (strängar) | Returnerar en bokstavlig sträng (mönster) för den angivna strängen. |
| 10 | String toString () | Få strängrepresentation av mönstret. |
Nedanstående exempel använder några av ovanstående metoder för mönsterklass.
import java.util.regex.*; public class Main { public static void main(String() args) { // define a REGEX String String REGEX = 'Test'; // string to be searched for given pattern String actualString = 'Welcome to SoftwareTestingHelp portal'; // generate a pattern for given regex using compile method Pattern pattern = Pattern.compile(REGEX); // set limit to 2 int limit = 2; // use split method to split the string String() array = pattern.split(actualString, limit); // print the generated array for (int i = 0; i Regex-strängmatchningsmetod Vi har sett metoden String.Contains () i våra stränghandledningar. Den här metoden returnerar ett booleskt värde true eller false beroende på om strängen innehåller ett angivet tecken i det eller inte.
På samma sätt har vi en metod 'matches ()' för att kontrollera om strängen matchar med ett reguljärt uttryck eller regex. Om strängen matchar den angivna regexen returneras ett sant värde eller annars returneras false.
Den allmänna syntaksen för matches () -metoden:
public boolean matches (String regex)Om den angivna regexen inte är giltig kastas 'PatternSyntaxException'.
Låt oss implementera ett program för att demonstrera användningen av matches () -metoden.
public class MatchesExample{ public static void main(String args()){ String str = new String('Java Series Tutorials'); System.out.println('Input String: ' + str); //use matches () method to check if particular regex matches to the given input System.out.print('Regex: (.*)Java(.*) matches string? ' ); System.out.println(str.matches('(.*)Java(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)Series(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)String(.*)')); System.out.print('Regex: (.*)Tutorials matches string? ' ); System.out.println(str.matches('(.*)Tutorials')); } } Produktion:
Input String: Java Series Tutorials
Regex: (. *) Java (. *) Matchar strängen? Sann
Regex: (. *) Serien (. *) Matchar strängen? Sann
Regex: (. *) Serien (. *) Matchar strängen? falsk
Regex: (. *) Självstudier matchar sträng? Sann
Vi använder många specialtecken och metatecken med regelbundna uttryck i Java. Vi använder också många karaktärsklasser för mönstermatchning. I det här avsnittet tillhandahåller vi tabellerna som innehåller teckenklasser, metatecken och kvantifierare som kan användas med regex.
Regex karaktärsklasser
Nej Karaktärsklass Beskrivning 7 (a-z && (^ m-p)) Subtraktion: a till z, och inte m genom p: (a-lq-z) ett (pqr) p, q eller r två (^ pqr) Negation: Alla tecken utom p, q eller r 3 (a-zA-Z) Område: a till z eller A till Z, inklusive 4 (a-d (m-p)) Union: a till d, eller m till p: (a-dm-p) 5 (a-z && (def)) Korsning: d, e eller f 6 (a-z && (^ bc)) Subtraktion: a till z, utom b och c: (ad-z)
Regex-kvantifierare
Kvantifierare används för att ange hur många gånger tecknet ska förekomma i regex.
Följande tabell visar de vanliga regex-kvantifierarna som används i Java.
Nej Regex kvantifierare Beskrivning 7 I Alla tecken utan ord, (^ w) ett x? x visas en gång eller inte alls två x + x visas en eller flera gånger 3 x * x förekommer noll eller flera gånger 4 x {n} x förekommer n gånger 5 x {n,} x förekommer n eller flera gånger 6 X och Z} x förekommer åtminstone y gånger men mindre än z gånger
Regex Meta-tecken
Metatecken i regex fungerar som stenografiska koder. Dessa koder inkluderar blanksteg och icke-blankstegstecken tillsammans med andra kortkoder.
Följande tabell visar regex-metatecken.
Nej Metatecken Beskrivning ett . Varje tecken (matchar eventuellt terminator) två d Alla siffror, (0-9) 3 D Alla icke-siffriga, (^ 0-9) 4 s Valfri blanksteg, ( t n x0B f r) 5 S Alla tecken som inte är blanksteg, (^ s) 6 i Vilket ord som helst, (a-zA-Z_0-9) 8 b En ordgräns 9 B En gräns utan ord
Nedan följer ett Java-program som använder ovanstående specialtecken i Regex.
import java.util.regex.*; public class RegexExample{ public static void main(String args()){ // returns true if string exactly matches 'Jim' System.out.print('Jim (jim):' + Pattern.matches('Jim', 'jim')); // Returns true if the input string is Peter or peter System.out.println('
(Pp)eter(Peter) :' + Pattern.matches('(Pp)eter', 'Peter')); //true if string = abc System.out.println('
.*abc.*(pqabcqp) :' + Pattern.matches('.*abc.*', 'pqabcqp')); // true if string doesn't start with a digit System.out.println('
^(^\d).*(abc123):' + Pattern.matches('^(^\d).*', 'abc123')); // returns true if the string contains exact three letters System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z) (aQz):' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z)', 'aQz')); System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z', 'a10z')); //input string length = 4 // true if the string contains 0 or more non-digits System.out.println('
\D*, abcde:' + Pattern.matches('\D*', 'abcde')); //True // true of line contains only word this ^-start of the line, $ - end of the line System.out.println('
^This$, This is Java:' + Pattern.matches('^This$', 'This is Java')); System.out.println('
^This$, This:' + Pattern.matches('^This$, This', 'This')); System.out.println('
^This$, Is This Java?:' + Pattern.matches('^This$, Is This Java?', 'Is This Java?')); } } Produktion:
Jim (jim): falsk
(Pp) eter (Peter): sant
. * abc. * (pqabcqp): sant
^ (^ d). * (abc123): sant
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): sant
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: sant
^ Detta $, detta är Java: falskt
^ Detta $, detta: falskt
^ Detta $, är det här Java?: Falskt
I programmet ovan har vi tillhandahållit olika regexer som matchas med inmatningssträngen. Läsarna rekommenderas att läsa kommentarerna i programmet för varje regex för att bättre förstå konceptet.
Regex Logical eller (|) Operator
Vi kan använda det logiska eller (| operator) i regex som ger oss valet att välja antingen operand av | operatör. Vi kan använda den här operatören i en regex för att välja tecken eller sträng. Till exempel, om vi vill matcha både orden, 'test' och 'Test', kommer vi att inkludera dessa ord i logisk eller operatör som Test | test.
Låt oss se följande exempel för att förstå den här operatören.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexOR { public static void main(String() args) { // Regex string to search for patterns Test or test String regex = '(Test|test)'; // Compiles the pattern and obtains the matcher object from input string. Pattern pattern = Pattern.compile(regex); String input = 'Software Testing Help'; Matcher matcher = pattern.matcher(input); // print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } //define another input string and obtain the matcher object input = 'SoftwaretestingHelp'; matcher = pattern.matcher(input); // Print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } } } Produktion:
Text ”Test” hittades kl. 9 till 13.
Text ”test” hittades vid 8 till 12.
I detta program har vi tillhandahållit regexen “(Test | test)”. Sedan ger vi först inmatningssträngen som “Software Testing Help” och matchar mönstret. Vi ser att matchen hittas och positionen skrivs ut.
Därefter ger vi inmatningssträngen som “SoftwaretestingHelp”. Den här gången hittas också matchen. Detta beror på att regex har använt eller operatör och därmed mönstret på vardera sidan av | operatören matchas med strängen.
E-postvalidering med Regex
Vi kan också validera e-post-id (adress) med regex med java.util.regex.Pattern.matches () -metoden. Det matchar det angivna e-post-id: t med regex och returnerar true om e-postmeddelandet är giltigt.
Följande program visar validering av e-post med regex.
public class EmailDemo { static boolean isValidemail(String email) { String regex = '^(\w-_\.+)*(\w-_\.)\@((\w)+\.)+(\w)+(\w)$'; //regex to validate email. return email.matches(regex); //match email id with regex and return the value } public static void main(String() args) { String email = 'ssthva@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); email = '@sth@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); } } Produktion:
E-post-ID: t är: ssthva@gmail.com
E-post-ID giltigt? Sann
E-post-ID: t är: @ sth @ gmail.com
E-post-ID giltigt? falsk
Som vi kan se från ovanstående utgång är det första e-post-ID giltigt. Det andra id: et börjar direkt med @, och därmed validerar regex det inte. Därför är det ett ogiltigt ID.
sql intervju frågor och svar för testare
Vanliga frågor
F # 1) Vad finns i ett reguljärt uttryck?
Svar: TILL Vanligt uttryck vanligtvis kallad regex är ett mönster eller en sekvens av tecken (normala eller special- eller metatecken) som används för att validera en inmatningssträng.
F # 2) Vilken betydelse har Matcher-klassen för ett reguljärt uttryck i Java?
Svar: Matcherklassen (java.util.regex.Matcher) fungerar som en regex-motor. Den utför matchningsoperationerna genom att tolka mönstret.
F # 3) Vad är mönstret i Java?
Svar: Paketet java.util.regex ger en mönsterklass som används för att sammanställa en regex till ett mönster som är standardrepresentationen för regex. Detta mönster används sedan för att validera strängar genom att matcha det med mönstret.
F # 4) Vad är B i ett reguljärt uttryck?
Svar: B i regex betecknas som b och är ett ankartecken som används för att matcha en position som kallas ordgräns. Början på raden betecknas med en markör (^) och slutet på raden betecknas med ett dollartecken ($).
F # 5) Är mönstertrådssäker Java?
Svar: Ja. Exempel på mönsterklassen är oföränderliga och säkra för användning av flera samtidiga trådar. Men matchningsklassinstanserna är inte trådsäkra.
Slutsats
I denna handledning har vi diskuterat Regular Expressions i Java. Det reguljära uttrycket som även kallas ”regex” används för att validera inmatningssträngen i Java. Java tillhandahåller java.util.regex ' paket som innehåller klasser som Mönster, Matcher, etc. som hjälper till att definiera och matcha mönstret med inmatningssträngen.
Vi har också sett olika specialteckenklasser och metatecken som vi kan använda i regex som ger kortkoder för mönstermatchning. Vi undersökte också validering av e-post med regex.
=> Utforska The Simple Java Training Series här.
Rekommenderad läsning