szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:programozás:java|< Java]]
====== Regex ======

  * **Szerző:** Sallai András
  * Copyright (c) 2011, Sallai András
  * Szerkesztve: 2011, 2013, 2014
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu
===== 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 ((Unix rendszerek szabványleírása.)) és a PCRE ((A Perl nyelvbe épített mintaillesztési lehetőségre utal.)).
==== Egyenlő ====


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

Megvalósítás:
<code java Program.java>
class Program
{
	public static void main(String args[])
	{
		String str = "abc";
                boolean a = str.matches("abc"); 	
		System.out.println(a);
	}
}
</code>
Ez persze semmiben nem különbözik attól, mintha equals() metódust használtam volna.
==== Hol használjuk? ====

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





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

<code java>
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"};
</code>

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.

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

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:
<code java>
for(int i=0;i<szavak.length;i++){
	if(szavak[i].matches("jele.")){
		System.out.println(szavak[i]);
	}
}
</code>

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:

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

Ekkor eggyel több szót kapunk eredményül:
  * jeles
  * jelen
  * jelöl

===== Többszörözők =====

==== Felvetés ====

Vegyük újra az előző szógyűjteményünket:
<code java>
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"};
</code>

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:

<code java>
String word = "játék";
System.out.println(word.matches("j.*"));
</code>


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

<code java 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);
	}
}
</code>

==== 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:
<code java>
String word = "0";
System.out.println(word.matches("[0-9]"));
</code>
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:
<code java>
String word = "00";
System.out.println(word.matches("[0-9]"));
</code>
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:
<code java>
String str = "a";
System.out.println(str.matches("[a-z]|[A-Z]"));
</code>

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:
<code java Program01.java>
class Program01
{
	public static void main(String args[])
	{
		String dirPath = "info\\priv";
		System.out.println(dirPath.matches("info\\\\priv"));

	}
}
</code>

De kipróbálhatjuk bekéréssel is:
<code java 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"));
	}
}
</code>

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.
<code java>
String str = "aajelzés";
System.out.println(str.replaceAll("jel.*", "---"));
</code>

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.

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

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

<code java>
String str = "aajelzésaajel";
System.out.println(str.replaceAll("jel$", "---"));
</code>


===== Feladatok =====

==== Feladat 001 ====
=== Felvetés ===

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.

=== Megoldás ===

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


===== Függelék =====

==== Karakterek ====
| x | Az x karakter |
| \ \ |A backslash karakter|
| \0n | A karakter oktális értékkel 0n <nowiki>(0 <= n <  7)</nowiki> |
| \0nn | A karakter oktális értékkel 0nn <nowiki> (0 <= n <=  7)</nowiki> |
| \0mnn | A karakter oktális értékkel 0mnn <nowiki>(0 <= m <= 3, 0 <= n <= 7)</nowiki> |
| \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) |
|<nowiki> [^abc] </nowiki> | 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) |
| <nowiki> [a-z&&[^bc]] </nowiki> | a-tól -- z-ig, kivéve a b és c: [ad-z] (kivonás) |
| <nowiki> [a-z&&[^m-p]] </nowiki> | a-tól -- z-ig, és ami nem m-től -- p-ig: [a-lq-z](kivonás) |

==== Előre definiált karakterosztályok ====


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


==== 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: <nowiki>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</nowiki>|
|\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ó) |
|<nowiki> [\p{L}&&[^\p{Lu}]]  </nowiki>| Egy betű amelyik nem nagy betű (kivonás) |
 
==== Határoló egyezések ====
|<nowiki>^</nowiki>|A sor eleje|
|$|A sor vége|
|\b|szóhatár|
|\B|Nem szóhatár|
|\A|A bevitel eleje|
|\G|Az előző egyezés vége|
|\Z|A bevitel vége, de az utolsó befejezés számára, ha van|
|\z|A 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|
|<nowiki>X|Y</nowiki>| X vagy Y közül bármelyik|
|(X)| X, mint egy elfogott csoport|
 
==== Vissza hivatkozás ====

|\n|Bármi az n-dik elfogott egyező csoport|

==== Mennyiségek ====

|\|Semmi, de hivatkozik a következő karakterre|
|\Q|Semmi, de hivatkozik minden ezt követő karakterre \E|
|\E|Semmi, 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.

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

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

==== Pattern osztály minták ====

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.

<code java>
boolean a = Pattern.matches("\\w", "a");
System.out.println(a);
</code>

<code java 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));
	}
}
</code>


<code java 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);
	}
}
</code>


<code java Program.java>
import java.util.regex.*;

class Program
{
	public static void main(String args[])
	{
		System.out.println(Pattern.compile("^a.*").matcher("alma").matches());
	}
}
</code>

Részlet keresése:
<code java>
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");

    }
}
</code>

Teljes egyezés keresése:
<code java>
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");
  
    }
}
</code>

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