Lavorare con le espressioni regolari in Java

Nei sistemi informativi odierni è normale vedere funzioni di ricerca, queste funzioni ogni volta devono elaborare modelli di molti più complessi. Per poter considerare ogni caso in particolare, ci vorrebbero alcune migliaia di anni, motivo per cui sono stati sviluppati meccanismi che consentono di stabilire una rappresentazione formulata delle ricerche.
Queste formule possono essere trovate nel espressioni regolari, che ci permettono di stabilire dei pattern per la valutazione delle stringhe di testo e restituiscono un valore positivo o negativo se detta stringa corrisponde o meno alla formula espressa.
Nel Giava Possiamo implementare le espressioni regolari in modo semplice, ma ciò richiede uno studio piuttosto ampio da parte dello sviluppatore in modo che possa apprendere i diversi elementi che ha.
Il modo in cui possiamo esprimere le formule con cui possiamo testare i nostri modelli con una particolare costruzione di codice, lo chiameremo il sintassi delle espressioni regolari.
Cosa ci permette la sintassi?Ciò che la sintassi ci consente è di stabilire modelli per tipo di carattere, quantità, combinazione di caratteri e quantità, inizia con un elemento particolare, imposta un'espressione per il centro della formula e una fine. Con questo possiamo identificare pattern molto specifici che potrebbero essere necessari nel nostro programma o magari filtrare in modo più adeguato una ricerca su un testo o un database.
Vediamo di seguito un piccolo elenco degli elementi più utilizzati nelle espressioni regolari con Giava, ci sono molti più elementi rispetto a quelli mostrati in questo tutorial, quindi si consiglia di fare le proprie ricerche per rafforzare la conoscenza:
Inizio della linea\^ Con questo elemento si procede ad indicare a Giava che inizia una riga nell'espressione regolare.
Fine linea$ Con questo simbolo indichiamo che abbiamo terminato la linea.
Elenco dei personaggi[] Con parentesi indichiamo all'espressione regolare che dovrebbe cercare una qualsiasi delle liste all'interno.
Escludere[\^] Ci permette di selezionare qualsiasi carattere che non è elencato.
Quantificatore{j, k} Trova cosa c'è dentro J il numero di volte indicato K; {J,} in questo secondo caso, qualunque cosa sia in J una o più volte; finalmente {J} indica che ciò che è in dovrebbe apparire J una sola volta.
Caratteri di parole\ w Individua i personaggi che appartengono a parola, ma se usiamo \ W fa l'opposto individua i caratteri che non appartengono.
cifre\ D Ci permette di fare corrispondenze con solo cifre e se usiamo \ D abbineremo tutto ciò che non è una cifra o un carattere numerico.
spazi vuoti\ S Ci permette di abbinare spazi vuoti come tab, barra spaziatrice, ma se usiamo \ S fa il contrario, abbina tutto ciò che non è spazio bianco.
Come possiamo vedere con questi pochi elementi possiamo costruire varie combinazioni con le quali possiamo arrivare ad ottenere schemi relativamente complessi.
Se vogliamo provarne uno frase normale Prima di compilare un programma possiamo utilizzare la pagina rubular.com dove possiamo valutare i pattern in tempo reale.

INGRANDIRE

Faremo un semplice esempio in cui testeremo a espressione regolare per convalidare un'e-mail, utilizzeremo quanto segue:

[_ a-z0-9 -] + (\. [_ a-z0-9 -] +) * @ [a-z0-9 -] + (\. [a-z0-9 -] +) * (\ . [az] {2,3}) $

Per prima cosa dobbiamo inserire l'espressione regolare nel primo campo del form della pagina di rubular.com poi nel campo chiamato la tua stringa di prova è dove testeremo diverse email per verificare che l'espressione regolare funzioni, vediamo come si comporta il validatore quando inseriamo una email non valida:

INGRANDIRE

Come possiamo vedere, nella nostra email di esempio manca il punto, quindi non è valido e no non genera corrispondenze Con l'espressione regolare, la correggeremo posizionando il punto mancante e il validatore genera automaticamente una risposta positiva che ci consente di vedere che la nostra espressione regolare funziona senza problemi.

INGRANDIRE

Come possiamo vedere, questa è una risorsa molto utile quando stiamo imparando a usare le espressioni regolari non solo in Giava se non in qualsiasi lingua.
Una volta che sappiamo cosa fa ciascuno degli elementi di base della sintassi, ora dobbiamo imparare come possiamo creare un cerca uno schema entro Giava, con questo possiamo vedere quali metodi, classi e pacchetti entrano in gioco quando usiamo le espressioni regolari.
La prima cosa che dovremmo sapere è che tutte queste utilità sono nel pacchetto java.util.regex, quindi per fare questi esempi dobbiamo includere questo pacchetto all'inizio delle nostre classi.
Una volta fatto quanto sopra, possiamo testare un modello nel modo seguente:

 if (ourString.matches (ourExpression)) {// Se corrisponde qui eseguiamo un codice} 

Vediamo che usiamo il metodo fiammiferi (), questo valuterà la stringa di caratteri rispetto al modello regex e restituirà vero o falso, nel caso in cui la stringa di caratteri corrisponda o meno al modello.
Questo tipo di utilizzo va bene nelle piccole convalide, tuttavia se useremo una convalida ricorrente, cioè apparirà molte volte all'interno del nostro programma, è meglio creare una piccola routine o classe che ci permetta di valutare la stringa di forma parametrica, cioè una routine o un metodo che ci permette di inserire una stringa e restituire vero o falso, già confrontando con un particolare pattern.
Nel seguente programma testeremo un piccolo modello e lo valuteremo rispetto a un paio di stringhe e il programma ci dirà quale fa. incontro, cioè quale corrisponde e quale no, vediamo il codice e poi vedremo come funziona:

 import java.util.regex.*; public class TestPatterns {public static void main (String [] argv) {String pattern = "Q [u] \ d + \."; String [] input = {"QA777. È l'identificatore del nostro prodotto.", "Quack, Quack, Quack!" }; Modello p = Modello.compile (schema); for (String in: input) {boolean found = p.matcher (in) .lookingAt (); System.out.println ("'" + pattern + "'" + (trovato? "Matches'": "non corrisponde a '") + in + "'"); }}} 

Qui vediamo come la prima cosa che facciamo è importare il pacchetto citato all'inizio di questa sezione, in modo da ottenere in questo modo le funzionalità della ricerca per espressioni regolari. Quindi costruiamo uno schema che utilizzeremo è il nostro programma, in questo caso è uno schema che corrisponde alla lettera "Q"Allora deve avere qualsiasi carattere tranne la lettera"o«E deve finire con un punto. Quindi compiliamo il nostro modello usando il metodo compilare e possiamo usarlo per fare le partite. Infine, se il motivo corrisponde, viene stampato con la parola incontro altrimenti stampiamo non corrisponde.
Vediamo nell'immagine seguente come appare quando eseguiamo il programma:

INGRANDIRE

Notiamo quindi, come spiegato, la prima stringa o catena se corrisponde, ma la seconda no, e per ulteriore riferimento posizioniamo lo schema su cui dovrebbe essere fatto il confronto.
Ora faremo un esempio più avanzato, identificheremo quale parte della nostra stringa corrisponde, questo è molto utile quando facciamo ricerche di testo, poiché con questo potremmo evidenziare le corrispondenze di ciò che l'utente inserisce.
Per questo utilizzeremo la stessa base del nostro programma precedente con alcune modifiche, vediamo il codice e poi la spiegazione:

 import java.util.regex.*; public class Match {public static void main (String [] argv) {String pattern = "Q [u] \ d + \."; Pattern r = Pattern.compile (schema); String text = "L'id è: QW990. Fine del test!"; Matcher m = r.matcher (testo); if (m.find ()) {System.out.println (pattern + "matches \" "+ m.group (0) +" \ "inside \" "+ text +" \ ""); } else {System.out.println ("Nessuna corrispondenza"); }}} 

Ancora una volta vediamo come iniziamo il nostro programma compreso il pacchetto java.util.regex.*. Quindi usiamo lo stesso modello del programma precedente e lo compiliamo con il metodo compilare, la cosa interessante viene ora, abbiamo usato il metodo abbinatore () per individuare la corrispondenza e poi con il metodo Trovare () e il metodo gruppo () possiamo estrarre esattamente ciò che corrisponde, infine facciamo le serigrafie corrispondenti. Vediamo come si presenta ora il nostro programma:

INGRANDIRE

Vediamo quindi come siamo riusciti ad isolare la parola che corrisponde realmente allo schema che abbiamo predisposto per il confronto dei frase normale.
Una delle applicazioni più utilizzate è sul forme, dove possiamo fare convalide di e-mail, numeri di telefono, carte di credito, password, indirizzi IP, nomi utente, codici postali e anche convalidare che tutti i nostri tag nel nostro documento HTML siano chiusi correttamente, questo ci dà la possibilità di ottenere una maggiore sicurezza nella nostra elaborazione del testo inserito dagli utenti.
Ma non solo nelle validazioni nei campi di un form, come abbiamo notato nel nostro ultimo esempio possiamo anche fare lunghe ricerche di testo Con uno schema particolare, con esso possiamo ricercare in modo sistematico documenti di testo molto complessi e quindi risparmiare molto tempo, semplicemente scrivendo un piccolo programma.
Con questo finiamo questo tutorial, abbiamo imparato come possiamo passare dall'avere diversi elementi per esprimere situazioni all'interno dei nostri schemi per fare in modo efficace i corrispondenti confronti del testo o dei caratteri che vogliamo valutare, tutto questo grazie al espressioni regolari. Queste valutazioni sono abbastanza veloci grazie alle ottimizzazioni che il linguaggio fa nei metodi che ci offre, quindi sono molto adatte per la costruzione di interfacce in cui dobbiamo cercare e convalidare il testo che l'utente inserisce.Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo