API регулярных выражений
Следующий набор строк имеет нечто общее:
A string
A longer string
A much longer string
Заметьте, что каждая из этих строк начинается с буквы а и заканчивается словом string. API регулярных выражений Java (см. Ресурсы) помогает выявить такие элементы, увидеть в них общую модель и делать интересные вещи с использованием полученной информации.
API регулярных выражений состоит из трех основных классов, которыми вы будете пользоваться очень часто:
Pattern описывает модель строки.
Matcher проверяет строку на соответствие модели.
PatternSyntaxException указывает на что-то неприемлемое в той модели, которую вы пытаетесь определить.
Скоро мы начнем работать над моделью простых регулярных выражений, которая использует эти классы. Однако сначала рассмотрим синтаксис модели регулярных выражений.
В начало
Синтаксис модели регулярных выражений
Модель регулярных выражений описывает структуру строк, которую выражение пытается обнаружить во входной строке. Регулярные выражения в ней могут выглядеть немного странно. Однако как только вы освоите синтаксис, их станет легче расшифровать. В таблице 2 приведены некоторые наиболее распространенные конструкции регулярных выражений, которые применяются для моделирования строк:
Таблица 2. Распространенные конструкции регулярных выражений
Конструкция Regex Что считается совпадением
. Любой символ
? Ноль (0) или одно (1)повторение предшествующего
* Ноль (0) или более повторений предшествующего
+ Одно (1) или более повторений предшествующего
[] Диапазон символов или цифр
^ Отрицание последующего (то есть, "не что-то")
\d Любая цифра (иначе, [0-9])
\D Любой нецифровой символ (иначе, [^0-9])
\s Любой символ-разделитель (иначе, [\n\t\f\r])
\S Любой символ, отличный от разделителей (иначе, [^\n\t\f\r])
\w Любая буква или цифра (иначе, [A-Za-Z_0-9])
\W Любой знак, отличный от буквы или цифры (иначе, [^\w])
Первые конструкции называются квантификаторами, поскольку они определяют количество того, что им предшествует. Конструкции типа \d - это определенные классы символов. Любой символ, который не имеет специального значения в шаблоне, является буквальным и соответствует самому себе.
Поиск по модели
Вооружившись синтаксисом моделей из таблицы 2, можно выполнить простой пример, приведенный в листинге 19, используя классы API регулярных выражений Java.
Листинг 19. Поиск по модели регулярных выражений
Pattern pattern = Pattern.compile("a.*string");
Matcher matcher = pattern.matcher("a string");
boolean didMatch = matcher.matches();
Logger.getAnonymousLogger().info (didMatch);
int patternStartIndex = matcher.start();
Logger.getAnonymousLogger().info (patternStartIndex);
int patternEndIndex = matcher.end();
Logger.getAnonymousLogger().info (patternEndIndex);
Сначала создается класс Pattern. Это делается с помощью вызова статического метода compile() объекта Pattern со строковым литералом, который представляет собой модель, соответствие которой мы ищем. Этот литерал использует синтаксис модели регулярных выражений. Обычным языком модель, приведенную в данном примере, можно описать следующим образом:
Найти строку вида: буква а, за которой следуют ноль или более символов, а за ними - строка string.
Методы сравнения
Затем в листинге 19 вызывается метод matcher() объекта Pattern. Этот вызов создает экземпляр Matcher. Matcher проверяет переданную ему строку на соответствие модели, использованной при создании объекта Pattern.
Каждая строка на языке Java – это индексированная коллекция символов, начиная с 0-го и заканчивая символом с индексом "длина строки минус единица". Matcher анализирует строку, начиная с 0-го символа, в поисках совпадений с моделью. После завершения этого процесса Matcher содержит информацию о найденных (или не найденных) совпадениях в строке ввода. Доступ к этой информации можно получить, вызывая различные методы Matcher:
matches() сообщает, совпадает ли с моделью вся входная последовательность;
start() указывает значение индекса в строке, с которого начинается совпадение;
end() указывает значение индекса в строке, на котором совпадение заканчивается, плюс единица.
Код, приведенный в листинге 19, находит одно совпадение, с 0-й по 7-ю позицию. Следовательно, вызов matches() возвращает значение true, вызов start() возвращает значение 0, a вызов end() возвращает значение 8.
lookingAt() и matches()
Если бы в строке было больше элементов, чем в модели поиска, вместо matches() можно было бы использовать метод lookingAt(). lookingAt() ищет совпадения подстрок с данной моделью. Например, рассмотрим следующую строку:
Here is a string with more than just the pattern.
Если искать по модели a.*string и использовать lookingAt(), мы получим совпадение. Но метод matches() возвратил бы значение false, так как в строке есть не только то, что указано в модели.
В начало
Сложные модели регулярных выражений
Простой поиск по классам регулярных выражений производить легко, но с API регулярных выражений можно делать и довольно сложные вещи.
Вики, как вы наверняка знаете, это Web-система, которая позволяет пользователям редактировать страницы. Вики почти исключительно основаны на регулярных выражениях. Их содержание зависит строки, введенной пользователем, которая анализируется и форматируется с использованием регулярных выражений. Любой пользователь может дать ссылку на другую тему, введя wiki-слово, которое, как правило, представляет собой последовательности соединенных слов, каждое из которых начинается с прописной буквы, например:
MyWikiWord
Зная это, рассмотрим следующую строку:
Here is a WikiWord followed by AnotherWikiWord, then YetAnotherWikiWord.
В этой строке можно искать вики-слова с помощью модели регулярных выражений:
[A-Z][a-z]*([A-Z][a-z]*)+
И вот код для поиска wiki-слов:
String input = "Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.";
Pattern pattern = Pattern.compile("[A-Z][a-z]*([A-Z][a-z]*)+");
Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
Logger.getAnonymousLogger().info("Found this wiki word: " + matcher.group());
}
Выполнив этот код, вы должны увидеть на консоли три wiki-слова.
Замена строк
Поиск совпадений полезен, но и после того как совпадение найдено со строками можно что-то делать. Одни строки можно заменять другими, как текст в текстовом редакторе. В Matcher есть несколько методов для замены элементов строк:
ReplaceAll() заменяет все совпадения указанной строкой;
replaceFirst() заменяет указанной строкой только первое совпадение.
Использовать методы замены Matcher легко:
String input = "Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.";
Pattern pattern = Pattern.compile("[A-Z][a-z]*([A-Z][a-z]*)+");
Matcher matcher = pattern.matcher(input);
Logger.getAnonymousLogger().info("Before: " + input);
String result = matcher.replaceAll("replacement");
Logger.getAnonymousLogger().info("After: " + result);
Этот код находит wiki-слова, как и прежде. Обнаружив совпадение, Matcher заменяет wiki-слово другим. Выполнив этот код, вы должны увидеть на консоли следующее:
Before: Here is WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is replacement followed by replacement, then replacement.
При использовании replaceFirst() вы бы увидели:
Before: Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is a replacement followed by AnotherWikiWord, then SomeWikiWord.
В начало
Сопоставление групп и манипулирование ими
При поиске совпадений с моделью регулярного выражения можно получить информацию о найденном. Мы видели, как это делается с помощью методов start() и end() объекта Matcher. Но на совпадения можно ссылаться и с помощью групп.
В каждой модели, как правило, создаются группы – для этого отдельные ее части заключаются в круглые скобки. Группы нумеруются слева направо, начиная с 1 (группа 0 соответствует всему совпадению). Код, приведенный в листинге 20, заменяет каждое вики-слово строкой, которая "обертывает" слово:
Листинг 20. Совпадение групп
String input = "Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.";
Pattern pattern = Pattern.compile("[A-Z][a-z]*([A-Z][a-z]*)+");
Matcher matcher = pattern.matcher(input);
Logger.getAnonymousLogger().info("Before: " + input);
String result = matcher.replaceAll("blah$0blah");
Logger.getAnonymousLogger().info("After: " + result);
Выполнив этот код, вы получите следующий результат:
Before: Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is a blahWikiWordblah followed by blahAnotherWikiWordblah,
then blahSomeWikiWordblah.
Другой подход к совпадению групп
В листинге 20 делается ссылка на все совпадение путем включения в строку замены $0. Любая часть заменяющей строки вида $int относится к группе, указанной целым числом (так, $1 указывает на группу 1 и т.п.). Другими словами, запись $0 эквивалентна matcher.group(0);.
Той же цели можно было бы достичь с помощью некоторых других методов. Вместо вызова replaceAll(), можно сделать следующее:
StringBuffer buffer = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(buffer, "blah$0blah");
}
matcher.appendTail(buffer);
Logger.getAnonymousLogger().info("After: " + buffer.toString());
И вы получите тот же результат:
Before: Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is a blahWikiWordblah followed by blahAnotherWikiWordblah,
then blahSomeWikiWordblah.