Java Regex API объяснил

     // Compile the regex.    String regex = "(\w+)@(\w+\.)(\w+)(\.\w+)*";    Pattern pattern = Pattern.compile(regex);    // Create the 'target' string we wish to interrogate.    String targetString = "You can email me at g_andy@example.com or andy@example.net to get more info";    // Get a Matcher based on the target string.    Matcher matcher = pattern.matcher(targetString);     // Find all the matches.    while (matcher.find()) {      System.out.println("Found a match: " + matcher.group());      System.out.println("Start position: " + matcher.start());      System.out.println("End position: " + matcher.end());    } 

Здесь происходит несколько интересных вещей. Прежде всего, обратите внимание, что мы использовали метод matcher() класса Pattern для получения объекта Matcher. Этот объект, все еще использующий нашу аналогию с SQL, — это место, где хранятся полученные совпадения — вспомним JDBC ResultSet. Записи, конечно, являются частями текста, которые соответствуют нашему регулярному выражению.

Цикл while выполняется условно на основе результатов метода find() класса Matcher. Этот метод будет анализировать только целевую строку, достаточную для сопоставления, и в этот момент он вернет true. Будьте осторожны: любые попытки использовать matcher перед вызовом find() приведут к тому, что непроверенная IllegalStateException будет выброшена во время выполнения.

В теле нашего цикла while мы получили соответствующую подстроку с помощью метода group() класса Matcher. Наш цикл while выполняется дважды: один раз для каждого адреса электронной почты в нашей целевой строке. В каждом случае он печатает соответствующий адрес электронной почты, возвращенный методом group() , и информацию о расположении подстроки. Посмотрите на вывод:

 Found a match: g_andy@example.com  Start position: 20  End position: 38  Found a match: andy@example.net  Start position: 42  End position: 58 

Как вы можете видеть, это был просто вопрос использования методов start() и end() Matcher, чтобы выяснить, где совпадающие подстроки произошли в целевой строке. Далее подробнее рассмотрим метод group() .

Понимание групп

Как вы узнали, Matcher.group() будет получать полное совпадение из целевой строки. Но что, если вас также интересуют подразделы или «подгруппы» сопоставляемого текста? В нашем примере электронной почты, возможно, было бы желательно извлечь часть имени хоста из адреса электронной почты и часть имени пользователя. Взгляните на пересмотренную версию нашего цикла Matcher, управляемого:

     while (matcher.find()) {      System.out.println("Found a match: " + matcher.group(0) +                         ". The Username is " +                         matcher.group(1) + " and the ISP is " +                         matcher.group(2));    } 

Как вы помните, группы представлены в виде набора круглых скобок, заключенных в подраздел вашего шаблона. Первая группа, расположенная с использованием Matcher.group() или, как в примере, более конкретного Matcher.group(0) , представляет все совпадение. Другие группы можно найти с помощью того же метода group(int index) . Вот вывод для приведенного выше примера:

 Found a match: g_andy@example.com.. The Username is g_andy and the ISP is example.  Found a match: andy@example.net.. The Username is andy and the ISP is example. 

Как вы можете видеть, group(1) получает часть имени пользователя из адреса электронной почты, а group(2) — часть ISP. Разрабатывая собственные регулярные выражения, вы, конечно же, решаете, как логически подгруппировать свои шаблоны. Небольшой недосмотр в этом примере заключается в том, что сам период фиксируется как часть подгруппы, возвращаемой group(2) !

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

Немного больше о шаблонах и классах Matcher

Это в значительной степени ядро ​​этого очень маленького, но очень способного Java API. Тем не менее, есть несколько других частей, которые вы должны изучить, как только у вас будет возможность поэкспериментировать с основами. Класс Pattern имеет несколько флагов, которые вы можете использовать в качестве второго аргумента для метода compile() . Например, вы можете использовать Pattern.CASE_INSENSITIVE чтобы Pattern.CASE_INSENSITIVE механизм регулярных выражений сопоставлять символы ASCII независимо от регистра.

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

 Если вам нужно, вы можете объединить несколько флагов с помощью java |  (вертикальная черта) оператора.  Например, если вы хотите скомпилировать регулярное выражение с поддержкой многострочной и нечувствительности к регистру, вы можете сделать следующее:

 Pattern.compile(myRegEx, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE ); 
  Класс Matcher также имеет ряд интересных методов: String replaceAll(String replacementString) , в частности, стоит упомянуть String replaceFirst(String replacementString) String replaceAll(String replacementString) и String replaceFirst(String replacementString) . 
  Метод replaceAll() принимает строку замены и заменяет все совпадения ей.  Метод replaceFirst() очень похож, но, как вы уже догадались, он заменит только первое совпадение.  Посмотрите на следующий код: 
     // Matches 'BBC' words that end with a digit.    String thePattern = "bbc\d";    // Compile regex and switch off case sensitivity.    Pattern pattern = Pattern.compile(thePattern, Pattern.CASE_INSENSITIVE);    // The target string.    String target = "I like to watch bBC1 and BbC2 - I suppose ITV is okay too";    // Get the Matcher for the target string.    Matcher matcher = pattern.matcher(target);    // Blot out all references to the BBC.    System.out.println(matcher.replaceAll("xxxx") ); 
  Здесь 'вывод: 
 I like to watch xxxx and xxxx - I suppose ITV is okay too 
  Обратные 
  Стоит взглянуть на еще одну важную тему регулярных выражений: обратные ссылки.  Обратные ссылки позволяют вам получить доступ к захваченным подгруппам во время выполнения механизма регулярных выражений.  По сути, это означает, что вы можете ссылаться на подгруппу из более ранней части совпадения позже в шаблоне.  Представьте, что вам нужно проверить целевую строку на наличие трехбуквенных слов, которые начинаются и заканчиваются одной и той же буквой - вау, сос, мама, и тому подобное.  Вот образец, который сделает работу: 
 (w)(w)(1) 
  В этом случае группа (1) содержит обратную ссылку на первое совпадение, сделанное в шаблоне.  По сути, третья группа в скобках будет соответствовать только тогда, когда символ в этой позиции совпадает с символом в первой группе в скобках.  Конечно, вы бы просто заменили 1 на 2 если вы хотите сделать ссылку на вторую группу.  Это просто, но во многих случаях чрезвычайно полезно. 
  Методы замены объекта Matcher (и аналоги класса String) также поддерживают нотацию для выполнения обратных ссылок в строке замены.  Он работает таким же образом, но вместо обратной косой черты используется знак доллара.  Таким образом, matcher.replaceAll("$2") заменит все совпадения в целевой строке значением, сопоставленным второй подгруппой регулярного выражения. 
  Методы RegEx класса String 
  Как я упоминал ранее, класс Java String был обновлен, чтобы использовать преимущества регулярных выражений.  В простых случаях вы можете полностью обойти использование regex API напрямую, вызвав методы с поддержкой regex непосредственно в классе String.  Доступно 5 таких методов. 
  Вы можете использовать метод boolean matches(String regex) чтобы быстро определить, соответствует ли строка определенному шаблону.  String replaceFirst(String regex, String replacement) соответствующим именем и String replaceFirst(String regex, String replacement) String replaceAll(String regex, String replacement) позволяют выполнять быстрые и грязные замены текста.  И наконец, String[] split(String regEx) и String[] split(String regEx, int limit) позволяют разбивать строку на подстроки на основе регулярного выражения.  Эти два последних метода по своей java.util.StringTokenizer похожи на java.util.StringTokenizer , только гораздо более мощные. 
  Имейте в виду, что во многих случаях имеет смысл использовать API регулярных выражений и более объектно-ориентированный подход.  Одна из причин этого заключается в том, что такой подход позволяет предварительно скомпилировать регулярное выражение и затем использовать его в нескольких целевых строках.  Другая причина в том, что он просто гораздо более способный.  Вы быстро поймете, когда выбрать один подход перед другим. 
  Надеюсь, я дал вам преимущество API regex и соблазнил тех, кто еще не открыл этот мощный инструмент, серьезно подумать.  Совет: не тратьте часы драгоценного времени на разработку сложного регулярного выражения - оно может уже существовать.  Есть много мест, таких как www.regexlib.com, которые делают целую кучу их свободно доступными.