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

Автор оригинала: Pankaj Kumar.

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

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

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

Классы регулярных выражений Java присутствуют в java.util.regex пакете, содержащем три класса:

1. Шаблон : Шаблон объект – это скомпилированная версия регулярного выражения. Класс шаблона не имеет открытого конструктора, и мы используем его общедоступный статический метод compile для создания объекта шаблона путем передачи аргумента регулярного выражения.
2. Сопоставитель : Сопоставитель – это объект механизма регулярных выражений java, который сопоставляет шаблон входной строки с созданным объектом шаблона. Класс Matcher не имеет открытого конструктора, и мы получаем объект Matcher, используя метод pattern object matcher , который принимает входную строку в качестве аргумента. Затем мы используем метод matches , который возвращает логический результат на основе входной строки, соответствующей шаблону регулярного выражения или нет.
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());
		// bad regular expression
		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 , который выполняет сопоставление шаблонов регулярных выражений. Внутренне он использует классы регулярных выражений Pattern и Matcher java для обработки, но, очевидно, это уменьшает количество строк кода.

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

Поэтому приведенный ниже код отлично подходит для сопоставления входной строки с регулярным выражением в 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 и Matches только тогда, когда вам нужно манипулировать входной строкой или вам нужно повторно использовать шаблон.

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

Например, регулярное выражение “121” будет соответствовать “31212142121” только в два раза “_121____121”.

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

Метасимволы регулярных выражений Java

У нас есть некоторые мета-символы в регулярных выражениях Java, это похоже на короткие коды для общих шаблонов сопоставления.

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

1. Перед метасимволом ставьте обратную косую черту (\).
2. Держите метасимвол в пределах \Q (с которого начинается цитата) и \E (которым она заканчивается).

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

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

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

Например, [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), которая оценивается как “a 2” при сопоставлении с входной строкой “a2 a2” и сохраняется в памяти. Таким образом, \1 относится к “a2” и, следовательно, возвращает значение true. По той же причине второе утверждение выводит false.

Попробуйте сами понять этот сценарий для утверждений 3 и 4. 🙂

Теперь мы рассмотрим некоторые важные методы классов шаблонов и сопоставителей.

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

Давайте рассмотрим эти методы регулярных выражений java в простом примере программы.

package com.journaldev.util;

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

public class RegexExamples {

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

		// using Pattern split() method
		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);
		}

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

}

Вывод приведенного выше примера регулярного выражения java является.

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 поначалу кажутся сложными, но если вы работаете с ними в течение некоторого времени, их легко изучать и использовать.