Обработка строк в Java. Часть II: Pattern, Matcher
Что Вы знаете о обработке строк в Java? Как много этих знаний и насколько они углублены и актуальны? Давайте попробуем вместе со мной разобрать все вопросы, связанные с этой важной, фундаментальной и часто используемой частью языка. Наш маленький гайд будет разбит на две публикации:
Регулярные выражения
Регулярные выражения (regular expressions, далее РВ) — мощное и эффективное средство для обработки текста. Они впервые были использованы в текстовых редакторах операционной системы UNIX (ed и QED) и сделали прорыв в электронной обработке текстов конца XX века. В 1987 году более сложные РВ возникли в первой версии языка Perl и были основаны на пакете Henry Spencer (1986), написанном на языке С. А в 1997 году, Philip Hazel разработал Perl Compatible Regular Expressions (PCRE) — библиотеку, что точно наследует функциональность РВ в Perl. Сейчас PCRE используется многими современными инструментами, например Apache HTTP Server.
Большинство современных языков программирования поддерживают РВ, Java не является исключением.
Механизм
Существует две базовые технологии, на основе которых строятся механизмы РВ:
- Недетерминированный конечный автомат (НКА) — «механизм, управляемый регулярным выражением»
- Детерминированный конечный автомат (ДКА) — «механизм, управляемый текстом»
ДКА — механизм, который анализирует строку и следит за всеми «возможными совпадениями». Его работа зависит от каждого просканированного символа текста (то есть ДКА «управляется текстом»). Даний механизм сканирует символ текста, обновляет «потенциальное совпадение» и резервирует его. Если следующий символ аннулирует «потенциальное совпадение», то ДКА возвращается к резерву. Нет резерва — нет совпадений.
Логично, что ДКА должен работать быстрее чем НКА (ДКА проверяет каждый символ текста не более одного раза, НКА — сколько угодно раз пока не закончит разбор РВ). Но НКА предоставляет возможность определять ход дальнейших событий. Мы можем в значительной степени управлять процессом за счет правильного написания РВ.
Регулярные выражения в Java используют механизм НКА.
Эти виды конечных автоматов более детально рассмотрены в статье «Регулярные выражения изнутри».
Подход к обработке
В языках программирования существует три подхода к обработке РВ:
Для обработки регулярных выражений в Java используют объектно-ориентированный подход.
Реализация
Для работы с регулярными выражениями в Java представлен пакет java.util.regex. Пакет был добавлен в версии 1.4 и уже тогда содержал мощный и современный прикладной интерфейс для работы с регулярными выражениями. Обеспечивает хорошую гибкость из-за использования объектов, реализующих интерефейс CharSequence.
Все функциональные возможности представлены двумя классами, интерфейсом и исключением:
Pattern
Класс Pattern представляет собой скомпилированное представление РВ. Класс не имеет публичных конструкторов, поэтому для создания объекта данного класса необходимо вызвать статический метод compile и передать в качестве первого аргумента строку с РВ:
// XML тэг в формате Pattern pattern = Pattern.compile("^<([a-z]+)([^>]+)*(?:>(.*)|\\s+\\/>)$"); Также в качестве второго параметра в метод compile можно передать флаг в виде статической константы класса Pattern, например:
// email адрес в формате xxx@xxx.xxx (регистр букв игнорируется) Pattern pattern = Pattern.compile("^([a-z0-9_\\.-]+)@([a-z0-9_\\.-]+)\\.([a-z\\.])$", Pattern.CASE_INSENSITIVE); Таблица всех доступных констант и эквивалентных им флагов:
| № | Constant | Equivalent Embedded Flag Expression |
|---|---|---|
| 1 | Pattern.CANON_EQ | — |
| 2 | Pattern.CASE_INSENSITIVE | (?i) |
| 3 | Pattern.COMMENTS | (?x) |
| 4 | Pattern.MULTILINE | (?m) |
| 5 | Pattern.DOTALL | (?s) |
| 6 | Pattern.LITERAL | — |
| 7 | Pattern.UNICODE_CASE | (?u) |
| 8 | Pattern.UNIX_LINES | (?d) |
Иногда нам необходимо просто проверить есть ли в строке подстрока, что удовлетворяет заданному РВ. Для этого используют статический метод matches, например:
// это hex код цвета? if (Pattern.matches("^#?([a-f0-9]|[a-f0-9])$", "#8b2323")) < // вернет true // делаем что-то >Также иногда возникает необходимость разбить строку на массив подстрок используя РВ. В этом нам поможет метод split:
Pattern pattern = Pattern.compile(":|;"); String[] animals = pattern.split("cat:dog;bird:cow"); Arrays.asList(animals).forEach(animal -> System.out.print(animal + " ")); // cat dog bird cow Matcher и MatchResult
Matcher — класс, который представляет строку, реализует механизм согласования (matching) с РВ и хранит результаты этого согласования (используя реализацию методов интерфейса MatchResult). Не имеет публичных конструкторов, поэтому для создания объекта этого класса нужно использовать метод matcher класса Pattern:
// будем искать URL String regexp = "^(https?:\\/\\/)?([\\da-z\\.-]+)\\.([a-z\\.])([\\/\\w \\.-]*)*\\/?$"; String url = "http://habrahabr.ru/post/260767/"; Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(url); Но результатов у нас еще нет. Чтобы их получить нужно воспользоваться методом find. Можно использовать matches — этот метод вернет true только тогда, когда вся строка соответствует заданному РВ, в отличии от find, который пытается найти подстроку, которая удовлетворяет РВ. Для более детальной информации о результатах согласования можно использовать реализацию методов интерфейса MatchResult, например:
// IP адрес String regexp = "(?:(?:253|216|[01]?77?)\\.)(?:253|224|[01]?38?)"; // для сравнения работы find() и matches() String goodIp = "192.168.0.3"; String badIp = "192.168.0.3g"; Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(goodIp); // matches() - true, find() - true matcher = pattern.matcher(badIp); // matches() - false, find() - true // а теперь получим дополнительную информацию System.out.println(matcher.find() ? "I found '"+matcher.group()+"' starting at index "+matcher.start()+" and ending at index "+matcher.end()+"." : "I found nothing!"); // I found the text '192.168.0.3' starting at index 0 and ending at index 11. Также можно начинать поиск с нужной позиции используя find(int start). Стоит отметить что существует еще один способ поиска — метод lookingAt. Он начинает проверку совпадений РВ с начала строки, но не требует полного соответствия, в отличии от matches.
Класс предоставляет методы для замены текста в указанной строке:
| appendReplacement(StringBuffer sb, String replacement) | Реализует механизм «добавление-и-замена» (append-and-replace). Формирует обьект StringBuffer (получен как параметр) добавляя replacement в нужные места. Устанавливает позицию, которая соответствует end() последнего результата поиска. После этой позиции ничего не добавляет. |
| appendTail(StringBuffer sb) | Используется после одного или нескольких вызовов appendReplacement и служит для добавления оставшейся части строки в объект класса StringBuffer, полученного как параметр. |
| replaceFirst(String replacement) | Заменяет первую последовательность, которая соответствует РВ, на replacement. Использует вызовы методов appendReplacement и appendTail. |
| replaceAll(String replacement) | Заменяет каждую последовательность, которая соответствует РВ, на replacement. Также использует методы appendReplacement и appendTail. |
| quoteReplacement(String s) | Возвращает строку, в которой коса черта (‘ \ ‘) и знак доллара (‘ $ ‘) будут лишены особого смысла. |
Pattern pattern = Pattern.compile("a*b"); Matcher matcher = pattern.matcher("aabtextaabtextabtextb the end"); StringBuffer buffer = new StringBuffer(); while (matcher.find()) < matcher.appendReplacement(buffer, "-"); // buffer = "-" ->"-text-" -> "-text-text-" -> "-text-text-text-" > matcher.appendTail(buffer); // buffer = "-text-text-text- the end" PatternSyntaxException
Неконтролируемое (unchecked) исключение, возникает при синтаксической ошибке в регулярном выражении. В таблице ниже приведены все методы и их описание.
| getDescription() | Возвращает описание ошибки. |
| getIndex() | Возвращает индекс строки, где была найдена ошибка в РВ |
| getPattern() | Возвращает ошибочное РВ. |
| getMessage() | getDescription() + getIndex() + getPattern() |
Спасибо за внимание. Все дополнения, уточнения и критика приветствуются.
Java Pattern Matcher не работает для регулярных выражений, как ожидалось
^ и $ anchors используются, когда вы хотите, чтобы ваше выражение соответствовало всей строке ввода. Когда вы хотите совместить в начале, держите ^ и удаляете $ ; когда вы хотите совместить в конце, удалите ^ и сохраните $ ; если вы хотите совместить нигде внутри строки, удалите оба якоря.
Код хорош и работает как ожидалось. В блоке 2) и 3) в вашем вопросе вы используете одно и то же регулярное выражение, но разные входные строки.
Однако, если вы просто хотите проверить, должна ли строка содержать почтовый индекс в США, проблема в том, что в вашем регулярном выражении используются привязки, поэтому вы выполняете только соответствующие строки, которые начинаются и заканчиваются почтовым индексом.
Строки, соответствующие вашему регулярному выражению, похожи на 34238 или 34238-1234 и ничего не будут соответствовать something 12345 something .
Если вы удалите анкеры, то вы будете соответствовать whatever 12345 whatever :
// Pattern pattern = Pattern.compile("^9(?:-5)?$"); // ^--------- Here -------^ Pattern pattern = Pattern.compile("4(?:-6)?"); Matcher matcher = pattern.matcher("6003 Honore Ave Suite 101 Sarasota Florida, 34238"); if (matcher.find()) Btw, если вы просто хотите проверить, содержит ли строка почтовый индекс, вы можете использовать String.matches(..) , например:
String str = "6003 Honore Ave Suite 101 Sarasota Florida, 34238"; if (str.matches(".*3(?:-1)?.*")) Pattern и Matcher не работают в java
В основном у меня есть простая строка, где мне нужно явно ограничить символы, отличные от a-zA-Z0-9 . Прежде чем упомянуть, что здесь не так, я это делаю.
Pattern p = Pattern.compile("[&=]"); Matcher m = p.matcher("Nothing is wrong"); if (m.find()) < out.print("You are not allowed to have &=."); return; >Pattern p1 = Pattern.compile("[a-zA-Z0-9]"); Matcher m1 = p1.matcher("Itissupposetobeworking"); if (m1.find()) Первый работает отлично, но на втором матчи m1 всегда получается выполнить if(m1.find()) даже если он не содержит никаких символов, кроме указанных в шаблоне.
Я также попробовал Pattern p1 = Pattern.compile(«[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]») Но все равно есть те же проблемы.
и если вы хотите сказать, что лучше между String.matches([«a-zA-Z0-9»]); или как я использую выше?
Кажется, вы хотите найти частичное совпадение в строке, содержащей символ, отличный от буквенно-цифрового символа:
Pattern p1 = Pattern.compile("[^a-zA-Z0-9]"); Pattern p1 = Pattern.compile("\\P"); Обратите внимание, что весь отрицательный класс символов можно заменить на предопределенный класс символов \P который соответствует любому \P , отличному от буквенно-цифрового. \p соответствует любому буквенно-цифровому символу, а \P – это обратный класс.
[a-zA-Z0-9] пытается сопоставить буквенно-цифровые символы.Итак, вы получите “Что-то не так”. для печати, если у вас есть алфавитно-цифровой символ во входной последовательности символов matcher() .
Измените его на [^a-zA-Z0-9] и попробуйте.
Это пытается сопоставить не буквенно-цифровые символы. Итак, вы получите ожидаемый результат.
Когда выражение выше находит совпадение, оно печатает “Что-то не так”. но если вы хотите ограничить использование кода ниже.
Pattern p1 = Pattern.compile("a-zA-Z0-9"); String a = "It$issupposetobeworking"; Matcher m1 = p1.matcher(a); if (m1.find()) < System.out.print("There is something wrong."); >else Если вы хотите, чтобы один и тот же код работал с одним и тем же регулярным выражением в этом сценарии, используйте этот код.
Pattern p1 = Pattern.compile("[a-zA-Z0-9]"); Matcher m1 = p1.matcher("Itissupposetobeworking"); if (!(m1.find())) Если вы используете isAlphanumeric Method для org.apache.commons.lang.StringUtils, ваш код станет намного читабельнее. Поэтому вам нужно написать
if (!StringUtils.isAlphanumeric("Itissupposetobeworking")) Pattern p1 = Pattern.compile("[a-zA-Z0-9]"); Matcher m1 = p1.matcher("Itissupposetobeworking"); if (!m1.find())