L’extracció o validació de dades és un aspecte important de tots els llenguatges de programació. Una de les formes més populars de validació de dades és mitjançant expressions regulars. utilitza aquestsexpressions regulars per descriure un patró de personatges. Aquest article sobre Java Regex enumerarà els diversos mètodes d’ús d’expressions en la seqüència següent:
- Què són les expressions regulars?
- Què és Java Regex?
- Classe Matcher
- Classe de patrons
- Classe de caràcters Regex
- Quantificadors de Regex
- Metacaracters de Regex
Comencem!
algoritme de classificació de combinació c ++
Què són les expressions regulars?
A Expressió normal és una seqüència de caràcters que construeix un patró de cerca. Quan cerqueu dades en un text, podeu utilitzar aquest patró de cerca per descriure el que esteu cercant.
Una expressió regular pot ser a un sol personatge o un patró més complicat. Es pot utilitzar per a qualsevol tipus de cerca de text i operacions de substitució de text. Un patró Regex consisteix en caràcters simples, com ara / Abc / o una combinació de caràcters simples i especials, com ara / ab * c / o bé /example(d+).d*/ .
Què és Java Regex?
El Java Regex és una API a la qual s'utilitza definiu un patró per cercar o manipular . S'utilitza àmpliament per definir la restricció de les cadenes, com ara la contrasenya i la validació del correu electrònic.
Hi ha diferents mètodes d'ús de Java Regex. Així que anem endavant i fem una ullada a les diferents expressions.
Classe Matcher
Aquesta classe s'utilitza per realitzar operacions de coincidència en una seqüència de caràcters. A la taula següent es representen diversos mètodes de la classe Matcher.
| Mètode | Descripció |
|---|---|
| coincidències booleanes () | Comprova si l'expressió regular donada coincideix amb el patró |
| find booleà () | S'utilitza per trobar la següent expressió que coincideix amb el patró |
| trobada booleana (int start) | Cerca la següent expressió que coincideix amb el patró del número d'inici donat |
| Grup de cadenes () | S'utilitza per retornar la subseqüència coincident |
| int start () | Retorna l'índex inicial de la subseqüència coincident |
| int end () | Retorna l'índex final de la subseqüència coincident |
| int groupCount () | Retorna el nombre total de la subseqüència coincident |
Classe de patrons
Pattern Class és una versió compilada d’expressions regulars que s’utilitza per definir el patró del motor d’expressió regular.
| Mètode | Descripció |
|---|---|
| compilació de patrons estàtics (regex de cadena) | Compila la regla regular donada i retorna la instància del Patró |
| Coincidències coincidents (entrada CharSequence) | S'utilitza per crear un aparellador que coincideixi amb l'entrada proporcionada amb el patró |
| coincidències booleanes estàtiques (cadena regex, entrada CharSequence) | Funciona com una combinació de mètodes de compilació i combinació. Compila l’expressió regular i fa coincidir l’entrada donada amb el patró |
| Cadena [] dividida (entrada CharSequence) | S'utilitza per dividir la cadena d'entrada donada al voltant de les coincidències d'un patró determinat |
| Patró de cadena () | Ajuda a retornar el patró d'expressió regular |
Prenguem ara un petit exemple per entendre com escriure una expressió regular.
import java.util.regex. * public class RegexExample {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('La cadena coincideix amb el Regex donat - + matcher.matches ())}}En aquest cas, internament utilitza Pattern and Matcher classes regulars per fer el processament, però òbviament,redueix les línies de codi. La classe de patrons també conté un mètode de coincidències que pren com a argument la regla regular i l'entrada de cadena i retorna un resultat booleà després de coincidir-les. Per tant, el codi funciona bé per coincidir amb l'entrada amb una expressió regular a Java. Per tant, la sortida serà certa com es mostra a continuació.
Sortida:
cert
Ara vegem algunes categories més d’expressions regulars de Java.
Classe de caràcters Regex
La taula següent representa la combinació de classes de caràcters diferents.
| Classe de personatges | Descripció |
|---|---|
| [Abc] | a, b o c (classe simple) |
| [^ Abc] | Qualsevol caràcter excepte a, b o c (negació) |
| [a-zA-Z] | de la a a la z o de la A a la Z, inclosos (rang) |
| [a-d [m-p]] | a a d, o m a p: [a-dm-p] (unió) |
| [a-z && [def]] | d, e o f (intersecció) |
| [a-z && [^ bc]] | a a z, excepte b i c: [ad-z] (resta) |
| [a-z && [^ m-p]] | a a z, i no m a p: [a-lq-z] (resta) |
Exemple:
import java.util.regex. * public class CharacterExample {public static void main (String args []) {// false (not x or y or z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (entre x o y o z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (xy arriba més d'una vegada) System .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}Quantificadors de Regex
Els quantificadors especifiquen el nombre d’ocurrències d’un caràcter. La taula següent representa diversos quantificadors.
| Regex | Descripció |
|---|---|
| X? | X es produeix una vegada o en absolut |
| X + | La X es produeix una o més vegades |
| X * | X es produeix zero o més vegades |
| X {n} | X només es produeix n vegades |
| X {n,} | X es produeix n o més vegades |
| X {i, z} | X es produeix com a mínim y vegades però menys que z vegades |
Exemple:
import java.util.regex. * public class Exemple {public static void main (String args []) {System.out.println ('? quantifier ....') // (a o y o z arriba una vegada) System.out.println (Pattern.matches ('[ayz]?', 'A')) // sortida: true System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay i z vénen més d'una vegada) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // sortida: fals // (a arriba més d'una vegada) Sistema. out.println (Pattern.matches ('[ayz]?', 'amnta')) // sortida: false // (a o y o z ha d'arribar una vegada) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // sortida: false System.out.println (' + quantificador .... ') // (a o y o z una o més vegades) System.out.println (Patró .matches ('[ayz] +', 'a')) // sortida: true // (a arriba més d'una vegada) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a o y o z ve més d'una vegada) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z et no coincideixen amb el patró) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // sortida: false System.out.println ('* quantificador ....') // (a o y o z poden venir zero o més vegades ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // sortida: true}}Bàsicament, cercarà el quantificador coincident i coincideix amb el resultat de la cerca.
Metacaracters de Regex
Els metacaràcters d’expressió regular funcionen com a codis curts. Vegem la taula següent per comprendre diversos tipus de metacaracters.
| Regex | Descripció |
|---|---|
| . | Pot ser qualsevol caràcter (pot coincidir o no amb el terminador) |
| d | Representa qualsevol dígit, inferior a [0-9] |
| D | Representa qualsevol abreviatura sense dígits per a [^ 0-9] |
| s | Representa qualsevol caràcter d'espai en blanc, abreviatura de [tnx0Bfr] |
| S | Pot ser un caràcter que no sigui en blanc, abreujant per [^ s] |
| dins | Pot ser un caràcter de paraula, abreviatura de [a-zA-Z_0-9] |
| IN | Representa qualsevol caràcter que no sigui de paraula, abreujant per [^ w] |
| b | Representa un límit de paraules |
| B | No és un límit de paraules |
Exemple:
import java.util.regex. * public class MetacharExample {public static void main (String args []) {// d significa dígits System.out.println ('metacaracters d ....') // (sense dígits) System.out.println (Pattern.matches ('d', 'abc')) // Sortida: fals // (dígit i ve una vegada) System.out.println (Pattern.matches ('d', '1') ) // Sortida: cert // (dígit però ve més d’una vegada) System.out.println (Pattern.matches ('d', '4443')) // Sortida: fals // (dígit i caràcter) System.out .println (Pattern.matches ('d', '323abc')) // Sortida: fals // D vol dir System.out.println sense dígits ('metacaràcters D ....') // (sense dígits però ve més d'una vegada) System.out.println (Pattern.matches ('D', 'abc')) // Sortida: fals // És un dígit System.out.println (Pattern.matches ('D', '1 ')) // Sortida: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Sortida: false // (dígit i caràcter) System.out.println (Pattern.matches (' D ',' 323abc ')) // Sortida: falsa // (sense dígits i ve una vegada) System.out.println (Pattern.matches (' D ',' m ')) // Sortida: true System.out .pr intln ('metacaràcters D amb quantificador ....') // (sense dígits i pot aparèixer 0 o més vegades) System.out.println (Pattern.matches ('D *', 'abc')) // Sortida : veritable}}Basant-se en les condicions esmentades anteriorment, mostrarà la sortida. Així funciona. Així doncs, es tractava de diversos tipus de Regex. Amb això, arribem al final d’aquest article. Joespero que us hagi estat informatiu. Si voleu obtenir més informació, podeu consultar el nostre també.
Consulteu el per Edureka, una empresa d'aprenentatge en línia de confiança amb una xarxa de més de 250.000 estudiants satisfets repartits per tot el món. Estem aquí per ajudar-vos en tots els passos del vostre viatge, per convertir-vos en una pregunta a part d’aquestes entrevistes java, oferim un pla d’estudis dissenyat per a estudiants i professionals que vulguin ser desenvolupador de Java.
__init__ en pitó
Tens alguna pregunta? Si us plau, mencioneu-lo a la secció de comentaris d'aquest article de 'Java Regex' i us respondrem el més aviat possible.