Регулярные выражения в Java – Пример Java Regex

Добро пожаловать в регулярные выражения в Java. Их также называют Regex в Java. Когда я начал программировать, регулярные выражения в Java казались для меня кошмаром. Этот учебник призван помочь вам освоить регулярные выражения в Java. Я также вернусь сюда, чтобы освежить свои знания по Java Regex.

Регулярные выражения в Java

Регулярное выражение в Java определяет шаблон для строки. Регулярные выражения можно использовать для поиска, редактирования или манипулирования текстом. Регулярное выражение не зависит от языка, но они немного различаются для каждого языка. Регулярные выражения в Java наиболее похожи на Perl. Классы Java Regex находятся в пакете java.util.regex и содержат три класса:

1. Pattern: Объект Pattern – это скомпилированная версия регулярного выражения. У класса Pattern нет открытого конструктора, и мы используем его открытый статический метод compile для создания объекта шаблона, передавая аргумент регулярного выражения.
2. Matcher: Matcher – объект движка Java Regex, который сопоставляет входную строку с созданным объектом шаблона. У класса Matcher нет общедоступного конструктора, и мы получаем объект Matcher, используя метод matcher объекта шаблона, который принимает входную строку в качестве аргумента. Затем мы используем метод matches, который возвращает логический результат в зависимости от того, соответствует ли входная строка шаблону regex или нет.
3. PatternSyntaxException: PatternSyntaxException выбрасывается, если синтаксис регулярного выражения неверен.

Давайте рассмотрим пример программы на языке Java с использованием регулярных выражений.

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());
		// неверное регулярное выражение
		pattern = Pattern.compile("*xx*");

	}

}

При запуске этой программы на языке Java с регулярными выражениями мы получим следующий вывод.

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)

Поскольку регулярные выражения Java связаны со строками, класс String был расширен в Java 1.4 для предоставления метода matches, выполняющего сопоставление шаблона regex. Внутренне он использует классы регулярных выражений Java Pattern и Matcher для обработки, но, очевидно, уменьшает количество строк кода. Класс Pattern также содержит метод matches, который принимает регулярное выражение и входную строку в качестве аргументов и возвращает логический результат после их сопоставления. Так что нижеприведенный код отлично подходит для сопоставления входной строки с регулярным выражением в 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));

Если ваше требование заключается всего лишь в проверке соответствия входной строки шаблону, вам стоит экономить время и строки кода, используя простой метод сравнения строк. Классы Pattern и Matcher следует использовать только тогда, когда необходимо манипулировать входной строкой или переиспользовать шаблон. Обратите внимание, что шаблон, определенный с использованием регулярных выражений, применяется к строке слева направо, и после использования символа источника в совпадении он не может быть повторно использован. Например, регулярное выражение “121” совпадет с “31212142121” только дважды, как “_121____121”.

Регулярные выражения в Java – общие символы сопоставления

Метасимволы Java Regex

В Java есть несколько метасимволов для обозначения общих шаблонов сопоставления.

Есть два способа использования метасимволов как обычных символов в регулярных выражениях.

1. Предварите метасимвол обратной косой чертой (\).
2. Разместите метасимвол внутри \Q (начало цитаты) и \E (окончание).

Регулярные выражения в Java – Квантификаторы

Квантификаторы Java Regex указывают количество вхождений символа для сопоставления.

Квантификаторы Java Regex могут использоваться также с символьными классами и захватывающими группами. Например, [abc]+ означает – a, b или c – один или более раз. (abc)+ означает группу “abc” один или более раз. Сейчас мы обсудим Группу захвата.

Регулярные выражения в Java – Группы захвата

В Java группы захвата регулярных выражений используются для обработки нескольких символов как единого блока. Вы можете создать группу, используя (). Часть строки ввода, которая соответствует группе захвата, сохраняется в памяти и может быть вызвана с использованием Обратная ссылка. Метод matcher.groupCount можно использовать для определения количества групп захвата в шаблоне регулярного выражения Java. Например, ((a)(bc)) содержит 3 группы захвата – ((a)(bc)), (a) и (bc). Вы можете использовать Обратную ссылку в регулярном выражении с обратным слешем (\), а затем номером группы для вызова в память. Группы захвата и обратные ссылки могут вызывать путаницу, давайте разберем это на примере.

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

В первом примере, при выполнении первой группы захвата (\w\d) получается “a2”, когда совпадает с входной строкой “a2a2” и сохраняется в памяти. Таким образом, \1 ссылается на “a2”, и поэтому возвращает true. По той же причине второе утверждение выводит false. Попробуйте понять этот сценарий для утверждений 3 и 4 сами. 🙂 Теперь мы рассмотрим некоторые важные методы классов Pattern и Matcher.

1. Мы можем создать объект Pattern с флагами. Например, Pattern.CASE_INSENSITIVE включает нечувствительное к регистру сопоставление.
2. Класс Pattern также предоставляет метод split(String), который аналогичен методу split() класса String.
3. Метод toString() класса Pattern возвращает строку регулярного выражения, из которого был скомпилирован этот шаблон.
4. У классов Matcher есть методы индекса start() и end(), которые показывают точное место совпадения во входной строке.
5. Класс Matcher также предоставляет методы манипулирования строкой replaceAll(String replacement) и replaceFirst(String replacement).

Давайте рассмотрим эти методы java regex в простом примере программы.

package com.journaldev.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		// использование шаблона с флагами
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// использование методов find(), group(), start() и end() Matcher
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// использование метода split() Pattern
		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);
		}

		// использование методов replaceFirst() и replaceAll() Matcher
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

Вывод примера программы java regex приведен выше.

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

Всё, что касается регулярных выражений в Java. Регулярные выражения в Java кажутся сложными сначала, но если вы поработаете с ними некоторое время, их легко освоить и использовать.

Вы можете ознакомиться с полным кодом и другими примерами регулярных выражений в нашем репозитории GitHub.