• Szerző: Sallai András
• Copyright © 2011, Sallai András
• Szerkesztve: 2011, 2013, 2014
• Licenc: CC BY-SA 4.0
• Web: https://szit.hu

A szabályos kifejezések vagy másként mintaillesztés, angolul regular expressions, minták keresését, cserélését teszi lehetővé. A minták használatának lehetősége programozói munkát takaríthat meg. Ma már minden implementált programozási nyelvben előfordul.

A regexek a Unix világából erednek, de legmagasabb szintre talán a Perl nyelvben fejlesztették. A mintaillesztések terén így két rendszert tartunk követendőnek, a POSIX ¹⁾ és a PCRE ²⁾.

Adott egy karaktersorozat. Szeretnénk megtudni, hogy az „abc” karaktersorozatot tartalmazza-e.

Megvalósítás:

Program.java

class Program
{
	public static void main(String args[])
	{
		String str = "abc";
                boolean a = str.matches("abc"); 	
		System.out.println(a);
	}
}

Ez persze semmiben nem különbözik attól, mintha equals() metódust használtam volna.

• keresés (matches)
• csere (replaceAll, replaceFirst)
• darabolás (split)

A matches() metódus teljes egyezést vizsgál, ellentétben a például a replaceAll() metódusban használatos reguláris kifejezésekkel. Utóbbiban ha a karakter sorozatban bárhol megtalálható a minta az egyezés áll, tehát csere történik.

A fentiek miatt a matches() metódusban nincs értelme néhány illesztésnek. Például „^” és „$”, amelyek a sor elejére és a sor végére illeszkedést vizsgálják, mivel eleve a illeszkedni kell a mintának a sor elejére és a sor végére. A „^” és „$” illesztések viszont értelmesek a replaceAll() metódusban.

Keresztrejtvény megoldásához szeretnénk programot írni. Ha van például egy öt betűs szavunk, amelynek megvan az első három betűje, szeretnénk egy adatbázisból vagy fájlból olyan szavakat listázni, amelyek ezzel a három betűvel kezdődnek. Legen ez a példa kedvéért:

jel..

Az hiányzó betűk helyére pontokat tettem, jelezve, hogy oda kell két betű még.

Mivel a jel szóval nagyon sok szó kezdődik, nagyon megkönnyítené a program ha csak azokat a szavakat írná ki, amelyik a „jel” szóval kezdődik és utána csak két betű van.

A Java nyelv lehetővé teszi a szabályos kifejezések használatát karaktersorozatoknál. Az egyik metódus a matches(), amellyel illeszkedéseket vizsgálhatunk.

A keresztrejtvényes feladatunkat tekintve, szükségünk lenne olyan szavakra, amelyek a „jel” szóval kezdődnek és utána két betű. Legyen egy szavak nevű lista amely szavakat tartalmaz, amiben keresni szeretnénk.

String[] szavak = {
	"hurka", "hurok", "hús", "húsvét",
	"huzam", "ideg", "idomár", "időzik",
	"igazol", "ige", "igazság", "ígér",
	"iktató", "illat", "illegális",
	"jel", "jelöl", "jelzés", "jelvény", 
	"jelmondat", "jellem", "jelenet", "jeles", 
	"jelen", "jelenleg", "jelkép", "jellemzés",
	"jelmez", "jelleg"};

Ha egy bizonyos szót szeretnék kiíratni, könnyű dolgom lenne. Keressük például a jelzés szót. Ezt megkereshetem az equals() metódussal is, ehhez nem szükséges szabályos kifejezés.

for(int i=0;i<szavak.length;i++){
	if(szavak[i].equals("jelzés")){
		System.out.println(szavak[i]);
	}
}

Nekünk azonban csak annyit tudunk, hogy a keresett szó a „jel” taggal kezdődik. A matches() metódusban megadhatunk a hiányzó karakterek helyett, úgynevezett helyettesítő karaktereket. A pont „.” helyettesítő karakter, például egy darab karaktert helyettesít, ami bármi lehet. Tegyük fel, hogy nem három, hanem négy betű van meg a keresett szóból:

jele.

Ezt pont helyettesítőt használjuk a Java matches() metódusában is:

for(int i=0;i<szavak.length;i++){
	if(szavak[i].matches("jele.")){
		System.out.println(szavak[i]);
	}
}

A szólistából most két szót kapunk:

• jeles
• jelen

A pont „.” tehát egy olyan helyettesítő karakter, amely bármilyen karakterre illeszkedik, de csak egy karakterre vonatkozik a helyettesítés. Nem véletlenül írtam karaktert és nem betűt. Ugyanis nem csak betűre illeszkedik. Illeszkedik plusz „+”, et „@”, nagyobb mint „>”, de bármilyen karakterre.

Ha szavak között lenne egy „jele>” vagy „jele+”, ezeket is megkapnánk.

Ha nem vagyunk biztosak abban, hogy a negyedik karakter „e” betű – mint az eredeti feladatunkban is van, akkor tehetünk két pontot a hiányzó karakterek helyére:

for(int i=0;i<szavak.length;i++){
	if(szavak[i].matches("jel..")){
		System.out.println(szavak[i]);
	}
}

Ekkor eggyel több szót kapunk eredményül:

• jeles
• jelen
• jelöl

Vegyük újra az előző szógyűjteményünket:

String[] szavak = {
	"hurka", "hurok", "hús", "húsvét",
	"huzam", "ideg", "idomár", "időzik",
	"igazol", "ige", "igazság", "ígér",
	"iktató", "illat", "illegális",
	"jel", "jelöl", "jelzés", "jelvény", 
	"jelmondat", "jellem", "jelenet", "jeles", 
	"jelen", "jelenleg", "jelkép", "jellemzés",
	"jelmez", "jelleg"};

Szeretnénk megszámolni hány darab szó kezdődik „j” betűvel. Igaz mintának be tudjuk írni, hogy „.” és az akármilyen karakter lehet, de hány pontot írjak?

j..

Ez csak akkor illeszkedik, ha „j” után két betű van.

j...

Ez pedig csak akkor a „j” után három betű van.

A fenti felvetésre adnak megoldást a többszörözők. A többszörözők mindig az előtte lévő karakterre vonatkoznak. Az első többszöröző a „*”. Pont után téve, azt jelenti, egy bármilyen karakter amiből akár hány darab van, de ha egy sincs, akkor sem gond. A minta legyen tehát:

j.*

Ez a minta azt jelenti, hogy elvárás egy szó elején egy „j” betű, utána bármilyen karakter szerepelhet, akárhányszor, de ha nincs utána semmi, az sem gond. Próbáljuk ki:

String word = "játék";
System.out.println(word.matches("j.*"));

A „j” betűvel kezdődő szavakat megszámoló programunk ezek után:

Program01.java

class Program01
{
	public static void main(String args[])
	{
		String[] szavak = {
			"hurka", "hurok", "hús", "húsvét",
			"huzam", "ideg", "idomár", "időzik",
			"igazol", "ige", "igazság", "ígér",
			"iktató", "illat", "illegális",
			"jel", "jelöl", "jelzés", "jelvény", 
			"jelmondat", "jellem", "jelenet", "jeles", 
			"jelen", "jelenleg", "jelkép", "jellemzés",
			"jelmez", "jelleg"};
 
		System.out.printf("Szavak száma: %d\n", szavak.length);
		int count = 0;
		for(int i=0;i<szavak.length;i++){
			if(szavak[i].matches("j.*")){
				count++;				
			}
		}
		System.out.printf("j betűvel kezdődik: %d\n", count);
	}
}

A többszörözőből persze több is van. A következő többszöröző a „+” karakter. Ez ugyanúgy működik mint a „*”, de minimum egyszer megköveteli az előtte lévő karaktert.

j.+

A fenti mintaillesztésben tehát csak két betűs szóra kapunk illeszkedést, amíg a most következő illesztésnél ha a „j” magában áll, akkor is illeszkedést kapunk:

j.*

Természetesen nem csak a „.”-nak, de bármely más betű is lehet többszörözve.

ja+

Utóbbi minta, például megköveteli „j” kezdést, ami után tetszőleges „a” betű lehetséges, de csak „a” betű, és minimum egynek lennie kell.

A ? többszöröző esetén akkor kapunk illesztést, ha egyszer szerepel az előtte levő érték, vagy egyszer sem.

ja?

Utóbbi minta illeszkedik a „j” és a „ja” szavakra.

Lehetséges elvárás, hogy pontosan adott számú karaktert várok egy szövegben. Az illesztés általánosan leírva: {n}.

ja{3}

A fenti minta, akkor illeszkedik, ha az előtt lévő „a” betűből pontosan három darab van. Vagyis illeszkedik a „jaaa” szóra. Persze ennek mintáját így is leírhattuk volna:

jaaa

Ugyanez ponttal:

j.{3}

Akkor kapunk illeszkedést, ha „j” betűvel kezdődik és utána három darab akármilyen karakter. Itt már több értelme van a többszörözőnek.

{n,}

Ha a szám után veszőt teszünk, akkor minimum szabályként viselkedik az illesztésünk.

j.{3,}

A fenti példában a „j” után bármi szerepelhet, de minimum három kell legyen belőle. Illeszkedést kapunk „jaaa”, „jaaaa”, „jzgi”, „jzgizzszs”, „j343843434”, „j323”, „j+-+”, stb. szavakra. De „j32” már nem illeszkedik.

{n,m}

A vessző után megadhatunk egy felső határt is:

j.{3,5}

Így akkor kapunk illeszkedést, ha „j” után három, négy vagy öt bármilyen karakter szerepel.

[..]

Eddig megismertük a pont „.” illesztést, amely bármilyen karakterre illeszkedik, tanultunk hozzá többszörözőket.

A következőkben szűkítjük azon karakterek számát, amelyre illeszkedést szeretnénk. Legyen például egy feladat, hogy csak akkor szeretnénk illeszkedést, ha csak 0 és 10 közötti számokat tartalmaz egy változó. Ennek megfelelő minta:

[0-9]

Egy darab karakter fogadunk el, amely 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 számok lehetnek.

Próbáljuk ki egy programban:

String word = "0";
System.out.println(word.matches("[0-9]"));

Adjunk meg a „0” helyén más számokat, de csak 0-tól 9-ig.

Most próbáljuk meg két, három jegyű számokkal:

String word = "00";
System.out.println(word.matches("[0-9]"));

Ebben az esetben nem kapunk illeszkedést.

A szögletes zárójelek mindig egy, és csak egy karakterre vonatkoznak. Természetesen itt is használhatunk többszörözőket. Ha bármekkora számot el szeretnénk fogadni, akkor:

[0-9]*

Ez az illesztés, elfogad bármekkora számjegyű számot, de ha üres akkor is illeszkedik.

Három számjegy megkövetelése:

[0-9]{3}

A „0” és a „9” megadásával tehát egy intervallumot adunk meg, azaz 0-től – 9-ig számjegyek. Az intervallum lehet persze kisebb is. Például:

[0-5]

Ekkor már 6, 7 stb. számokat nem fogadjuk el.

A számok megadhatók szimplán felsorolva is:

[123]

Ekkor csak 1-est, 2-est vagy 3-ast fogadunk el. Esetlege így:

[12389]

A sorrend természetesen mindegy. A kapcsos zárójelek közé írt karakterek között vagy kapcsolat van.

A betűk karakterosztályának meghatározása:

[a-z]

A fenti jelölés csak az angol ábécé kisbetűire vonatkozik. Illeszkedik az „a” betűre, de nem illeszkedik az „á” betűre.

Természetesen felsorolhatjuk a magyar ékezeteseket:

[a-záéíóúöüőű]

Nagybetűk leírása:

[A-Z]

Ékezetesekkel együtt:

[A-ZÁÉÍÓÚÖÜŐŰ]

A fentiek keverhetők:

[a-záéíóúöüőűA-ZÁÉÍÓÚÖÜŐŰ]

Ne felejtsük el, hogy ez csak egyetlen karakterre vonatkozik.

Minden más karakter is kerülhet ide:

[a-z _-+]

A fenti minta illeszkedik az angol ábécé kisbetűire, a szóközre, az alsóvonalra, minusz és plusz karakterekre. A „+” karakter csak szögletes zárójelen belül lehetséges. Azon kívül jelentése van.

[^..]

A „^” karakterrel megfordíthatjuk a szögletes zárójelbe tett karakterek értelmezését.

[^a-z]

A fenti minta akkor illeszkedik, ha a bemenet nem az angol ábécé kisbetűje.

A „^” karaktert a nyitó szögletes zárójel elején kell elhelyezni, mert később normál karakterként van értelmezve.

[a-z^]

A „^” karakter normál karakterként van értelmezve.

[^^a-z]

Így a második „^” már normál karakterként van értelmezve.

( )

Ha korábbi egyik feladatunkra vissza emlékszünk, volt egy olyan, ahol „j” betűvel kezdődhetett egy szöveg és utána bármi. Ez egy többszörzővel értük el:

j.+

Megtudtuk, hogy a többszöröző mindig csak az előtte lévő karakterre vonatkozik. Ezen változtathatunk a csoportosítással:

(j.)+

Ekkor a többszöröző a „j” és az utána következő karakterre is vonatkozik. Illeszkedik „jg”, a „g” helyén más is lehet, de egyszer kell egy ilyennek szerepelnie. Utána csak akkor fogadjuk el, ha két karakter következik és az első megint „j”. Vagyis illeszkedik „jgjd” szavakra, például.

A csoportosítással szoktuk használni a vagy kapcsolatot. Használhatnánk persze így is:

[a-z]|[A-Z]

Java nyelven:

String str = "a";
System.out.println(str.matches("[a-z]|[A-Z]"));

De ezt leírhattuk volna így is:

[a-zA-Z]

Legyen a feladat például a „jel” vagy „ill” kezdetű szavak keresése.

(jel|ill).+

Adott egy info könyvtár, azon belül egy priv nevű könyvtár. Ennek útvonalát megkapjuk valahonnan, feladatunk az lenne, hogy megnézzük vissza-per jellel van-e szeparálva:

info\priv

Ha bekérjük ezt az útvonalat, ha fájlból vagy adatbázisból jön, akkor nincs gond. Ha Java nyelvben karaktersorozat literálisként le szeretném írni, akkor annyi a feladatunk, hogy egy másik visszaperjellel vezetem be:

String dirPath = "info\\priv";

Hiszen eddigi tanulmányaikból tudjuk, hogy a vissza-perjelnek speciális jelentése van, ezért nem írható csak úgy le egy karaktersorozat literálisban.

A szabályos kifejezéseikben is használhatunk visszaperjelet. Ezt szeretnénk, ha például visszaperjelet szeretnénk vizsgálni, mint a példánkban is van. Egy szabályos kifejezésben így vizsgáljuk:

info\\priv

A visszaperjel magában a Java nyelvben is speciális jelentésű. Ennek következménye, hogy ha egy szabályos kifejezésben a fentieket le szeretném írni Java nyelven, akkor azt így kell tennünk:

"info\\\\priv"

Azaz négy darab visszaperjelet kell írnunk, amikor egyetlen egy visszaperjelet vizsgálunk. Képzeljük el, hogy néz ez ki, amikor egy UNC útvonalat vizsgálok, amire példa:

\\server\home

Szabályos kifejezés Java nyelvben:

"\\\\\\\\server\\\\home"

Visszatérve az eredeti példához „info\\priv”, a mi szabályos kifejezésünk csak akkor illeszkedik, ha a visszaperjel előtt az „info” szót, utána pedig a „priv” szót szerepel.

Lássuk a kódunkat:

Program01.java

class Program01
{
	public static void main(String args[])
	{
		String dirPath = "info\\priv";
		System.out.println(dirPath.matches("info\\\\priv"));
 
	}
}

De kipróbálhatjuk bekéréssel is:

Program01.java

import java.util.Scanner;
class Program01
{
	public static void main(String args[])
	{
		Scanner in = new Scanner(System.in);
		System.out.print("Útvonal: ");		
		String dirPath = in.nextLine();
		System.out.println(dirPath.matches("info\\\\priv"));
	}
}

Természetesen a bekért útvonalba csak egy darab visszaperjelet kell beírnunk.

Az eddigi használt matches() metódus mindig teljes egyezést figyel, vagyis a minta eleve illeszkedett a sor elejére és a sor végére is. Ha volt egy „jel” szó és mintának ezt írtam:

jel.*

Akkor ezt azt jelentette, hogy a „jel” szóval kezdődik és utána bármi, de a „jel” szóval kellett kezdődnie.

Ez a minta látszólag másként viselkedik replaceAll() és replaceFirst() metódusok esetén.

Legyen egy szöveg, amelyben cserélni szeretnék bizonyos feltételek teljesülése esetén:

"aajelzés"

Szeretném lecserélni a szövegben a „jel” részt és ami utána van. Hogy a kívánt mintát felismerjük az eddigiek alapján lehet valaki ehhez hasonló mintát írna:

.*jel.*

Csakhogy ez nem jó, mert a két „a” betűt éppen nem szeretném lecserélni. Ehhez akkor kihagyjuk az elejéről a pontot és a csillagot:

jel.*

Ez már jól működik.

String str = "aajelzés";
System.out.println(str.replaceAll("jel.*", "---"));

De mi van akkor ha van egy olyan szövegem amiben „aajelzés” és van egy olyan, amelyben „jelzés” szerepel, és nem szeretném csak akkor lecserélni, ha a jelzés sor elején van. Ha a bemenet „aajelzés”, akkor nem cserélek semmit. Ha a bemenet „jelzés” akkor cserélek. Ekkor lenne jó egy olyan jelölés, ami jelzi, hogy a sor elején várjuk a minta kezdetét:

^jel.*

A „^” karakterrel jelezzük, hogy a sor elejére illesztünk.

String str = "jelzés";
System.out.println(str.replaceAll("^jel.*", "---"));

Előfordul, hogy egy rész akkor szeretnénk cserélni, ha az a sor végén van. Legyen a cserélendő szöveg a „jel”, de csak akkor ha a sor végén szerepel.

String str = "aajelzésaajel";
System.out.println(str.replaceAll("jel$", "---"));

Adott egy UNC útvonal, nézzük meg, hogy szabályos-e:

\\server\gazdasagi

A követelmények:

• Két visszaperjellel kell kezdődnie az UNC útvonalnak.
• A két visszaperjelet bármilyen angol kisbetű követheti, de egy mindenképpen szerepeljen.

Program01.java

class Program01
{
	public static void main(String args[])
	{
		String uncPath = "\\\\server\\gazdasagi";		
		System.out.println(uncPath.matches("\\\\\\\\[a-z]+\\\\[a-z]+"));
	}
}

A replace() metódus karaktersorozatok illeszkedését vizsgálja, míg a replaceAll() szabályos kifejezések alapján cserél.

String s = "alma";
System.out.println(s.replace("[a]", "-")); //Kimenet: alma
System.out.println(s.replaceAll("[a]", "-")); //Kimenet: -lm-

String s = "[a]lma";
System.out.println(s.replace("[a]", "-")); //Kimenet: -lma
System.out.println(s.replaceAll("[a]", "-")); //Kimenet: [-]lm-

A szabályos kifejezések használatához van egy külön osztályunk is:

• java.util.regex.Pattern

A következőkben ennek használatára találunk néhány mintát.

boolean a = Pattern.matches("\\w", "a");
System.out.println(a);

Program01.java

import java.util.regex.Pattern;
class Program01
{
	public static void main(String args[])
	{
		String str = "abc";		
		System.out.println(Pattern.matches("ab.", str));
	}
}

Program.java

import java.util.regex.*;
 
class Program
{
	public static void main(String args[])
	{
		Pattern minta = Pattern.compile("^a.*");
		Matcher illeszto = minta.matcher("alma");
		boolean egyezik = illeszto.matches();
 
		System.out.println(egyezik);
	}
}

Program.java

import java.util.regex.*;
 
class Program
{
	public static void main(String args[])
	{
		System.out.println(Pattern.compile("^a.*").matcher("alma").matches());
	}
}

Részlet keresése:

import java.util.regex.*;
 
public class ap 
{
    public static void main(String[] args)
    {
 
        String s = "Valami";
 
        Pattern p = Pattern.compile("^Va");
        Matcher m = p.matcher(s);
 
        if (m.find()) 
            System.out.println("Egyezik");
        else
            System.out.println("Nem egyezik");
 
    }
}

Teljes egyezés keresése:

import java.util.regex.*;
 
public class ap2 
{
    public static void main(String[] args)
    {
 
        String s = "Valami";
 
        Pattern p = Pattern.compile("^Va.*");
        Matcher m = p.matcher(s);
 
        if (m.matches()) 
            System.out.println("Egyezik");
        else
            System.out.println("Nem egyezik");
 
    }
}

Ezt a dokumentumot 2014 márciusban teljesen újra írtam, mert előtte csak szedett-vetett gyűjtemény volt. Remélem most hasznosabb iromány vált belőle.