Java valodā Regular Expressions vai Regex (īsumā) Java ir API virkņu modeļu definēšanai, ko var izmantot, lai meklētu, manipulētu ar virkni un rediģētu Java. E-pasta validācija un paroles ir dažas virkņu jomas, kurās ierobežojumu definēšanai plaši izmanto Regex. Java regulārās izteiksmes tiek nodrošinātas sadaļā java.util.regex iepakojums. Tas sastāv no 3 klases un 1 interfeiss . The java.util.regex pakotne galvenokārt sastāv no šādām trim klasēm, kā parādīts tālāk tabulas formātā:
Regex klases un saskarnes
Regex Java nodrošina 3 klases un 1 interfeisu, kas ir šādi:
- Rakstu klase
- Saderības klase
- Pattern SyntaxException klase
- MatchResult interfeiss
Plašāku izpratni var interpretēt tālāk sniegtajā attēlā šādi:
| Jā nē. | Klase/interfeiss | Apraksts |
|---|---|---|
| 1. | Rakstu klase | Izmanto modeļu noteikšanai |
| 2. | Saderības klase | Izmanto teksta atbilstības operāciju veikšanai, izmantojot modeļus |
| 3. | PatternSyntaxException Class | Izmanto, lai norādītu sintakses kļūdu regulārās izteiksmes shēmā |
| 4. | MatchResult interfeiss | Izmanto, lai attēlotu spēles darbības rezultātu |
Rakstu klase
Šī klase ir regulāru izteiksmju apkopojums, ko var izmantot, lai definētu dažāda veida modeļus, nenodrošinot publiskos konstruktorus. To var izveidot, izsaucot kompile() metodi, kas pieņem regulāro izteiksmi kā pirmo argumentu, tādējādi atgriežot modeli pēc izpildes.
| Jā nē. | Metode | Apraksts |
|---|---|---|
| 1. | kompilēt (virknes regex) | To izmanto, lai apkopotu doto regulāro izteiksmi paraugā. |
| 2. | kompilēt (virknes regulārais izteiksme, int karodziņi) | To izmanto, lai apkopotu doto regulāro izteiksmi paraugā ar dotajiem karodziņiem. |
| 3. | karodziņi () | To izmanto, lai atgrieztu šī modeļa atbilstības karogus. |
| 4. | matcher (CharSequence ievade) | To izmanto, lai izveidotu saskaņotāju, kas saskaņos doto ievadi ar šo modeli. |
| 5. | atbilst (virknes regex, CharSequence ievade) | To izmanto, lai apkopotu doto regulāro izteiksmi un mēģinātu saskaņot doto ievadi ar to. |
| 6. | modelis () | To izmanto, lai atgrieztu regulāro izteiksmi, no kuras tika apkopots šis modelis. |
| 7. | citāts (virkne) | To izmanto, lai norādītajai virknei atgrieztu burtisku paraugu String. |
| 8. | sadalīt (CharSequence ievade) | To izmanto, lai sadalītu doto ievades secību ap šī modeļa atbilstībām. |
| 9. | sadalīt (CharSequence ievade, ieejas ierobežojums) | To izmanto, lai sadalītu doto ievades secību ap šī modeļa atbilstībām. Ierobežojuma parametrs nosaka, cik reižu modelis tiek lietots. |
| 10. | toString() | To izmanto, lai atgrieztu šī modeļa virknes attēlojumu. |
Piemērs: Rakstu klase
Java
// Java Program Demonstrating Working of matches() Method> // Pattern class> // Importing Pattern class from java.util.regex package> import> java.util.regex.Pattern;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Following line prints 'true' because the whole> >// text 'geeksforgeeks' matches pattern> >// 'geeksforge*ks'> >System.out.println(Pattern.matches(> >'geeksforge*ks'>,>'geeksforgeeks'>));> >// Following line prints 'false' because the whole> >// text 'geeksfor' doesn't match pattern 'g*geeks*'> >System.out.println(> >Pattern.matches(>'g*geeks*'>,>'geeksfor'>));> >}> }> |
>
>Izvade
true false>
Saderības klase
Šis objekts tiek izmantots, lai Java ievades virknei veiktu atbilstības darbības, tādējādi interpretējot iepriekš izskaidrotos modeļus. Tas arī nedefinē publiskos konstruktorus. To var īstenot, izsaucot matcher () jebkurā modeļa objektā.
| Jā nē. | Metode | Apraksts |
|---|---|---|
| 1. | atrast () | To galvenokārt izmanto, lai meklētu vairākus regulāro izteiksmju gadījumus tekstā. |
| 2. | atrast (sākumā) | To izmanto, lai meklētu regulāro izteiksmju sastopamības tekstā, sākot no dotā indeksa. |
| 3. | sākt() | To izmanto, lai iegūtu atbilstības sākuma indeksu, kas tiek atrasts, izmantojot metodi find (). |
| 4. | beigas () | To izmanto, lai iegūtu atbilstības beigu indeksu, kas tiek atrasts, izmantojot Find() metodi. Tas atgriež rakstzīmes indeksu blakus pēdējai atbilstošajai rakstzīmei. |
| 5. | grupu skaits() | To izmanto, lai atrastu atbilstošās apakšsecības kopējo skaitu. |
| 6. | grupa () | To izmanto, lai atrastu atbilstošo apakšsecību. |
| 7. | atbilst() | To izmanto, lai pārbaudītu, vai regulārā izteiksme atbilst modelim. |
Piezīme: T Pattern.matches() pārbauda, vai viss teksts atbilst rakstam vai nē. Citas metodes (parādītas tālāk) galvenokārt tiek izmantotas, lai tekstā atrastu vairākus modeļus.
Apspriedīsim dažus programmu paraugus, kā to darījām paraugu klasē. Šeit mēs apspriedīsim dažas Java programmas, kas demonstrē kompile (), find (), start (), end () un split () darbību, lai iegūtu labāku izpratni par Matcher klasi.
1. piemērs: Rakstu meklēšana
Java
// Java program to demonstrate working of> // String matching in Java> // Importing Matcher and Pattern class> import> java.util.regex.Matcher;> import> java.util.regex.Pattern;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Create a pattern to be searched> >// Custom pattern> >Pattern pattern = Pattern.compile(>'geeks'>);> >// Search above pattern in 'techcodeview.com> | Apraksts |
|---|---|
| [xyz] | x, y vai z |
| [^xyz] | Visas rakstzīmes, izņemot x, y vai z |
| [a-zA-Z] | rakstzīmes diapazonā no a līdz z vai no A līdz Z. |
| [a-f[m-t]] | Savienojums no a līdz f un no m līdz t. |
| [a-z && p-y] | Visi elementu diapazoni krustojas starp diviem diapazoniem |
| [a-z && [^bc]] | a līdz z savienība ar izņemot b un c |
| [a-z && [^m-p]] | no a līdz z savienība ar izņemot diapazonu no m līdz p |
Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:
Java
// Java Program to check on Regex> import> java.io.*;> import> java.util.regex.*;> // Driver class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Checks if the string matches with the regex> >// Should be single character a to z> >System.out.println(Pattern.matches(>'[a-z]'>,>'g'>));> >// Check if the element is range a to z or A to Z> >System.out.println(> >Pattern.matches(>'[a-zA-Z]'>,>'Gfg'>));> >}> }> |
>
>Izvade
true false>
Regex metarakstzīmes
| Regex | Apraksts |
|---|---|
| X? | X parādās vienu reizi vai nē |
| X+ | X parādās vienu vai vairākas reizes |
| X* | X parādās nulle vai ne reizi |
| X{n} | X parādās n reizes |
| X{n,} cik liels ir mans datora ekrāns | X parādās n reizes vai vairāk nekā n |
| X{n,m} | X šķiet lielāks par n reizēm un mazāks par m reizi. |
Tālāk ir parādīta Regex metarakstu ieviešana:
Java
// Java Program to check on regex> import> java.io.*;> import> java.util.regex.*;> // Driver class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Checking all the strings using regex> >System.out.println(Pattern.matches(>'[b-z]?'>,>'a'>));> >// Check if all the elements are in range a to z> >// or A to Z> >System.out.println(> >Pattern.matches(>'[a-zA-Z]+'>,>'GfgTestCase'>));> >// Check if elements is not in range a to z> >System.out.println(Pattern.matches(>'[^a-z]?'>,>'g'>));> >// Check if all the elements are either g,e,k or s> >System.out.println(> >Pattern.matches(>'[geks]*'>,>'geeksgeeks'>));> >}> }> |
>
>Izvade
false true false true>
Java Regex Finder piemērs
| Regex | Apraksts |
|---|---|
| . | Jebkurš varonis |
| d | Jebkuri cipari, [0-9] |
| D | Jebkurš bez cipara, [^0-9] |
| s | Atstarpes rakstzīme, [ x0Bf ] |
| S | Rakstzīme, kas nav atstarpes, [^s] |
| In | Vārda rakstzīme, [a-zA-Z_0-9] |
| IN | Rakstzīme, kas nav vārds, [^w] |
|
| Vārdu robeža |
| B | Ne-vārdu robeža |
Tālāk ir sniegta Java Regex Finder ieviešana:
Java
// Java Program to implement regex> import> java.io.*;> import> java.util.regex.*;> // Driver Class> class> GFG {> >// Main Function> >public> static> void> main(String[] args)> >{> >// Check if all elements are numbers> >System.out.println(Pattern.matches(>'d+'>,>'1234'>));> >// Check if all elements are non-numbers> >System.out.println(Pattern.matches(>'D+'>,>'1234'>));> >// Check if all the elements are non-numbers> >System.out.println(Pattern.matches(>'D+'>,>'Gfg'>));> >// Check if all the elements are non-spaces> >System.out.println(Pattern.matches(>'S+'>,>'gfg'>));> >}> }> |
>
>Izvade
true false true true>
Secinājums
Visbeidzot, apspriedīsim dažus svarīgus novērojumus, kas iegūti no iepriekš minētā raksta
- Veidojam modeļa objektu, izsaucot Pattern.compile(), konstruktora nav. compile () ir statiska metode klasē Pattern.
- Tāpat kā iepriekš, mēs izveidojam Matcher objektu, izmantojot matcher () klases Pattern objektiem.
- Pattern.matches() ir arī statiska metode, ko izmanto, lai pārbaudītu, vai dotais teksts kopumā atbilst modelim.
- find() tiek izmantots, lai tekstā atrastu vairākus modeļus.
- Mēs varam sadalīt tekstu, pamatojoties uz norobežotāja modeli, izmantojot split() metodi
Bieži uzdotie jautājumi programmā Java Regex
Q1. Kas ir regulārās izteiksmes Java?
Gadi:
Java regulārās izteiksmes tiek izmantotas virkņu modeļiem, kurus var izmantot, lai meklētu, manipulētu ar virkni un rediģētu Java.
Q2. Kāds ir vienkāršs regulārās izteiksmes piemērs Java?
Gadi:
Vienkāršs java regulāras izteiksmes piemērs ir minēts zemāk:
Java
// Java Program to check on Regex>import>java.io.*;>import>java.util.regex.*;>// Driver class>class>GFG {>>// Main function>>public>static>void>main(String[] args)>>{>>// Checks if the string matches with the regex>>// Should be single character a to z>>System.out.println(Pattern.matches(>'[a-z]'>,>'g'>));>>// Check if all the elements are non-numbers>>System.out.println(Pattern.matches(>'D+'>,>'Gfg'>));>>// Check if all the elements are non-spaces>>System.out.println(Pattern.matches(>'S+'>,>'gfg'>));>>}>}>atlases kārtošana java>>Izvadetrue true true>