
Apa ekspresi reguler (regex)?
Nyatane, ekspresi reguler minangka pola kanggo nemokake senar ing teks. Ing Jawa, representasi asli saka pola iki tansah string, yaiku obyek saka kelasString
. Nanging, dudu senar sing bisa dikompilasi dadi ekspresi reguler - mung senar sing cocog karo aturan kanggo nggawe ekspresi reguler. Sintaksis ditetepake ing spesifikasi basa. Ekspresi reguler ditulis nggunakake aksara lan angka, uga metakarakter, yaiku karakter sing nduweni makna khusus ing sintaksis ekspresi reguler. Tuladhane:
String regex = "java"; // The pattern is "java";
String regex = "\\d{3}"; // The pattern is three digits;
Nggawe ekspresi reguler ing basa Jawa
Nggawe ekspresi reguler ing Jawa kalebu rong langkah prasaja:- tulis minangka senar sing tundhuk karo sintaks ekspresi reguler;
- ngumpulake senar menyang ekspresi biasa;
Pattern
obyek. Kanggo nindakake iki, kita kudu nelpon salah siji saka rong cara statis kelas: compile
. Cara pisanan njupuk siji argumen - string literal sing ngemot ekspresi reguler, dene sing kapindho njupuk argumen tambahan sing nemtokake setelan sing cocog karo pola:
public static Pattern compile (String literal)
public static Pattern compile (String literal, int flags)
Dhaptar nilai potensial parameter flags
ditetepake ing Pattern
kelas lan kasedhiya kanggo kita minangka variabel kelas statis. Tuladhane:
Pattern pattern = Pattern.compile("java", Pattern.CASE_INSENSITIVE); // Pattern-matching will be case insensitive.
Sejatine, Pattern
kelas minangka konstruktor kanggo ekspresi reguler. Ing hood, compile
cara nelpon Pattern
konstruktor pribadi kelas kanggo nggawe perwakilan nyawiji. Mekanisme nggawe obyek iki ditindakake kanthi cara iki kanggo nggawe obyek sing ora bisa diganti. Nalika ekspresi reguler digawe, sintaks kasebut dicenthang. Yen senar ngemot kesalahan, banjur a PatternSyntaxException
digawe.
Sintaks ekspresi reguler
Sintaks ekspresi reguler gumantung marang<([{\^-=$!|]})?*+.>
karakter, sing bisa digabung karo huruf. Gumantung ing peran, bisa dipérang dadi sawetara klompok:
Metakarakter | Katrangan |
---|---|
^ | wiwitan baris |
$ | mburi baris |
\b | wates tembung |
\B | wates non-tembung |
\A | wiwitan input |
\G | pungkasan pertandhingan sadurunge |
\Z | pungkasan input |
\z | pungkasan input |
Metakarakter | Katrangan |
---|---|
\d | digit |
\D | non-digit |
\s | karakter spasi putih |
\S | karakter non-whitespace |
\w | karakter alfanumerik utawa garis ngisor |
\W | karakter apa wae kajaba huruf, angka, lan garis ngisor |
. | karakter apa wae |
Metakarakter | Katrangan |
---|---|
\t | karakter tab |
\n | karakter baris anyar |
\r | gerbong bali |
\f | karakter linefeed |
\u0085 | karakter baris sabanjuré |
\u2028 | pemisah baris |
\u2029 | pemisah paragraf |
Metakarakter | Katrangan |
---|---|
[abc] | sembarang karakter sing kadhaptar (a, b, utawa c) |
[^abc] | karakter apa wae kajaba sing kadhaptar (dudu a, b, utawa c) |
[a-zA-Z] | kisaran gabungan (karakter Latin saka a nganti z, ora sensitif huruf cilik) |
[iklan [mp]] | kesatuan karakter (saka a nganti d lan saka m nganti p) |
[az&&[def]] | persimpangan karakter (d, e, f) |
[az&&[^bc]] | pengurangan aksara (a, dz) |
Metakarakter | Katrangan |
---|---|
? | siji utawa ora ana |
* | nul utawa luwih kaping |
+ | siji utawa luwih |
{n} | n kaping |
{n,} | n utawa kaping liyane |
{n,m} | paling n kaping lan ora luwih saka m kaping |
Pengukuran rakus
Siji bab sampeyan kudu ngerti babagan quantifiers iku padha teka ing telung varieties beda: rakus, possessive, lan wegah. Sampeyan nggawe quantifier possessive kanthi nambahake+
karakter " " sawise quantifier. Sampeyan nggawe wegah kanthi nambahake " ?
". Tuladhane:
"A.+a" // greedy
"A.++a" // possessive
"A.+?a" // reluctant
Coba gunakake pola iki kanggo ngerti cara kerjane macem-macem jinis pengukur. Kanthi gawan, quantifiers rakus. Iki tegese padha golek match paling dawa ing senar. Yen kita mbukak kode ing ngisor iki:
public static void main(String[] args) {
String text = "Fred Anna Alexander";
Pattern pattern = Pattern.compile("A.+a");
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
System.out.println(text.substring(matcher.start(), matcher.end()));
}
}
kita entuk output iki:
Anna Alexa
Kanggo ekspresi reguler " A.+a
", pencocokan pola ditindakake kaya ing ngisor iki:
-
Karakter pisanan ing pola kasebut yaiku aksara Latin
A
.Matcher
mbandhingake karo saben karakter teks, wiwit saka indeks nul. Karakter kasebutF
ana ing indeks nol ing teks kita, mulaMatcher
ngulang karakter nganti cocog karo pola kasebut. Ing conto kita, karakter iki ditemokake ing indeks 5. -
Yen cocog karo karakter pisanan pola ditemokake,
Matcher
goleki sing cocog karo karakter kapindho. Ing kasus kita, iku.
karakter " ", sing tegese karakter apa wae.Karakter kasebut
n
ana ing posisi kaping enem. Iku mesthi cocog minangka match kanggo "karakter apa wae". -
Matcher
nerusake mriksa karakter pola sabanjure. Ing pola kita, kalebu ing quantifier sing ditrapake kanggo karakter sadurunge: ".+
". Amarga jumlah repetisi "karakter apa wae" ing pola kita kaping siji utawa luwih,Matcher
bola-bali njupuk karakter sabanjure saka senar lan mriksa pola kasebut sajrone cocog karo "karakter apa wae". Ing conto kita - nganti pungkasan senar (saka indeks 7 kanggo indeks 18).Sejatine,
Matcher
gobbles munggah senar kanggo mburi - iki sabenere apa tegese "rakus". -
Sawise Matcher tekan pungkasan teks lan rampung mriksa "
A.+
" bagean saka pola, iku wiwit mriksa kanggo liyane saka pola:a
. Ora ana teks maneh sing bakal maju, mula priksa diterusake kanthi "mundur", diwiwiti saka karakter pungkasan: -
Matcher
"ngelingi" jumlah repetisi ing.+
bagean " " pola kasebut. Ing titik iki, ngurangi jumlah repetisi siji lan mriksa pola sing luwih gedhe marang teks nganti cocog ditemokake:
Kuantifier posesif
Possessive quantifiers akeh kaya rakus. Bentenipun punika nalika teks wis dijupuk kanggo mburi senar, ora ana pola-cocog nalika "mundur". Ing tembung liya, telung tahap pisanan padha karo pengukur sing rakus. Sawise njupuk kabeh senar, matcher nambahake pola liyane kanggo apa sing dianggep lan mbandhingake karo senar sing dijupuk. Ing conto kita, nggunakake ekspresi reguler "A.++a
", cara utama ora nemokake sing cocog. 
Quantifiers wegah
-
Kanggo pengukur iki, kaya karo macem-macem rakus, kode kasebut nggoleki sing cocog adhedhasar karakter pisanan saka pola kasebut:
-
Banjur nggoleki sing cocog karo karakter sabanjure pola (karakter apa wae):
-
Beda karo pencocokan pola sing rakus, sing cocog paling cendhak digoleki ing pencocokan pola sing wegah. Iki tegese sawise nemokake sing cocog karo karakter kaloro pola kasebut (periode, sing cocog karo karakter ing posisi 6 ing teks,
Matcher
mriksa manawa teks kasebut cocog karo pola liyane - karakter "a
" -
Teks kasebut ora cocog karo pola (yaiku ngemot karakter "
n
" ing indeks 7), mulaMatcher
nambah "karakter apa wae", amarga pangukuran nuduhake siji utawa luwih. Banjur maneh mbandhingake pola karo teks ing posisi 5 nganti 8:
Ing kasus kita, sing cocog ditemokake, nanging kita durung tekan pungkasan teks. Mulane, pencocokan pola diwiwiti maneh saka posisi 9, yaiku karakter pisanan pola digoleki nggunakake algoritma sing padha lan iki bola-bali nganti pungkasan teks.

main
cara kasebut entuk asil ing ngisor iki nalika nggunakake pola " A.+?a
": Anna Alexa Minangka sampeyan bisa ndeleng saka conto kita, macem-macem jinis quantifier ngasilake asil sing beda kanggo pola sing padha. Dadi elinga iki lan pilih macem-macem sing cocog adhedhasar apa sing sampeyan goleki.
Uwal karakter ing ekspresi biasa
Amarga ekspresi reguler ing Jawa, utawa luwih, perwakilan asline, minangka literal string, kita kudu nganggep aturan Jawa babagan literal string. Utamane, karakter backslash "\
" ing string literals ing kode sumber Jawa diinterpretasikake minangka karakter kontrol sing ngandhani kompiler yen karakter sabanjure iku khusus lan kudu diinterpretasikake kanthi cara khusus. Tuladhane:
String s = "The root directory is \nWindows"; // Move "Windows" to a new line
String s = "The root directory is \u00A7Windows"; // Insert a paragraph symbol before "Windows"
Iki tegese string literals sing njlèntrèhaké ekspresi reguler lan nggunakake " \
" karakter (yaiku kanggo nunjukaké metacharacters) kudu mbaleni garis miring mburi kanggo mesthekake yen kompiler bytecode Jawa ora misinterpreted string. Tuladhane:
String regex = "\\s"; // Pattern for matching a whitespace character
String regex = "\"Windows\""; // Pattern for matching "Windows"
Garis miring pindho uga kudu digunakake kanggo uwal saka karakter khusus sing pengin digunakake minangka karakter "normal". Tuladhane:
String regex = "How\\?"; // Pattern for matching "How?"
Metode saka kelas Pola
Kelas kasebutPattern
duwe cara liya kanggo nggarap ekspresi reguler:
-
String pattern()
‒ ngasilake representasi string asli ekspresi reguler sing digunakake kanggo nggawePattern
obyek:Pattern pattern = Pattern.compile("abc"); System.out.println(pattern.pattern()); // "abc"
-
static boolean matches(String regex, CharSequence input)
– ngijini sampeyan mriksa ekspresi reguler liwati minangka regex marang teks liwati minangkainput
. bali:bener - yen teks cocog karo pola;
palsu - yen ora;Tuladhane:
System.out.println(Pattern.matches("A.+a","Anna")); // true System.out.println(Pattern.matches("A.+a","Fred Anna Alexander")); // false
-
int flags()
‒ ngasilake nilaiflags
set parameter pola nalika pola digawe utawa 0 yen parameter ora disetel. Tuladhane:Pattern pattern = Pattern.compile("abc"); System.out.println(pattern.flags()); // 0 Pattern pattern = Pattern.compile("abc",Pattern.CASE_INSENSITIVE); System.out.println(pattern.flags()); // 2
-
String[] split(CharSequence text, int limit)
– pamisah teks liwati menyangString
larik. Parameter kasebutlimit
nuduhake jumlah maksimum sing cocog sing digoleki ing teks:- yen
limit > 0
‒limit-1
cocog; - yen
limit < 0
‒ kabeh cocog ing teks - yen
limit = 0
‒ kabeh cocog ing teks, string kosong ing mburi larik bakal dibuwak;
Tuladhane:
public static void main(String[] args) { String text = "Fred Anna Alexa"; Pattern pattern = Pattern.compile("\\s"); String[] strings = pattern.split(text,2); for (String s : strings) { System.out.println(s); } System.out.println("---------"); String[] strings1 = pattern.split(text); for (String s : strings1) { System.out.println(s); } }
Output konsol:
Fred Anna Alexa --------- Fred Anna Alexa
Ing ngisor iki kita bakal nimbang cara kelas liyane sing digunakake kanggo nggawe
Matcher
obyek. - yen
Metode saka kelas Matcher
Instance sakaMatcher
kelas digawe kanggo nindakake pola-matching. Matcher
yaiku "mesin telusur" kanggo ekspresi reguler. Kanggo nindakake panelusuran, kita kudu menehi rong perkara: pola lan indeks wiwitan. Kanggo nggawe Matcher
obyek, Pattern
kelas menehi cara ing ngisor iki: рublic Matcher matcher(CharSequence input)
Cara njupuk urutan karakter, sing bakal digoleki. Iki minangka conto saka kelas sing ngetrapake antarmuka CharSequence
. Sampeyan bisa ngliwati ora mung a String
, nanging uga a StringBuffer
, StringBuilder
, Segment
, utawa CharBuffer
. Pola yaiku Pattern
obyek sing matcher
diarani metode. Tuladha nggawe matcher:
Pattern p = Pattern.compile("a*b"); // Create a compiled representation of the regular expression
Matcher m = p.matcher("aaaaab"); // Create a "search engine" to search the text "aaaaab" for the pattern "a*b"
Saiki kita bisa nggunakake "mesin telusur" kanggo nggoleki sing cocog, entuk posisi sing cocog ing teks, lan ngganti teks nggunakake metode kelas. Cara kasebut boolean find()
nggoleki pertandhingan sabanjure ing teks. Kita bisa nggunakake metode iki lan statement loop kanggo nganalisa kabeh teks minangka bagéan saka model acara. Ing tembung liyane, kita bisa nindakake operasi perlu nalika ana acara, IE nalika kita nemokake match ing teks. Contone, kita bisa nggunakake kelas iki int start()
lan int end()
cara kanggo nemtokake posisi match ing teks. Lan kita bisa nggunakake String replaceFirst(String replacement)
lan String replaceAll(String replacement)
cara kanggo ngganti cocog karo Nilai saka parameter panggantos. Tuladhane:
public static void main(String[] args) {
String text = "Fred Anna Alexa";
Pattern pattern = Pattern.compile("A.+?a");
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
int start=matcher.start();
int end=matcher.end();
System.out.println("Match found: " + text.substring(start, end) + " from index "+ start + " through " + (end-1));
}
System.out.println(matcher.replaceFirst("Ira"));
System.out.println(matcher.replaceAll("Mary"));
System.out.println(text);
}
Output:
Match found: Anna from index 5 through 8
Match found: Alexa from index 10 through 14
Fred Ira Alexa
Fred Mary Mary
Fred Anna Alexa
Conto nerangake manawa metode replaceFirst
lan replaceAll
nggawe String
obyek anyar - senar sing cocog karo pola ing teks asli diganti karo teks sing diterusake menyang metode kasebut minangka argumen. Kajaba iku, replaceFirst
cara mung ngganti pertandhingan pisanan, nanging replaceAll
cara kasebut ngganti kabeh pertandhingan ing teks. Teks asli tetep ora owah. Operasi regex sing paling kerep Pattern
lan Matcher
kelas dibangun langsung ing String
kelas kasebut. Iki minangka cara kayata split
, matches
, replaceFirst
, lan replaceAll
. Nanging ing hood, cara iki nggunakake Pattern
lan Matcher
kelas. Dadi, yen sampeyan pengin ngganti teks utawa mbandhingake senar ing program tanpa nulis kode tambahan, gunakake metodeString
kelas. Yen sampeyan butuh fitur sing luwih maju, elinga Pattern
lan Matcher
kelas.
Kesimpulan
Ing program Jawa, ekspresi reguler ditetepake kanthi senar sing manut aturan sing cocog karo pola tartamtu. Nalika nglakokake kode, mesin Java nglumpukake senar iki dadiPattern
obyek lan nggunakake Matcher
obyek kanggo nemokake sing cocog ing teks kasebut. Kaya sing dakkandhakake ing wiwitan, wong asring nolak ekspresi reguler kanggo mengko, nganggep minangka topik sing angel. Nanging yen sampeyan ngerti sintaks dhasar, metakarakter, lan karakter sing lolos, lan nyinaoni conto ekspresi reguler, mula sampeyan bakal nemokake luwih gampang tinimbang sing katon sepisanan.
Wacan liyane: |
---|
GO TO FULL VERSION