Reguliere Expressie in Java – Voorbeeld van Java Regex

Welkom bij Regelmatige Expressies in Java. Het wordt ook Regex genoemd in Java. Toen ik begon met programmeren, was java reguliere expressie een nachtmerrie voor mij. Deze tutorial is bedoeld om je te helpen Regelmatige Expressies in Java onder de knie te krijgen. Ik zal hier ook terugkomen om mijn kennis van Java Regex op te frissen.

Reguliere Expressie in Java

De reguliere expressie in Java definieert een patroon voor een tekenreeks. Een reguliere expressie kan worden gebruikt om tekst te zoeken, bewerken of manipuleren. Een reguliere expressie is niet taalspecifiek, maar ze verschillen enigszins voor elke taal. De reguliere expressie in Java lijkt het meest op Perl. Java Regex-klassen bevinden zich in het pakket java.util.regex dat drie klassen bevat:

1. Patroon: Het Patroon-object is de gecompileerde versie van de reguliere expressie. De klasse Patroon heeft geen openbare constructor, en we gebruiken de openbare statische methode compile om het patroonobject te maken door het argument van de reguliere expressie door te geven.
2. Matcher: Matcher is het Java regex engine object dat het invoer String patroon matcht met het aangemaakte patroon object. De Matcher-klasse heeft geen openbare constructor en we krijgen een Matcher-object met behulp van de pattern-methode die het invoer String-argument gebruikt. We gebruiken vervolgens de matches-methode die een boolean resultaat retourneert op basis van of de invoer String overeenkomt met het regex-patroon of niet.
3. PatternSyntaxException: PatternSyntaxException wordt gegenereerd als de syntaxis van de reguliere expressie niet correct is.

Laten we eens kijken naar een voorbeeldprogramma van Java Regex.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// slechte reguliere expressie
		pattern = Pattern.compile("*xx*");

	}

}

Wanneer we dit Java regex-voorbeeldprogramma uitvoeren, krijgen we de onderstaande uitvoer.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

Omdat Java reguliere expressies draaien om String, is de String-klasse uitgebreid in Java 1.4 om een matches-methode te bieden die regex-patroonmatching uitvoert. Intern gebruikt het Pattern- en Matcher-klassen van Java regex om de verwerking uit te voeren, maar het vermindert duidelijk de coderegels. De Pattern-klasse bevat ook een matches-methode die regex en invoer String als argumenten gebruikt en een boolean resultaat retourneert na het matchen ervan. Dus onderstaande code werkt prima voor het matchen van invoer String met een reguliere expressie in Java.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

Dus, als uw vereiste alleen is om te controleren of de invoerreeks overeenkomt met het patroon, zou u tijd en regels code kunnen besparen door de eenvoudige methode voor het matchen van teksten te gebruiken. U moet Pattern- en Matches-klassen alleen gebruiken als u de invoerreeks moet manipuleren of als u het patroon opnieuw moet gebruiken. Merk op dat het patroon gedefinieerd door regex wordt toegepast op de tekenreeks van links naar rechts, en zodra een bronkarakter in een overeenkomst wordt gebruikt, kan het niet opnieuw worden gebruikt. Bijvoorbeeld, regex “121” zal slechts twee keer overeenkomen met “31212142121” als “_121____121”.

Reguliere expressie in Java – veelvoorkomende overeenkomende symbolen

Java Regex Metakarakters

We hebben enkele metakarakters in Java regex, het zijn als shortcodes voor veelvoorkomende overeenkomstpatronen.

Er zijn twee manieren om metakarakters als gewone tekens in reguliere expressies te gebruiken.

1. Plaats het metakarakter vooraf met een backslash (\).
2. Houd het metakarakter binnen \Q (dat begint met citeren) en \E (dat eindigt).

Reguliere Expressie in Java – Kwantificeerders

Java Regex Kwantificeerders geven het aantal voorkomens van een karakter aan om mee te matchen.

Java Regex Kwantificeerders kunnen ook worden gebruikt met karakterklassen en vastleggende groepen. Bijvoorbeeld, [abc]+ betekent – a, b, of c – een of meer keren. (abc)+ betekent de groep “abc” een of meer keren. We zullen nu praten over Vastleggende Groep.

Reguliere Expressie in Java – Vastleggende Groepen

Reguliere Expressie in Java Vastleggende groepen worden gebruikt om meerdere tekens als een enkele eenheid te behandelen. Je kunt een groep maken met behulp van (). Het gedeelte van de invoerstring dat overeenkomt met de vastleggende groep, wordt opgeslagen in het geheugen en kan worden opgeroepen met behulp van Terugverwijzing. Je kunt de methode matcher.groupCount gebruiken om het aantal vastleggende groepen in een Java regex-patroon te achterhalen. Bijvoorbeeld, ((a)(bc)) bevat 3 vastleggende groepen – ((a)(bc)), (a) en (bc). Je kunt Terugverwijzing in de reguliere expressie gebruiken met een schuine streep (\) en vervolgens het nummer van de groep die moet worden opgeroepen. Vastleggende groepen en Terugverwijzingen kunnen verwarrend zijn, dus laten we dit begrijpen aan de hand van een voorbeeld.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

In het eerste voorbeeld, bij runtime is de eerste vastleggroep (\w\d) die evalueert naar “a2” wanneer gematcht met de invoerreeks “a2a2” en opgeslagen in het geheugen. Dus \1 verwijst naar “a2” en retourneert daarom waar. Vanwege dezelfde reden geeft de tweede verklaring vals terug. Probeer dit scenario te begrijpen voor verklaring 3 en 4 zelf. 🙂 Nu zullen we kijken naar enkele belangrijke methoden van de Pattern- en Matcher-klassen.

1. We kunnen een Pattern-object maken met vlaggen. Bijvoorbeeld Pattern.CASE_INSENSITIVE maakt hoofdletteronafhankelijk matchen mogelijk.
2. De Pattern-klasse biedt ook de split(String)-methode die vergelijkbaar is met de split()-methode van de String-klasse.
3. De toString()-methode van de Pattern-klasse retourneert de reguliere expressie-string waaruit dit patroon is gecompileerd.
4. Matcher-klassen hebben start()– en end()-indexmethoden die precies laten zien waar de overeenkomst werd gevonden in de invoerreeks.
5. De Matcher-klasse biedt ook methoden voor het manipuleren van strings replaceAll(String vervanging) en replaceFirst(String vervanging).

Laten we deze Java regex-methoden bekijken in een eenvoudig voorbeeldprogramma.

package com.journaldev.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexExamples {

	public static void main(String[] args) {
		// met patroon met vlaggen
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// met Matcher find(), group(), start() en end() methoden
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// met Pattern split() methode
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// met Matcher.replaceFirst() en replaceAll() methoden
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

De uitvoer van het bovenstaande Java-regex-voorbeeldprogramma is.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

Dat is alles voor reguliere expressies in Java. Java Regex lijkt in het begin moeilijk, maar als je er een tijdje mee werkt, is het gemakkelijk te leren en te gebruiken.

Je kunt de volledige code en meer voorbeelden van reguliere expressies bekijken op onze GitHub Repository.