Java Regex: què són les expressions regulars i com s'utilitza?

Java Regex és una API que s’utilitza per definir un patró per cercar o manipular cadenes. En aquest article també es parlarà de diverses classes d’expressions regulars proporcionades per Java.

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:



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.

Expressions regulars - Java Regex - Edureka



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 personatgesDescripció
[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.

RegexDescripció
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.

RegexDescripció
. 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.