[[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: 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? ==== * 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. 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 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 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 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: 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: 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 ==== 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: 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: 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: * 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 === 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| |\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| |X|Y| 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, 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: * 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); import java.util.regex.Pattern; class Program01 { public static void main(String args[]) { String str = "abc"; System.out.println(Pattern.matches("ab.", str)); } } 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); } } 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.