Java regex
I denne øvelse vil vi diskutere, hvad der er et regulært Java-udtryk, og hvordan man bruger java-substring-regex til mønstermatchning ved hjælp af pattern.matcher sammen med forskellige eksempler. Vi vil også dække forskellige Java-regex-specialtegn, som vi bruger til java-mønstermatches.
Hvad er et regulært udtryk (Java regex)?
Et regulært udtryk er en teknik, som vi bruger til at søge efter bestemte mønstre i en streng. Det kan enten være et enkelt tegn eller en sekvens af tegn. Vi kan bruge java regex til at udføre enhver form for strengsøgning og -erstatningsoperation.
For at bruge det regulære java-udtryk kan vi importere java.util.regex-pakken.
java.util.regex-pakke
Java.util.regex-pakken indeholder 1 grænseflade og 3 klasser som angivet nedenfor:
- MatchResult-grænseflade
- Matcher-klasse
- Mønsterklasse
- Klasse PatternSyntaxException
Find
Mønsterklasse
Mønsterklassen bruges til at implementere det regulære java-udtryk. Den har en compile()-metode, der accepterer det regulære udtryk som et argument og returnerer et mønsterobjekt, som vi kan bruge til at udføre et mønstermatch.
Nedenfor er de almindeligt anvendte metoder i Pattern-klassen:
| Metode | Beskrivelse |
|---|---|
| Matcher matcher(CharSequence input) | Opretter en matcher, der matcher inputtet med det givne mønster |
| Strengmønster() | Returnerer et regulært udtryk, hvorfra mønsteret blev kompileret |
| String[] split(CharSequence input) | Opdeler inputsekvensen omkring mønstermatchet |
| Mønsterkompilering(strengregex) | Kompilerer det regulære udtryk som et mønster |
| boolean matches(String regex, CharSequence input, | Kompilerer det regulære udtryk og udfører et mønstermatch. |
Kompileringsmetoden har en option flag parameter, der angiver, hvordan man udfører et mønster java match:
- Mønster.CASE_INSENSITIVE:Ignorerer store og små bogstaver under mønstersøgningen
- Pattern.LITERAL:Behandler specialtegnene som almindelige tegn under mønstersøgningen
- Mønster.UNICODE_CASE:Bruges sammen med CASE_INSENSITIVE for at ignorere store og små bogstaver uden for de engelske alfabeter.
Matcher-klasse
Matcher-klassen implementerer MatchResult-grænsefladen og udfører mønstermatch på en sekvens af tegn. Vi kan oprette et Matcher-objekt ved hjælp af matcher-metoden på Pattern-objektet.
Nedenfor er de forskellige metoder, der er til stede i Matcher-klassen:
| Metode | Beskrivelse |
|---|---|
| int end() | Returnerer forskydningen af det sidste tegn, der matches |
| boolesk find() | Finder den næste efterfølger af inputtet, der matcher mønsteret |
| boolesk find(int start) | Nulstiller matcheren og finder den næste efterfølger af inputtet, der matcher mønsteret startende fra det angivne indeks |
| String group() | Returnerer den input-undersekvens, der matcher udtrykket |
| int groupCount() | Returnerer antallet af indfangende grupper i matcherens mønster |
| boolean matches() | Finder matchen mod mønsteret |
| Mønstermønster() | Returnerer mønsteret fortolket af matcheren |
| Matcher region(int start, int end) | Indstiller grænsen for området for at udføre mønstermatch |
| String replaceAll(String replacement) | Erstatter al den underfølge, der matcher mønsteret med den givne nye streng |
| Matcher nulstilling() | Nulstiller matcheren |
Regulære udtryksmønstre
Vi kan kontrollere for enten alfabetiske eller numeriske regulære udtryksmønstre i en inputstreng. Mønsterklassens kompileringsmetode accepterer dette regulære udtryk som den første parameter. De forskellige kombinationer af mønstre eller karakterklasser er nedenfor:
| Mønster | Beskrivelse |
|---|---|
| [abc] | Finder et tegn fra valgmulighederne i parentesen |
| [^abc] | Finder et tegn, der ikke er mellem valgmulighederne i parentesen |
| [0-9] | Finder et tegn i området 0-9 |
| [a-zA-Z] | Finder et tegn mellem a til z i begge tilfælde |
| [a-g[k-r]] | Finder et tegn mellem a til g og k til r (union) |
| [a-z&&[lmn]] | Finder et tegn mellem a til z, der har l,m,n - skæringspunkt |
| [a-z&&[^de]] | Finder et tegn mellem a og z undtagen d og e - subtraktion |
| [a-z&&[^h-k]] | Finder et tegn mellem a og z undtagen i området h og k |
Metategn
Vi kan også bruge metategn som en del af de regulære udtryksmønstre, som har en særlig betydning.
| Metategn | Beskrivelse |
|---|---|
| | | Finder et match til et hvilket som helst af mønstrene adskilt af | |
| . | Finder en enkelt forekomst af ethvert tegn |
| ^ | Finder et match i begyndelsen af strengen |
| $ | Finder et match i slutningen af strengen |
| \d | Finder et ciffer |
| \s | Finder et mellemrumstegn |
| \b | Finder et match i enten begyndelsen eller slutningen af ordet |
| \uxxxx | Finder et unicode-tegn specificeret af det hexadecimale tal xxxx |
| \D | Alle ikke-cifre, der svarer til [^0-9] |
| \S | Ethvert ikke-mellemrum, som svarer til [^\s] |
| \w | Ethvert ordtegn, der svarer til [a-zA-Z_0-9] |
| \W | Enhver ikke-ord-tegn, der svarer til [^\w] |
Kvantifikatoren
Vi kan bruge kvantifiers til at definere mængden eller antallet af forekomster af det angivne tegn i det regulære udtryksmønster.
| Quantifier | Beskrivelse |
|---|---|
| a+ | a forekommer en eller flere gange |
| a* | a forekommer nul eller flere gange |
| a? | a forekommer nul eller én gang |
| a{n} | a forekommer n gange |
| a{n,} | a forekommer n eller flere gange |
| a{m,n} | a forekommer mindst m gange, men mindre end n gange |
Eksempler på regulære udtryk i Java
Lad os nu se forskellige java regex-eksempler, der demonstrerer forskellige java-mønstre.
Eksempel:Find en streng
Nedenfor er et simpelt eksempel på at finde et java-mønster med strengen "java" i inputteksten. Den bruger java pattern.matcher-metoden til at tjekke efter det nødvendige mønster. Hvis mønsteret findes, returnerer det sandt, ellers returnerer det falsk.
import java.util.regex.*;
public class RegExDemo {
public static void main(String[] args) {
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("Welcome to Java tutorial");
boolean bfound = m.find();
if(bfound)
System.out.println("Pattern found");
else
System.out.println("Pattern not found");
}
}
Pattern found
Eksempel:Forskellige måder at skrive et regulært udtryk på
Der er forskellige måder at skrive regulære udtryksmønstre på i java. Den 1. metode bruger en kombination af Pattern og Matcher klasse med Pattern.matcher metoden og matches metoden i forskellige udsagn. Den anden metode bruger den samme kombination, men i en enkelt sætning, mens den tredje metode kun bruger Pattern.matches til at søge efter det regulære udtryksmønster.
I dette eksempel tjekker vi for mønsteret med det 2. tegn som 'a', og de resterende tegn kan være alle bogstaver.
import java.util.regex.*;
public class RegExDemo2 {
public static void main(String[] args) {
Pattern p = Pattern.compile(".a..");
Matcher m = p.matcher("java");
System.out.println(m.matches());
boolean b = Pattern.compile(".a..").matcher("java").matches();
System.out.println(b);
boolean bm = Pattern.matches(".a..", "java");
System.out.println(bm);
}
}
true true true
Eksempel:Regulært udtryksmønster ved hjælp af . (prik)
Eksemplet nedenfor viser forskellige demonstrationer af brugen af tegnet .(dot) til et regulært udtryk. Det 1. output er sandt, da det matcher input med 2. tegn som i. 2. output er falsk, da det ikke stemmer overens med det givne udtryk, da der ikke er noget 'i' i 2. tegn. Det 3. output er falsk, da der er mere end 3 tegn. De sidste 2 udsagn er sande, da det 1. tegn er "h", og det sidste tegn er "e", og det matcher også antallet af tegnlængder.
import java.util.regex.*;
public class RegExDemo3 {
public static void main(String[] args) {
System.out.println(Pattern.matches(".i", "hi"));
System.out.println(Pattern.matches(".i", "at"));
System.out.println(Pattern.matches(".a.", "java"));
System.out.println(Pattern.matches("h.", "hi"));
System.out.println(Pattern.matches("..e", "bye"));
}
}
true false false true true
Eksempel:Tegnklasse for regulært udtryk
I dette eksempel bruger vi tegnene som et regulært udtryksmønster. Hvis mønsteret er til stede i inputstrengen, returnerer det sandt, ellers returnerer det falsk.
import java.util.regex.*;
public class RegExDemo4 {
public static void main(String[] args) {
System.out.println(Pattern.matches("[abc]", "bag"));
System.out.println(Pattern.matches("[abc]", "a"));
System.out.println(Pattern.matches("[a-c][p-u]", "ar"));
System.out.println(Pattern.matches(".*come.*", "welcome"));
System.out.println(Pattern.matches("java", "Java"));
}
}
false true true true false
Eksempel:Kvantifier for regulære udtryk
I eksemplet nedenfor bruger vi forskellige kvantifiers som "?", der kontrollerer, om tegnet kun forekommer én gang, "+" kontrollerer, om tegnet forekommer mere end én gang, og "*" kontrollerer, om tegnet forekommer nul eller flere gange.
import java.util.regex.*;
public class RegExDemo5 {
public static void main(String[] args) {
System.out.println(Pattern.matches("[lmn]?", "l"));
System.out.println(Pattern.matches("[lmn]?", "hello"));
System.out.println(Pattern.matches("[lmn]+", "llmmn"));
System.out.println(Pattern.matches("[lmn]*", "java"));
System.out.println(Pattern.matches("[lmn]*", "lln"));
}
}
true false true false true
Eksempel:Find flere forekomster ved hjælp af matchermetoden
Eksemplet nedenfor illustrerer de mange forekomster af mønsteret i inputstrengen ved hjælp af Pattern.matcher-metoden. Den viser de steder, hvor tegnet 'a' forekommer i strengen.
import java.util.regex.*;
public class RegExDemo6 {
public static void main(String[] args) {
Pattern p = Pattern.compile("a");
Matcher m = p.matcher("Welcome to java tutorial");
while(m.find()) {
System.out.println("Occurs at: " + m.start() + " - " + m.end());
}
}
}
Occurs at: 12 - 13 Occurs at: 14 - 15 Occurs at: 22 - 23
Eksempel:Grænsematcher
Dette er et af de java-mønstereksempler, der tjekker for grænseoverensstemmelser. Dette er en type Java-regex-specialtegn i søgemønsteret. Det første output er sandt, da mønsteret matcher begyndelsen af strengen, mens det andet er falsk, da det ikke begynder med mønsteret.
import java.util.regex.*;
public class RegExDemo7 {
public static void main(String[] args) {
System.out.println(Pattern.matches("^Java$","Java"));
System.out.println(Pattern.matches("^Java$","Welcome to java"));
}
}
true false
Eksempel:Regulært udtryk med cifre
Dette eksempel bruger et talmønster i det regulære udtryk. Det tjekker for et match med ethvert ciffer, der følger efter ordet "Java". Derfor er det 1. 2 output sandt, da det indeholder et ciffer, mens det sidste output er falsk, da det ikke indeholder noget ciffer.
import java.util.regex.*;
public class RegExDemo7 {
public static void main(String[] args) {
String regex = "Java\\d";
System.out.println(Pattern.matches(regex, "Java5"));
System.out.println(Pattern.matches(regex, "Java8"));
System.out.println(Pattern.matches(regex, "JavaScript"));
}
}
true true false
Eksempel:Brug af logiske operatorer i regulært udtryksmønster
Vi kan også bruge logiske operatorer som AND, OR i mønstre. Som standard tager den hensyn til og AND-operator, når vi har mere end ét tegn i det regulære udtryksmønster. For eksempel i nedenstående kode er outputtet sandt, hvis de første 2 tegn er 'c' og 'h'. Derfor er det 1. 2 output sandt, og det sidste output er falsk.
import java.util.regex.*;
public class RegExDemo8 {
public static void main(String[] args) {
String regex = "[Cc][h].*";
String s = "cheque";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
System.out.println(m.matches());
s = "Chart";
m = p.matcher(s);
System.out.println(m.matches());
s = "color";
m = p.matcher(s);
System.out.println(m.matches());
}
}
true true false
Vi kan bruge OR-operatoren ved at bruge '|'-symbolet til at tjekke for de matchende mønstre. I dette eksempel er outputtet sandt, hvis inputstrengen indeholder enten teksten "Java" eller "JavaScript".
import java.util.regex.*;
public class RegExDemo8 {
public static void main(String[] args) {
String regex = ".*Java.*|.*JavaScript.*";
String s = "Welcome to Java tutorial";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
System.out.println(m.matches());
s = "JavaScript tutorial";
m = p.matcher(s);
System.out.println(m.matches());
s = "C tutorial";
m = p.matcher(s);
System.out.println(m.matches());
}
}
true true false
Ovenstående to eksempler illustrerer også brugen af java understreng regex i mønstersøgning, da vi tjekker for en understreng i inputstrengen.
Konklusion
I dette selvstudium har vi lært Java regulært udtryksmønstermatchning ved hjælp af Pattern.matcher og andre metoder med eksempler sammen med, hvordan man bruger Java regex specialtegn og java substring regex i mønstersøgning.
