Arbetar med reguljära uttryck i Java

I dagens informationssystem är det normalt att se sökfunktioner, dessa funktioner måste bearbetas varje gång mönster av många fler komplex. För att kunna överväga varje fall i synnerhet skulle det ta några tusen år, varför mekanismer har utvecklats som gör det möjligt att upprätta en formulerad representation av sökningar.
Dessa formler finns i vanliga uttryck, som gör att vi kan upprätta mönster för utvärdering av textsträngar och returnera ett positivt eller negativt värde om strängen motsvarar den uttryckta formeln eller inte.
I Java Vi kan implementera reguljära uttryck på ett enkelt sätt, men detta kräver en ganska omfattande studie av utvecklaren så att han kan lära sig de olika elementen som den har.
Det sätt på vilket vi kan uttrycka de formler som vi kan testa våra mönster med en viss kodkonstruktion, vi kommer att kalla detta för reguljärt uttryckssyntax.
Vad tillåter syntaxen oss?Vad syntaxen tillåter oss är att etablera mönster efter typ av tecken, kvantitet, kombination av tecken och kvantiteter, börja med ett visst element, ange ett uttryck för formelns mitt och ett slut. Med detta kan vi identifiera mycket specifika mönster som kan behövas i vårt program eller kanske filtrera på ett mer adekvat sätt en sökning på en text eller en databas.
Låt oss se nedan en liten lista över de element som används mest i reguljära uttryck med Java, det finns många fler element än de som visas i denna handledning, så det rekommenderas att göra din egen forskning för att förstärka kunskap:
Start av rad\^ Med detta element fortsätter vi att indikera till Java som startar en rad i det reguljära uttrycket.
Slut på rad$ Med denna symbol anger vi att vi har avslutat raden.
Teckenlista[] Med parentes anger vi för det reguljära uttrycket att det ska söka efter någon av listorna inuti.
Utesluta[\^] Det tillåter oss att välja vilket tecken som inte är listat.
Kvantifierare{j, k} Leta reda på vad som finns i j antalet gånger som anges k; {j,} i det andra fallet, vad som helst j en eller flera gånger; till sist {j} indikerar att det som finns i ska visas j endast en gång.
Ord tecken\ w Leta reda på de tecken som tillhör ord, men om vi använder \ W det gör motsatsen lokaliserar tecken som inte hör hemma.
Siffror\ d Det tillåter oss att göra matchningar med endast siffror och om vi använder \ D vi matchar allt som inte är en siffra eller ett numeriskt tecken.
Blanks\ s Det tillåter oss att matcha tomma mellanslag som flikar, mellanslag, men om vi använder \ S gör det motsatta, det matchar allt som inte är vitt utrymme.
Som vi kan se med dessa få element kan vi bygga olika kombinationer som vi kan få relativt komplexa mönster med.
Om vi ​​vill prova en vanlig fras Innan vi sammanställer ett program kan vi använda rubular.com -sidan där vi kan utvärdera mönstren i realtid.

FÖRSTORA

Vi ska utföra ett enkelt exempel där vi ska testa a vanligt uttryck för att validera ett e -postmeddelande, kommer vi att använda följande:

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

Först måste vi ange det reguljära uttrycket i det första fältet i formen av sidan rubular.com sedan i fältet kallas din teststräng är det där vi ska testa olika e -postmeddelanden för att verifiera att regexet fungerar, låt oss se hur validatorn beter sig när vi anger ett ogiltigt e -postmeddelande:

FÖRSTORA

Som vi kan se saknas perioden i vårt exempelmeddelande, så det är ogiltigt och inte genererar ingen match Med det reguljära uttrycket kommer vi att korrigera det genom att placera den saknade punkten och validatorn genererar automatiskt ett positivt svar så att vi kan se att vårt reguljära uttryck fungerar utan problem.

FÖRSTORA

Som vi kan se är detta en mycket användbar resurs när vi lär oss att använda reguljära uttryck inte bara i Java om inte på något språk.
När vi vet vad var och en av de grundläggande elementen i syntaxen gör, måste vi nu lära oss hur vi kan skapa en leta efter ett mönster inom Java, med detta kan vi se vilka metoder, klasser och paket som spelar in när vi använder reguljära uttryck.
Det första vi bör veta är att alla dessa verktyg finns i paketet java.util.regex, så för att göra dessa exempel måste vi inkludera detta paket i början av våra klasser.
När ovanstående är gjort kan vi testa ett mönster på följande sätt:

 if (ourString.matches (ourExpression)) {// Om den matchar här kör vi en kod} 

Vi ser att vi använder metoden tändstickor (), detta kommer att utvärdera teckensträngen mot regexmönstret och returnera Sann eller falsk, om teckensträngen matchar mönstret eller inte.
Denna typ av användning är bra i små valideringar, men om vi ska använda en återkommande validering, det vill säga att den kommer att visas många gånger i vårt program, är det bäst att göra en liten rutin eller klass som gör att vi kan utvärdera strängen av parametrisk form, det vill säga en rutin eller metod som gör att vi kan ange en sträng och returnera sant eller falskt, redan jämfört med ett visst mönster.
I följande program kommer vi att testa ett litet mönster och vi kommer att utvärdera det mot ett par strängar och programmet kommer att berätta vilken det gör. match, det vill säga vilken som matchar och vilken inte, låt oss se koden och sedan får vi se hur den fungerar:

 importera java.util.regex. *; public class TestPatterns {public static void main (String [] argv) {String pattern = "Q [u] \ d + \."; String [] input = {"QA777. Är identifieraren för vår produkt.", "Quack, Quack, Quack!" }; Mönster p = Pattern.compile (mönster); för (String in: input) {boolean found = p.matcher (in) .lookingAt (); System.out.println ("'" + mönster + "'" + (hittat? "Matchar '": "matchar inte'") + i + "'"); }}} 

Här ser vi hur det första vi gör är att importera paketet som nämns i början av detta avsnitt, för att på så sätt få funktionerna i sökningen med reguljära uttryck. Sedan bygger vi ett mönster som vi kommer att använda är vårt program, i det här fallet är det ett mönster som matchar bokstaven ”F"Då måste den ha vilken karaktär som helst utom bokstaven"eller”Och måste sluta med en period. Sedan sammanställer vi vårt mönster med metoden sammanställa och vi kan använda den för att göra matcherna. Slutligen, om mönstret matchar, skrivs det ut med ordet match annars skriver vi ut det stämmer inte.
Låt oss se i följande bild hur detta ser ut när vi kör programmet:

FÖRSTORA

Vi noterar sedan, som förklarat, den första strängen eller kedjan om den matchar, men den andra inte, och för ytterligare referens lägger vi mönstret som jämförelsen ska göras på.
Vi ska nu genomföra ett mer avancerat exempel, vi kommer att identifiera vilken del av våra strängmatchningar, detta är mycket användbart när vi gör textsökningar, eftersom vi med detta kan markera matchningarna för vad användaren anger.
För detta kommer vi att använda samma bas i vårt tidigare program med några modifikationer, låt oss se koden och sedan förklaringen av den:

 importera java.util.regex. *; public class Match {public static void main (String [] argv) {String pattern = "Q [u] \ d + \."; Mönster r = Pattern.compile (mönster); String text = "Id är: QW990. Testets slut!"; Matcher m = r.matcher (text); if (m.find ()) {System.out.println (mönster + "matchar \" " + m.grupp (0) +" \ "insida \" " + text +" \ ""); } annat {System.out.println ("Inga träffar"); }}} 

Återigen ser vi hur vi startar vårt program inklusive paketet java.util.regex. *. Sedan använder vi samma mönster från föregående program och sammanställer det med metoden sammanställa, det intressanta kommer nu, vi har använt metoden matcher () för att hitta matchningen och sedan med metoden hitta () och metoden grupp () vi kan extrahera exakt vad som matchar, slutligen gör vi motsvarande skärmavtryck. Låt oss se hur vårt program ser ut nu:

FÖRSTORA

Således ser vi då hur vi kunde isolera ordet som verkligen matchar det mönster som vi har ordnat för jämförelsen av vanlig fras.
En av de mest använda programmen finns på former, där vi kan göra valideringar av mejl, telefonnummer, kreditkort, lösenord, IP -adresser, användarnamn, postnummer och till och med bekräfta att alla våra taggar i vårt HTML -dokument är korrekt stängda, vilket ger oss möjlighet att uppnå större säkerhet vid vår behandling av text som skrivs in av användare.
Men inte bara i valideringar i fält i en form, som vi märkte i vårt sista exempel kan vi också göra långa textsökningar Genom ett visst mönster, med det kan vi söka i mycket komplexa textdokument på ett systematiskt sätt och därmed spara mycket tid, helt enkelt genom att skriva ett litet program.
Med detta avslutar vi denna handledning, vi har lärt oss hur vi kan gå från att ha olika element till att uttrycka situationer i våra mönster till att effektivt göra motsvarande jämförelser av texten eller karaktärerna som vi vill utvärdera, allt detta tack vare vanliga uttryck. Dessa utvärderingar är ganska snabba tack vare de optimeringar som språket gör i de metoder som det erbjuder oss, så de är mycket lämpliga för konstruktion av gränssnitt där vi behöver söka och validera texten som användaren anger.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng