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

Регулярные выражения определяют шаблоны строк.

Регулярные выражения можно использовать для поиска, редактирования или манипулирования текстом.

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

Регулярные выражения Java наиболее похожи на выражения Perl.

Пакет java.util.regex в основном включает следующие три класса:

• Класс шаблона:

  Объект шаблона представляет собой скомпилированное представление регулярного выражения. Класс шаблона не имеет открытого конструктора. Чтобы создать объект Pattern, вы должны сначала вызвать его общедоступный статический метод компиляции, который возвращает объект Pattern. Этот метод принимает регулярное выражение в качестве первого параметра.

• Класс сопоставителя:

  Объект Matcher — это механизм, который интерпретирует и сопоставляет входные строки. Как и класс Pattern, Matcher не имеет открытого конструктора. Вам необходимо вызвать метод сопоставления объекта Pattern, чтобы получить объект Matcher.

• ПаттерсинтаксИсключение:

  PatternSyntaxException — это необязательный класс исключений, который представляет синтаксическую ошибку в шаблоне регулярного выражения.

Группа захвата

Группы захвата — это способ рассматривать несколько символов как единое целое, создаваемое путем группировки символов в круглых скобках.

Например, регулярное выражение (собака) создает одну группу, содержащую «d», «o» и «g».

Группы захвата нумеруются путем подсчета открывающих скобок слева направо. Например, в выражении ((A)(B(C))) таких групп четыре:

• ((А)(В(С)))

• (А)

• (Б(С))

• (С)

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

Существует также специальная группа (группа 0), которая всегда представляет все выражение. Группа не включается в возвращаемое значение groupCount.

Пример

В следующем примере показано, как найти строку цифр из заданной строки:

 импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;

открытый класс RegexMatches
{
public static void main( String args[] ){

// Поиск строки по заданному шаблону String line = "Этот ордер был установлен на QT3000! ОК?";
Строковый шаблон = "(.*)(\d+)(.*)";

//Создаем объект Pattern Pattern r = Pattern.compile(pattern);

// Теперь создаем объект сопоставления Matcher m = r.matcher(line);
если (m.find( )) {
System.out.println("Найдено значение: " + m.group(0) );
System.out.println("Найдено значение: " + m.group(1) );
System.out.println("Найдено значение: " + m.group(2) );
} еще {
System.out.println("НЕТ СОВПАДЕНИЯ");
}
}
}

Результаты компиляции и запуска приведенного выше примера следующие:

 Найдено значение: Этот заказ был размещен на QT3000. Хорошо?
Найдено значение: Этот заказ был размещен на QT300.
Найдено значение: 0

Синтаксис регулярных выражений

Методы класса Matcher

Индексный метод

Метод index предоставляет полезные значения индекса, которые точно указывают, где во входной строке найдено совпадение:

методы исследования

Метод исследования проверяет входную строку и возвращает логическое значение, указывающее, был ли найден шаблон:

метод замены

Метод замены — это метод замены текста во входной строке:

методы начала и конца

Вот пример подсчета количества вхождений слова «кот» во входную строку:

 импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;

открытый класс RegexMatches
{
частная статическая окончательная строка REGEX = "\bcat\b";
частная статическая окончательная строка INPUT =
«кошка, кошка, кошка, кошка, кошка»;

public static void main( String args[] ){
Шаблон p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // Получаем объект сопоставления int count = 0;

в то время как (m.find()) {
считать++;
System.out.println("Номер совпадения "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}

Результаты компиляции и запуска приведенного выше примера следующие:

 Матч №1
старт(): 0
конец(): 3
Матч №2
старт(): 4
конец(): 7
Матч №3
старт(): 8
конец(): 11
Матч №4
старт(): 19
конец(): 22

Вы можете видеть, что в этом примере используются границы слов, чтобы гарантировать, что буквы «c», «a», «t» не являются просто подстрокой более длинного слова. Он также предоставляет некоторую полезную информацию о том, где во входной строке произошло совпадение.

Метод start возвращает начальный индекс подпоследовательности, захваченной данной группой во время предыдущей операции сопоставления, а метод end добавляет единицу к индексу последнего совпавшего символа.

методы совпадений и просмотра

Методы match и LookingAt используются для попытки сопоставить шаблон входной последовательности. Разница между ними в том, что для match требуется совпадение всей последовательности, а для LookingAt этого не требуется.

Эти два метода часто используются в начале входной строки.

Для объяснения этой функции мы используем следующий пример:

 импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;

открытый класс RegexMatches
{
частная статическая окончательная строка REGEX = "foo";
частная статическая окончательная строка INPUT = "фуооооооооооо";
частный статический шаблон шаблона;
частный статический сопоставитель Matcher;

public static void main( String args[] ){
шаблон = Pattern.compile(REGEX);
сопоставитель = шаблон.сопоставитель(ВХОД);

System.out.println("Текущее REGEX: "+REGEX);
System.out.println("Текущий ВХОД: "+ВХОД);

System.out.println(" LookingAt(): "+matcher. LookingAt());
System.out.println("matches(): "+matcher.matches());
}
}

Результаты компиляции и запуска приведенного выше примера следующие:

 Текущее REGEX: foo
Текущий ВХОД: фууууууууууууу
смотряАт(): правда
совпадения(): ложь

Методы replaceFirst и replaceAll

Методы replaceFirst и replaceAll используются для замены текста, соответствующего регулярному выражению. Разница в том, что replaceFirst заменяет первое совпадение, а replaceAll заменяет все совпадения.

Следующий пример объясняет эту функциональность:

 импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;

открытый класс RegexMatches
{
частная статическая строка REGEX = «собака»;
Private static String INPUT = "Собака говорит мяу." +
«Все собаки говорят мяу»;
частная статическая строка REPLACE = "кот";

public static void main(String[] args) {
Шаблон p = Pattern.compile(REGEX);
// получаем объект сопоставления
Сопоставитель m = p.matcher(INPUT);
ВВОД = m.replaceAll(ЗАМЕНИТЬ);
System.out.println(ВХОД);
}
}

Результаты компиляции и запуска приведенного выше примера следующие:

 Кот говорит мяу. Все кошки говорят мяу.

Методы AppendReplacement и AppendTail.

Класс Matcher также предоставляет методы AppendReplacement и AppendTail для замены текста:

Посмотрите на следующий пример, чтобы объяснить эту функциональность:

 импортировать java.util.regex.Matcher;
импортировать java.util.regex.Pattern;

открытый класс RegexMatches
{
частная статическая строка REGEX = "a*b";
частная статическая строка INPUT = "aabfooaabfooabfoob";
частная статическая строка REPLACE = "-";
public static void main(String[] args) {
Шаблон p = Pattern.compile(REGEX);
// Получаем объект сопоставления Matcher m = p.matcher(INPUT);
StringBuffer sb = новый StringBuffer();
в то время как (m.find()) {
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

Результаты компиляции и запуска приведенного выше примера следующие:

 -фу-фу-фу-

Методы класса PatternSyntaxException

PatternSyntaxException — это непринудительный класс исключений, который указывает на синтаксическую ошибку в шаблоне регулярного выражения.

Класс PatternSyntaxException предоставляет следующие методы, которые помогут нам увидеть, какие ошибки произошли.