L'estrazione o la convalida dei dati è un aspetto importante di ogni linguaggio di programmazione. Uno dei modi più diffusi per la convalida dei dati è l'utilizzo di espressioni regolari. li usaespressioni regolari per descrivere uno schema di caratteri. Questo articolo su Java Regex elencherà i vari metodi di utilizzo delle espressioni nella seguente sequenza:
- Cosa sono le espressioni regolari?
- Cos'è Java Regex?
- Classe Matcher
- Pattern Class
- Classe di caratteri Regex
- Quantificatori Regex
- Metacaratteri Regex
Iniziamo!
Cosa sono le espressioni regolari?
PER Espressione regolare è una sequenza di caratteri che costruisce un modello di ricerca. Quando si cercano dati in un testo, è possibile utilizzare questo modello di ricerca per descrivere ciò che si sta cercando.
Un'espressione regolare può essere un file carattere singolo o uno schema più complicato. Può essere utilizzato per qualsiasi tipo di ricerca di testo e operazioni di sostituzione del testo. Un pattern Regex è costituito da caratteri semplici, come / abc / o una combinazione di caratteri semplici e speciali, come / ab * c / o /example(d+).d*/ .
Cos'è Java Regex?
Il Java Regex è un'API che viene utilizzata per definire un modello per la ricerca o la manipolazione . È ampiamente utilizzato per definire il vincolo su stringhe come password e convalida di posta elettronica.
Esistono diversi metodi per utilizzare Java Regex. Quindi andiamo avanti e diamo un'occhiata alle diverse espressioni.
Classe Matcher
Questa classe viene utilizzata per eseguire operazioni di corrispondenza su una sequenza di caratteri. La tabella sottostante rappresenta i vari metodi della classe Matcher.
| Metodo | Descrizione |
|---|---|
| corrispondenze booleane () | Verifica se l'espressione regolare data corrisponde al modello |
| booleano find () | Utilizzato per trovare l'espressione successiva che corrisponde al modello |
| boolean find (int start) | Cerca l'espressione successiva che corrisponde al modello dal numero iniziale specificato |
| Gruppo di stringhe () | Utilizzato per restituire la sottosequenza corrispondente |
| int start () | Restituisce l'indice iniziale della sottosequenza corrispondente |
| avere intenzione() | Restituisce l'indice finale della sottosequenza corrispondente |
| int groupCount () | Restituisce il numero totale della sottosequenza corrispondente |
Pattern Class
Pattern Class è una versione compilata di un'espressione regolare che viene utilizzata per definire il modello per il motore regex.
| Metodo | Descrizione |
|---|---|
| Compilazione di pattern statici (stringa regex) | Compila la regex data e restituisce l'istanza del Pattern |
| Corrisponde alle corrispondenze (input CharSequence) | Viene utilizzato per creare un matcher che abbina l'input fornito con il modello |
| corrispondenze booleane statiche (String regex, CharSequence input) | Funziona come una combinazione di metodi di compilazione e matcher. Compila l'espressione regolare e confronta l'input fornito con il modello |
| String [] split (CharSequence input) | Utilizzato per dividere la stringa di input data attorno alle corrispondenze di un determinato modello |
| Schema corde () | Aiuta a restituire il pattern regex |
Facciamo ora un piccolo esempio per capire come scrivere un'espressione regolare.
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 ('String corrisponde all'espressione regolare data - + matcher.matches ())}}In questo caso, internamente utilizza Pattern e Matcher classi regex per eseguire l'elaborazione ma ovviamente,riduce le righe di codice. La classe Pattern contiene anche il metodo delle corrispondenze che accetta regex e stringa di input come argomento e restituisce un risultato booleano dopo averle confrontate. Quindi il codice funziona bene per la corrispondenza dell'input con un'espressione regolare in Java. Quindi l'output sarà vero come mostrato di seguito.
lato mappa join in alveare
Produzione:
vero
Vediamo ora alcune altre categorie di espressioni regolari Java.
Classe di caratteri Regex
La tabella sottostante rappresenta la diversa combinazione di classi di caratteri.
| Classe di carattere | Descrizione |
|---|---|
| [abc] | a, b o c (classe semplice) |
| [^ abc] | Qualsiasi carattere tranne a, b o c (negazione) |
| [a-zA-Z] | dalla a alla z o dalla A alla Z, inclusi (intervallo) |
| [a-d [m-p]] | dalla a alla do, o dalla m alla p: [a-dm-p] (unione) |
| [a-z && [def]] | d, e o f (intersezione) |
| [a-z && [^ bc]] | dalla a alla z, ad eccezione di bec: [ad-z] (sottrazione) |
| [a-z && [^ m-p]] | dalla a alla z e non dalla m alla p: [a-lq-z] (sottrazione) |
Esempio:
import java.util.regex. * public class CharacterExample {public static void main (String args []) {// false (non x o y o z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (tra x o y o z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (xey viene visualizzato più di una volta) System .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}Quantificatori Regex
I quantificatori specificano il numero di occorrenze di un carattere. La tabella sottostante rappresenta vari quantificatori.
| Regex | Descrizione |
|---|---|
| X? | X si verifica una volta o non compare affatto |
| X + | X si verifica una o più volte |
| X * | X si verifica zero o più volte |
| X {n} | X si verifica solo n volte |
| X {n,} | X si verifica n o più volte |
| X e Z} | X si verifica almeno y volte ma meno di z volte |
Esempio:
import java.util.regex. * public class Esempio {public static void main (String args []) {System.out.println ('? quantifier ....') // (a o y o z viene una volta) System.out.println (Pattern.matches ('[ayz]?', 'A')) // output: true System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay ez arrivano più di una volta) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // output: false // (a arriva più di una volta) System. out.println (Pattern.matches ('[ayz]?', 'amnta')) // output: false // (aoy o z devono essere presenti una volta) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // output: false System.out.println (' + quantifier .... ') // (aoy o z una o più volte) System.out.println (Pattern .matches ('[ayz] +', 'a')) // output: true // (a viene più di una volta) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a o y o z è presente più di una volta) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z e t non corrispondono al pattern) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // output: false System.out.println ('* quantifier ....') // (a o y o z possono essere zero o più volte ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // output: true}}Fondamentalmente, cercherà il quantificatore corrispondente e corrisponderà al risultato della ricerca.
Metacaratteri Regex
I metacaratteri delle espressioni regolari funzionano come codici brevi. Diamo un'occhiata alla tabella seguente per comprendere vari tipi di metacaratteri.
| Regex | Descrizione |
|---|---|
| . | Può essere qualsiasi carattere (può o non può corrispondere al terminatore) |
| d | Rappresenta qualsiasi cifra, a meno di [0-9] |
| D | Rappresenta qualsiasi non cifra, abbreviazione di [^ 0-9] |
| S | Rappresenta qualsiasi carattere di spazio bianco, abbreviazione di [tnx0Bfr] |
| S | Può essere un carattere diverso da uno spazio bianco, abbreviazione di [^ s] |
| nel | Può essere un carattere alfanumerico, abbreviazione di [a-zA-Z_0-9] |
| NEL | Rappresenta qualsiasi carattere non alfanumerico, abbreviazione di [^ w] |
| b | Rappresenta un confine di parola |
| B | È un confine non di parole |
Esempio:
import java.util.regex. * public class MetacharExample {public static void main (String args []) {// d mean digit System.out.println ('metacharacters d ....') // (non-digit) System.out.println (Pattern.matches ('d', 'abc')) // Output: false // (cifra e arriva una volta) System.out.println (Pattern.matches ('d', '1') ) // Output: true // (cifra ma viene visualizzato più di una volta) System.out.println (Pattern.matches ('d', '4443')) // Output: false // (cifra e carattere) System.out .println (Pattern.matches ('d', '323abc')) // Output: false // D significa System.out.println non numerico ('metacaratteri D ....') // (non digit ma viene fornito più di una volta) System.out.println (Pattern.matches ('D', 'abc')) // Output: false // Its a Digit System.out.println (Pattern.matches ('D', '1 ')) // Output: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Output: false // (digit and char) System.out.println (Pattern.matches (' D ',' 323abc ')) // Output: false // (non cifra e viene fornito una volta) System.out.println (Pattern.matches (' D ',' m ')) // Output: true System.out .pr intln ('metacharacters D with quantifier ....') // (non digit e può venire 0 o più volte) System.out.println (Pattern.matches ('D *', 'abc')) // Output : vero } }In base alle condizioni sopra menzionate, visualizzerà l'output. Ecco come funziona. Quindi, si trattava di vari tipi di file Regex. Con questo, arriviamo alla fine di questo articolo. iospero che tu l'abbia trovato informativo. Se desideri saperne di più, puoi consultare il nostro anche.
Controlla il da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo. Siamo qui per aiutarti in ogni fase del tuo viaggio, per diventare oltre a queste domande di intervista Java, abbiamo creato un curriculum progettato per studenti e professionisti che vogliono essere uno sviluppatore Java.
Hai domande per noi? Per favore, menzionalo nella sezione commenti di questo articolo 'Java Regex' e ti risponderemo il prima possibile.