Tartalomjegyzék

< Java

Regex

Bevezetés

Regex

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 1) és a PCRE 2).

Egyenlő

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.

Hol használjuk?

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.

Illeszkedés egy karakterre

Keresztrejtvényes felvetés

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.

Megoldás

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:

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:

Többszörözők

Felvetés

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 "*" megoldás

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ő

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ő

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.

Pontos darabszámra illesztés

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.

Minimum meghatározása

{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.

Felsőhatár

{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.

Karakterosztályok

Jelölés

[..]

Számok

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.

Betűk

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.

Kizárás

[^..]

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.

Csoportosítás

Jelölés

( )

Csoport

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.

Vagy

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).+

Illesztés speciális karakterekre

Felvetés visszaperjelre

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.

Megoldás

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.

Illeszkedés sorhatárra

Csere

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.

Illeszkedés a sor elejére

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.*", "---"));

Illeszkedés a sor végére

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$", "---"));

Feladatok

Feladat 001

Felvetés

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

\\server\gazdasagi

A követelmények:

Megoldás

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

Függelék

Karakterek

x Az x karakter
\ \ A backslash karakter
\0n A karakter oktális értékkel 0n (0 <= n < 7)
\0nn A karakter oktális értékkel 0nn (0 <= n <= 7)
\0mnn A karakter oktális értékkel 0mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh A karakter hexadecimális értékkel 0xhh
\uhhhh A karakter hexadecimális értékkel 0xhhhh
\t A tabulátor karakter ('\u0009')
\n Az új sor (line feed) karakter ('\u000A')
\r A kocsi vissza (carriage-return) karakter ('\u000D')
\f A lapdobás (form-feed) karakter ('\u000C')
\a Figyelmeztető jelzés (bell) karakter ('\u0007')
\e Az escape karakter ('\u001B')
\cx A kontroll karakter, amely hasonlít az x-hez

Karakter osztályok

[abc] a, b, vagy c (egyszerű osztály)
[^abc] Karakterek az a, b, vagy c kivételével (negálás)
[a-zA-Z] a-tól – z-ig vagy A-tól – Z-ig bezárólag (tartomány)
[a-d[m-p]] a-tól – d-ig, vagy m-től – p-ig : [a-dm-p] (unió)
[a-z&&[def]] d, e, vagy f (metszet)
[a-z&&[^bc]] a-tól – z-ig, kivéve a b és c: [ad-z] (kivonás)
[a-z&&[^m-p]] a-tól – z-ig, és ami nem m-től – p-ig: [a-lq-z](kivonás)

Előre definiált karakterosztályok

.bármely karakter (ez lehet sortörés vagy nem sortörés)
\d Egy szám: [0-9]
\D Egy nem szám: [^0-9]
\s Egy whitespace karakter: [ \t\n\x0B\f\r]
\S Egy nem whitespace karakter: [^\s]
\w Egy szó karakter: [a-zA-Z_0-9]
\W Egy nem szó karakter: [^ \w]

POSIX karakter osztályok (csak US-ASCII)

\p{Lower}Egy kisbetűs betű karakter: [a-z]
\p{Upper}Egy nagybetűs betűkarakter:[A-Z]
\p{ASCII}Minden ASCII:[\x00-\x7F]
\p{Alpha}Egy betűkarakter:[\p{Lower}\p{Upper}]
\p{Digit}Egy decimális szám: [0-9]
\p{Alnum}Egy betű vagy szám karakter:[\p{Alpha}\p{Digit}]
\p{Punct}Írásjel: Egy a következők közzül: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}Egy látható karakter: [\p{Alnum}\p{Punct}]
\p{Print}Egy nyomtatható karakter: [\p{Graph}]
\p{Blank}Egy szóköz vagy egy tabulátor: [ \t]
\p{Cntrl}Egy kontrollkarakter: [\x00-\x1F\x7F]
\p{XDigit}Egy hexadecimális szám: [0-9a-fA-F]
\p{Space}Egy whitespace karakter: [ \t \n \x0B \f \r]

Osztályok unicode blokokk és kategóriák számára

\p{InGreek} Egy karakter a görög betűkből
\p{Lu} Egy nagybetű (egyszerű kategória)
\p{Sc} Egy pénznem szimbólum
\P{InGreek} Egy karakter amely nem görög betű (negáció)
[\p{L}&&[^\p{Lu}]] Egy betű amelyik nem nagy betű (kivonás)

Határoló egyezések

^A sor eleje
$A sor vége
\bszóhatár
\BNem szóhatár
\AA bevitel eleje
\GAz előző egyezés vége
\ZA bevitel vége, de az utolsó befejezés számára, ha van
\zA bevitel vége

Nagyobb mennyiségek jelzése

X?X egyszer vagy egyszer sem
X*X, 0-szor vagy többször
X+X, egyszer vagy többször
X{n}X, pontosan n-szer
X{n,}X, kevesebb mint n-szer
X{n,m}X, kevesebb mint n, de nem több mint m

Kevesebb mennyiségek

X?? X, egyszer vagy egyszer sem
X*? X, 0 vagy többször
X+? X, 1 vagy többször
X{n}? X, pontosan n-szer
X{n,}? X, legkevesebb n-szer
X{n,m}? X, legkevesebb n-szer, de nem több mint m

Birtokos mennyiségek

X?+X, egyszer vagy egyszersem
X*+X, 0-szor vagy többször
X++X, egyszer vagy többször
X{n}+X, pontosan egyszer
X{n,}+X, kevesebb mint n-szer
X{n,m}+X, kevesebb mint n-szer de nem több mint m

Logikai operátorok

XY X-et követő Y
X|Y X vagy Y közül bármelyik
(X) X, mint egy elfogott csoport

Vissza hivatkozás

\nBármi az n-dik elfogott egyező csoport

Mennyiségek

\Semmi, de hivatkozik a következő karakterre
\QSemmi, de hivatkozik minden ezt követő karakterre \E
\ESemmi, de az indulás végére hivatkozik \Q

Speciális szerkezetek (nem elfogott)

(?:X)X, mint egy nem elfogott csoport
(?idmsux-idmsux)Semmi, de az egyezésjelzőt on - off állítja
(?idmsux-idmsux:X)X, mint egy nem elfogott csoport on - off jelzővel
(?=X)X, 0 szélességű pozitív feltételezés
(?!X)X, 0 szélességű pozitív feltételezés
(?⇐X)X, 0 szélességű pozitív feltételezés
(?<!X)X, 0 szélességű pozitív feltételezés
(?>X)X, Mint egy független nem elfogott csoport

A replace és a replaceAll

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-

Pattern osztály minták

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

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");
 
    }
}

Utószó

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.

1)
Unix rendszerek szabványleírása.
2)
A Perl nyelvbe épített mintaillesztési lehetőségre utal.