Ang pagkuha ng data o pagpapatunay ay isang mahalagang aspeto ng bawat wika ng programa. Ang isa sa mga pinakatanyag na paraan para sa pagpapatunay ng data ay sa pamamagitan ng paggamit ng mga regular na expression. ginagamit ang mga itoregular na expression upang ilarawan ang isang pattern ng mga character. Ang artikulong ito sa Java Regex ililista ang iba't ibang mga pamamaraan ng paggamit ng mga expression sa sumusunod na pagkakasunud-sunod:
- Ano ang Mga Regular na Pagpapahayag?
- Ano ang Java Regex?
- Matcher Class
- Pattern ng klase
- Klase ng Regex Character
- Mga Quexifier ng Regex
- Mga Regex Metacharacter
Magsimula na tayo!
Ano ang Mga Regular na Pagpapahayag?
SA Regular na Pagpapahayag ay isang pagkakasunud-sunod ng mga character na bumubuo ng isang pattern sa paghahanap. Kapag naghanap ka ng data sa isang teksto, maaari mong gamitin ang pattern ng paghahanap na ito upang ilarawan kung ano ang iyong hinahanap.
Ang isang regular na pagpapahayag ay maaaring maging a solong character o isang mas kumplikadong pattern. Maaari itong magamit para sa anumang uri ng paghahanap sa teksto at operasyon ng pagpapalit ng teksto. Ang isang pattern ng Regex ay binubuo ng mga simpleng character, tulad ng / abc / , o isang kombinasyon ng mga simple at espesyal na character, tulad ng / ab * c / o /example(d+).d*/ .
Ano ang Java Regex?
Ang Java Regex ay isang API na dati ay tukuyin ang isang pattern para sa paghahanap o pagmamanipula . Malawakang ginagamit ito upang tukuyin ang hadlang sa Mga Strings tulad ng pagpapatunay ng password at email.
Mayroong iba't ibang mga pamamaraan ng paggamit ng Java Regex. Kaya't magpatuloy tayo at tingnan ang iba't ibang mga expression.
pag-uuri ng pag-andar sa c ++
Matcher Class
Ang klase na ito ay ginagamit upang maisagawa ang mga pagpapatakbo ng tugma sa isang pagkakasunud-sunod ng character. Kinakatawan ng talahanayan sa ibaba ang iba't ibang mga pamamaraan ng klase ng Matcher.
| Pamamaraan | Paglalarawan |
|---|---|
| mga tugma sa boolean () | Sinusubukan kung ang ibinigay na regular na pagpapahayag ay tumutugma sa pattern |
| boolean find () | Ginamit upang mahanap ang susunod na ekspresyon na tumutugma sa pattern |
| hanapin ang boolean (int start) | Hinanap ang susunod na ekspresyon na tumutugma sa pattern mula sa ibinigay na bilang ng pagsisimula |
| Grupo ng pangkat () | Ginamit upang ibalik ang katugmang susunod |
| int start () | Ibinabalik ang panimulang indeks ng katugmang susunod |
| int end () | Ibinabalik ang nagtatapos na index ng naitugmang susunod |
| int groupCount () | Ibinabalik ang kabuuang bilang ng naitugmang susunod |
Pattern ng klase
Ang pattern ng Class ay isang naipong bersyon ng regular na expression na ginagamit upang tukuyin ang pattern para sa regex engine.
| Pamamaraan | Paglalarawan |
|---|---|
| static na Pag-ipon ng pattern (String regex) | Pinagsasama nito ang ibinigay na regex at ibinabalik ang halimbawa ng pattern |
| Mga tugma sa tugma (input ng CharSequence) | Ginagamit ito upang lumikha ng isang matcher na tumutugma sa ibinigay na input sa pattern |
| static boolean match (String regex, CharSequence input) | Gumagana ito bilang isang kumbinasyon ng mga pamamaraan ng pagtitipon at matcher. Pinagsasama nito ang regular na expression at tumutugma sa ibinigay na input sa pattern |
| Hinahati ang String [] (input ng CharSequence) | Ginamit upang hatiin ang ibinigay na input String sa paligid ng mga tugma ng isang naibigay na pattern |
| Pattern ng string () | Mga Tulong upang Maibalik ang pattern ng regex |
Ngayon kumuha tayo ng isang maliit na halimbawa upang maunawaan kung paano magsulat ng isang regular na pagpapahayag.
import java.util.regex. * pampublikong klase RegexExample {public static void main (String [] args) {pattern pattern = pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('Tumutugma ang string sa ibinigay na Regex - + matcher.matches ())}}Sa kasong ito, sa panloob ay gumagamit ito ng Pattern at Matcher regex klase upang gawin ang pagproseso ngunit malinaw naman,binabawasan nito ang mga linya ng code. Naglalaman din ang pattern ng pattern ng mga pamamaraan ng pagtutugma na kumukuha ng regex at pag-input ng String bilang argument at nagbabalik ng isang resulta ng boolean pagkatapos na maitugma ang mga ito. Kaya't gumagana nang maayos ang code para sa pagtutugma ng input na may isang Regular na expression sa Java. Samakatuwid ang output ay magiging totoo tulad ng ipinakita sa ibaba.
Output:
totoo
Ngayon tingnan natin ang ilan pang mga kategorya ng Java Regular Expressions.
Klase ng Regex Character
Kinakatawan ng talahanayan sa ibaba ang magkakaibang kumbinasyon ng klase ng character.
| Character Class | Paglalarawan |
|---|---|
| [abc] | a, b, o c (simpleng klase) |
| [^ abc] | Anumang character maliban sa a, b, o c (pagwawaksi) |
| [a-zA-Z] | isang hanggang z o A hanggang Z, kasama (saklaw) |
| [a-d [m-p]] | a hanggang d, o m sa pamamagitan ng p: [a-dm-p] (unyon) |
| [a-z && [def]] | d, e, o f (intersection) |
| [a-z && [^ bc]] | a hanggang z, maliban sa b at c: [ad-z] (pagbabawas) |
| [a-z && [^ m-p]] | a sa pamamagitan ng z, at hindi m sa pamamagitan ng p: [a-lq-z] (pagbabawas) |
Halimbawa:
import java.util.regex. * pampublikong klase CharacterExample {public static void main (String args []) {// false (not x or y or z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (among x or y or z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (x at y dumating nang higit sa isang beses) System .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz')}}Mga Quexifier ng Regex
Tinutukoy ng mga nagbibilang ng dami ang bilang ng mga paglitaw ng isang character. Sa ibaba ng talahanayan ay kumakatawan sa iba't ibang mgaquififier.
ano ang session sa java
| Regex | Paglalarawan |
|---|---|
| X? | Nangyayari ang X nang isang beses o hindi man |
| X + | Nangyayari ang X nang isang beses o higit pang beses |
| X * | Ang X ay nangyayari zero o higit pang beses |
| X {n} | Ang X ay nangyayari n beses lamang |
| X {n,} | Ang X ay nangyayari n o higit pang mga beses |
| X at Z} | Ang X ay nangyayari nang hindi bababa sa mga y beses ngunit mas mababa sa z beses |
Halimbawa:
import java.util.regex. * pampublikong klase Halimbawa {public static void main (String args []) {System.out.println ('? quantifier ....') // (a o y o z ay dumating isang beses) System.out.println (Pattern.matches ('[ayz]?', 'A')) // output: true System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay at z ay dumating nang higit sa isang beses) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // output: false // (a come more than one time) System. out.println (Pattern.matches ('[ayz]?', 'amnta')) // output: false // (a or y or z must come one time) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // output: false System.out.println (' + quantifier .... ') // (a o y o z minsan o higit pang beses) System.out.println (Pattern .matches ('[ayz] +', 'a')) // output: true // (a more than one time) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a o y o z ay dumating nang higit sa isang beses) System.out.println (Pattern.matches ([amn + +, 'aayyyzz')) // output: true // (z at t ay hindi tumutugma sa pattern) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // output: false System.out.println ('* quantifier ....') // (a o y o z ay maaaring dumating zero o higit pang beses ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // output: true}}Karaniwan, hahanapin nito ang pagtutugma ng dami at tumutugma sa resulta ng paghahanap.
Mga Regex Metacharacter
Gumagana ang regular na mga metacharacter na expression bilang mga shortcode. Tingnan natin ang talahanayan sa ibaba upang maunawaan ang iba't ibang mga uri ng mga metacharacter.
| Regex | Paglalarawan |
|---|---|
| . | Maaari itong maging anumang character (maaaring o hindi tumugma sa terminator) |
| d | Kinakatawan ang anumang mga digit, maikli sa [0-9] |
| D | Kinakatawan ang anumang hindi digit, maikli para sa [^ 0-9] |
| s | Kinakatawan ang anumang character na whitespace, maikli para sa [tnx0Bfr] |
| S | Maaari itong isang character na hindi whitespace, maikli para sa [^ s] |
| sa | Maaari itong isang character na salita, maikli para sa [a-zA-Z_0-9] |
| SA | Kinakatawan ang anumang character na hindi salita, maikli para sa [^ w] |
| b | Kumakatawan sa isang hangganan ng salita |
| B | Ito ay isang hangganan na hindi salita |
Halimbawa:
import java.util.regex. * pampublikong klase MetacharExample {public static void main (String args []) {// d nangangahulugang digit System.out.println ('metachar character d ....') // (non-digit) System.out.println (Pattern.matches ('d', 'abc')) // Output: false // (digit at darating isang beses) System.out.println (Pattern.matches ('d', '1') ) // Output: true // (digit ngunit darating nang higit sa isang beses) System.out.println (Pattern.matches ('d', '4443')) // Output: false // (digit at char) System.out .println (Pattern.matches ('d', '323abc')) // Output: false // D nangangahulugang hindi digit na System.out.println ('metachar character D ....') // (hindi digit ngunit dumating nang higit sa isang beses) System.out.println (Pattern.matches ('D', 'abc')) // Output: false // Ito ay isang Digit System.out.println (Pattern.matches ('D', '1 ')) // Output: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Output: false // (digit at char) System.out.println (Pattern.matches (' D ',' 323abc ')) // Output: false // (non-digit at darating minsan) System.out.println (Pattern.matches (' D ',' m ')) // Output: true System.out .pr intln ('metachar character D na may tagatukoy ....') // (hindi digit at maaaring dumating 0 o higit pang beses) System.out.println (Pattern.matches ('D *', 'abc')) // Output : totoo}}Batay sa mga nabanggit na kundisyon, ipapakita nito ang output. Ganyan ang paggana nito. Kaya, Iyon ay ang lahat tungkol sa iba't ibang mga uri ng Regex. Sa pamamagitan nito, natapos na kami sa artikulong ito. Akosana ay nalaman mong ito ay may kaalaman. Kung nais mong matuto nang higit pa, maaari mong suriin ang aming din.
Suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Narito kami upang matulungan ka sa bawat hakbang sa iyong paglalakbay, para sa pagiging isang bukod sa mga katanungang ito sa panayam sa java, nakakakuha kami ng isang kurikulum na idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer.
mga algorithm at istruktura ng data sa java
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng artikulong 'Java Regex' at babalikan ka namin sa lalong madaling panahon.