Extrakcia alebo validácia dát je dôležitým aspektom každého programovacieho jazyka. Jedným z najpopulárnejších spôsobov overovania údajov je používanie regulárnych výrazov. používa tietoregulárne výrazy popisujúce vzor znakov. Tento článok o Java Regex vypíše rôzne spôsoby použitia výrazov v nasledujúcom poradí:
- Čo sú regulárne výrazy?
- Čo je Java Regex?
- Trieda zápasníkov
- Trieda vzoru
- Trieda znakov regulárneho výrazu
- Regex kvantifikátory
- Regulárne metaznaky
Začnime!
Čo sú regulárne výrazy?
TO Regulárny výraz je postupnosť znakov, ktorá vytvára vyhľadávací vzor. Pri hľadaní údajov v texte môžete pomocou tohto vyhľadávacieho vzoru popísať, čo hľadáte.
Regulárny výraz môže byť a jeden znak alebo zložitejší vzor. Môže sa použiť na akýkoľvek typ operácií hľadania a nahradenia textu. Regexový vzor sa skladá z jednoduchých znakov, ako napr / abc / , alebo kombinácia jednoduchých a špeciálnych znakov, ako napr / ab * c / alebo /example(d+).d*/ .
Čo je Java Regex?
The Java Regex je API, na ktoré je zvyknuté definovať vzor pre vyhľadávanie alebo manipuláciu . Často sa používa na definovanie obmedzení pre reťazce, ako je napríklad overenie hesla a e-mailu.
Existujú rôzne spôsoby použitia Java Regex. Poďme teda ďalej a pozrime sa na rôzne výrazy.
Trieda zápasníkov
Táto trieda sa používa na vykonávanie operácií zhody v postupnosti znakov. Nasledujúca tabuľka predstavuje rôzne metódy triedy Matcher.
| Metóda | Popis |
|---|---|
| booleovské zápasy () | Testuje, či sa daný regulárny výraz zhoduje so vzorom |
| booleovský nález () | Slúži na nájdenie ďalšieho výrazu, ktorý sa zhoduje so vzorom |
| boolean find (int start) | Vyhľadá ďalší výraz, ktorý sa zhoduje so vzorom z daného počiatočného čísla |
| Skupina reťazcov () | Používa sa na vrátenie zhodnej subsekvencie |
| int start () | Vráti počiatočný index zhodnej subsekvencie |
| int end () | Vráti koncový index zhodnej subsekvencie |
| int groupCount () | Vráti celkový počet zhodných podsekvencií |
Trieda vzoru
Pattern Class je kompilovaná verzia regulárneho výrazu, ktorá sa používa na definovanie vzoru pre regulárny výraz.
| Metóda | Popis |
|---|---|
| statická kompilácia vzoru (reťazcový regulárny výraz) | Zostaví daný regulárny výraz a vráti inštanciu vzoru |
| Zhoduje sa so zhodami (vstup CharSequence) | Používa sa na vytvorenie porovnávača, ktorý zodpovedá danému vstupu so vzorom |
| statické booleovské zhody (reťazcový regulárny výraz, vstup CharSequence) | Funguje to ako kombinácia kompilácie a porovnávacích metód. Zostavuje regulárny výraz a porovnáva daný vstup so vzorom |
| Rozdelenie reťazca [] (vstup CharSequence) | Používa sa na rozdelenie daného vstupu. Reťazec okolo zhôd daného vzoru |
| Reťazcový vzor () | Pomáha vrátiť vzor regulárneho výrazu |
Teraz si vezmime malý príklad na pochopenie toho, ako písať regulárny výraz.
import java.util.regex. * verejná trieda RegexExample {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('Reťazec sa zhoduje s daným Regexom - + matcher.matches ())}}V tomto prípade interne používa Pattern a Matcher regex triedy, aby vykonali spracovanie, ale samozrejme,zmenšuje riadky kódu. Trieda vzoru obsahuje aj metódu zhody, ktorá berie regex a vstupný reťazec ako argument a vráti logický výsledok po ich priradení. Takže kód funguje dobre na priradenie vstupu s regulárnym výrazom v jazyku Java. Preto bude výstup pravdivý, ako je uvedené nižšie.
Výkon:
pravda
Teraz sa pozrieme na niekoľko ďalších kategórií regulárnych výrazov Java.
program plánovania každý s každým v c
Trieda znakov regulárneho výrazu
Nasledujúca tabuľka predstavuje kombináciu rôznych tried znakov.
| Trieda znakov | Popis |
|---|---|
| [abc] | a, b alebo c (jednoduchá trieda) |
| [^ abc] | Ľubovoľný znak okrem a, b alebo c (negácia) |
| [a-zA-Z] | a až z alebo A až Z vrátane (rozsah) |
| [a-d [m-p]] | a až d alebo m až p: [a-dm-p] (spojenie) |
| [a-z && [def]] | d, e alebo f (križovatka) |
| [a-z && [^ bc]] | a až z, s výnimkou bac: [ad-z] (odčítanie) |
| [a-z && [^ m-p]] | a až z, a nie m až p: [a-lq-z] (odčítanie) |
Príklad:
import java.util.regex. * verejná trieda CharacterExample {public static void main (String args []) {// false (nie x alebo y alebo z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (medzi x alebo y alebo z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (x a y prichádzajú viackrát) Systém .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}Regex kvantifikátory
Kvantifikátory určujú počet výskytov znaku. Nasledujúca tabuľka predstavuje rôzne kvantifikátory.
| Regulárny výraz | Popis |
|---|---|
| X? | X sa vyskytuje raz alebo vôbec |
| X + | X sa vyskytuje raz alebo viackrát |
| X * | X sa vyskytuje nula alebo viackrát |
| X {n} | X sa vyskytuje iba n-krát |
| X {n,} | X sa vyskytuje n alebo viackrát |
| X a Z} | X sa vyskytuje najmenej y-krát, ale menej ako z-krát |
Príklad:
import java.util.regex. * verejná trieda Príklad {public static void main (String args []) {System.out.println ('? kvantifikátor ....') // (a alebo y alebo z prídu raz) System.out.println (Pattern.matches ('[ayz]?', 'A')) // výstup: pravý System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay a z prichádza viac ako raz) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // output: false // (a prichádza viac ako raz) Systém. out.println (Pattern.matches ('[ayz]?', 'amnta')) // výstup: false // (a alebo y alebo z musia prísť raz) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // výstup: false System.out.println (' + kvantifikátor .... ') // (a alebo y alebo z raz alebo viackrát) System.out.println (vzor .matches ('[ayz] +', 'a')) // výstup: true // (a prichádza viac ako raz) System.out.println (Pattern.matches ('[ayz] +', 'aaa') )) // outpu: true // (a alebo y alebo z prichádzajú viackrát) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // výstup: true // (z a t sa nezhodujú so vzorom) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // výstup: false System.out.println ('* kvantifikátor ....') // (a alebo y alebo z môžu prísť nula alebo viackrát ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // výstup: true}}V zásade bude hľadať vyhovujúci kvantifikátor a bude zodpovedať výsledku vyhľadávania.
Regulárne metaznaky
Metaznaky regulárneho výrazu fungujú ako krátke kódy. Pozrime sa na nasledujúcu tabuľku, aby sme pochopili rôzne typy metaznakov.
| Regulárny výraz | Popis |
|---|---|
| . | Môže to byť akýkoľvek znak (môže, ale nemusí sa zhodovať s terminátorom) |
| d | Predstavuje akékoľvek číslice, krátke ako [0-9] |
| D | Predstavuje akúkoľvek číslicu, skratku pre [^ 0-9] |
| s | Predstavuje akýkoľvek prázdny znak, skratka pre [tnx0Bfr] |
| S | Môže to byť znak bez medzier, skratka pre [^ s] |
| v | Môže to byť slovný znak, skratka pre [a-zA-Z_0-9] |
| IN | Predstavuje akýkoľvek neslovný znak, skratka pre [^ w] |
| b | Predstavuje hranicu slova |
| B | Je to neslovná hranica |
Príklad:
import java.util.regex. * verejná trieda MetacharExample {public static void main (String args []) {// d znamená číslicu System.out.println ('metaznaky d ....') // (nečíselné) System.out.println (Pattern.matches ('d', 'abc')) // Výstup: false // (číslica a príde raz) System.out.println (Pattern.matches ('d', '1')) ) // Výstup: true // (číslica, ale prichádza viackrát) System.out.println (Pattern.matches ('d', '4443')) // Výstup: false // (číslica a znak) System.out .println (Pattern.matches ('d', '323abc')) // Výstup: false // D znamená nečíselný System.out.println ('metaznaky D ....') // (nečíselný ale prichádza viackrát) System.out.println (Pattern.matches ('D', 'abc')) // Výstup: false // Je to digitálny System.out.println (Pattern.matches ('D', '1) ')) // Výstup: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Výstup: false // (číslica a znak) System.out.println (Pattern.matches (') D ',' 323abc ')) // Výstup: false // (nie je číslica a príde raz) System.out.println (Pattern.matches (' D ',' m ')) // Výstup: true System.out .pr intln ('metaznaky D s kvantifikátorom ....') // (neciferné a môžu prichádzať 0 alebo viackrát) System.out.println (Pattern.matches ('D *', 'abc')) // výstup : true}}Na základe vyššie uvedených podmienok zobrazí výstup. Takto to funguje. Takže to bolo o rôznych druhoch Regulárny výraz. Týmto sa dostávame na koniec tohto článku. JaDúfam, že ste to našli poučné. Ak sa chcete dozvedieť viac, môžete si pozrieť naše tiež.
Pozrite sa na autor: Edureka, dôveryhodná online vzdelávacia spoločnosť so sieťou viac ako 250 000 spokojných študentov rozmiestnených po celom svete. Sme tu, aby sme vám pomohli s každým krokom na vašej ceste. Okrem otázok týkajúcich sa tohto rozhovoru pre javu vymýšľame aj učebné osnovy určené pre študentov a profesionálov, ktorí sa chcú stať vývojármi v prostredí Java.
Máte na nás otázku? Uveďte to prosím v sekcii komentárov v tomto článku „Java Regex“ a my sa vám ozveme čo najskôr.