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

Регулярные выражения (Regular expression)
Принцип написания регулярного выражения
Специальные символы в Java Regex (Special characters)
Использование String.matches(String)
Использование Pattern и Matcher
Группа (Group)
Использование Pattern, Matcher, Group и *?

1. Регулярные выражения (Regular expression)

Регулярное выражение (regular expression) определяет шаблон (pattern) поиска для строк. Регулярные выражения могут использоваться для поиска, редактирования и манипулирования текстом. Шаблон, определенный регулярным выражением, может совпадать один или несколько раз, или не совпадает с данным текстом.

Аббревиатурой для регулярного выражения является регулярное выражение.

Регулярные выражения (Regular expression) поддерживаются большинством языков программирования, например, Java, C #, C/C++ и т. Д. К сожалению, каждый язык поддерживающий регулярные выражения, несколько отличаются.

Возможно вам будет интересно:
Руководство Регулярное выражение C#
Руководство Регулярное выражение JavaScript

2. Принцип написания регулярного выражения

No	Регулярные выражения	Описание
1	`.`	Подходит (match) любому символу
2	`^regex`	Регулярное выражение должно совпасть с начального пункта
3	`regex$`	Регулярное выражение должно совпасть в конце строки.
4	`[abc]`	Создание определения, может подойти к a или b или c.
5	`[abc][vz]`	Создание определения, может подойти к a или b или c, затем следует v или z.
6	`[^abc]`	Когда появляется знак ^ как первый символ в квадратных скобках, он опровергает модель. Это может совпасть с любым символом, кромер a или b или c.
7	`[a-d1-7]`	Рамки: подходит к строке между a и пунктом d и числом от 1 до 7.
8	`X\|Z`	Поиск X или Z.
9	`XZ`	Поиск X а затем Z.
10	`$`	Проверка завершения строки.

11	`\d`	Любое число, краткая форма `[0-9]`
12	`\D`	Символ неявляющийся числом, краткая форма `[^0-9]`
13	`\s`	Символ пробела, краткая форма`[ \t\n\x0b\r\f]`
14	`\S`	Символ неявляющийся пробелом, краткая форма `[^\s]`
15	`\w`	Символ букв, краткая форма`[a-zA-Z_0-9]`
16	`\W`	Символ неявляющийся пробелом, краткая форма`[^\w]`
17	`\S+`	Некоторые символы неявляющиеся пробелом (Один или более)
18	`\b`	Символ яляется a-z или A-Z или 0-9 или _, краткая форма `[a-zA-Z0-9_]`.

19	`*`	Появляется 0 или много раз, краткая форма`{0,}`
20	`+`	Появляется 1 или много раз, краткая форма`{1,}`
21	`?`	Появляется 0 или 1 раз, `?` краткая форма `{0,1}`.
22	`{X}`	Появляется X раз, `{}`
23	`{X,Y}`	Появляется от X до Y раз.
24	`*?`	* значит появляется 0 или много раз, добавление ? в конце значит поиск самого маленького совпадения.

3. Специальные символы в Java Regex (Special characters)

Специальные символы в Java Regex:

\.[{(*+?^$|

Символы, перечисленные выше, являются специальными символами. В Java Regex если вы хотите, чтобы он понял этот символ обычным способом, вы должны добавить \ впереди.

Например сивол точки. Java regex понимает как любой символ, если вы хотите, чтобы он понимал как символ обычной точки, требуется знак \ впереди.

// Regex pattern describe any character.
String regex = ".";

// Regex pattern describe a dot character.
String regex = "\\.";

4. Использование String.matches(String)

Class String

...

// Check the entire String object matches the regex or not.
public boolean matches(String regex)
..

Используя метод String.matches (String regex), вы можете проверить, что вся строка (String) соответствует регулярному выражению (regex) или нет. Это самый распространенный способ. Рассмотрим следующие примеры:

StringMatches.java

package org.o7planning.tutorial.regex.stringmatches;

public class StringMatches {

    public static void main(String[] args) {

        String s1 = "a";
        System.out.println("s1=" + s1);

        // Check the entire s1
        // Match any character
        // Rule .
        // ==> true
        boolean match = s1.matches(".");
        System.out.println("-Match . " + match);

        s1 = "abc";
        System.out.println("s1=" + s1);

        // Check the entire s1
        // Match any character
        // Rule .
        // ==> false (Because s1 has three characters)
        match = s1.matches(".");
        System.out.println("-Match . " + match);

        // Check the entire s1
        // Match with any character 0 or more times
        // Combine the rules . and *
        // ==> true
        match = s1.matches(".*");
        System.out.println("-Match .* " + match);

        String s2 = "m";
        System.out.println("s2=" + s2);

        // Check the entire s2
        // Start by m
        // Rule ^
        // ==> true
        match = s2.matches("^m");
        System.out.println("-Match ^m " + match);

        s2 = "mnp";
        System.out.println("s2=" + s2);

        // Check the entire s2
        // Start by m
        // Rule ^
        // ==> false (Because s2 has three characters)
        match = s2.matches("^m");
        System.out.println("-Match ^m " + match);

        // Start by m
        // Next any character, appearing one or more times.
        // Rule ^ and. and +
        // ==> true
        match = s2.matches("^m.+");
        System.out.println("-Match ^m.+ " + match);

        String s3 = "p";
        System.out.println("s3=" + s3);

        // Check s3 ending with p
        // Rule $
        // ==> true
        match = s3.matches("p$");
        System.out.println("-Match p$ " + match);

        s3 = "2nnp";
        System.out.println("s3=" + s3);

        // Check the entire s3
        // End of p
        // ==> false (Because s3 has 4 characters)
        match = s3.matches("p$");
        System.out.println("-Match p$ " + match);

        // Check out the entire s3
        // Any character appearing once.
        // Followed by n, appear one or up to three times.
        // End by p: p $
        // Combine the rules: . , {X, y}, $
        // ==> true

        match = s3.matches(".n{1,3}p$");
        System.out.println("-Match .n{1,3}p$ " + match);

        String s4 = "2ybcd";
        System.out.println("s4=" + s4);

        // Start by 2
        // Next x or y or z
        // Followed by any one or more times.
        // Combine the rules: [abc]. , +
        // ==> true
        match = s4.matches("2[xyz].+");

        System.out.println("-Match 2[xyz].+ " + match);

        String s5 = "2bkbv";
        
        // Start any one or more times
        // Followed by a or b, or c: [abc]
        // Next z or v: [zv]
        // Followed by any
        // ==> true
        match = s5.matches(".+[abc][zv].*");

        System.out.println("-Match .+[abc][zv].* " + match);
    }

}

Результат запуска примера:

s1=a
-Match . true
s1=abc
-Match . false
-Match .* true
s2=m
-Match ^m true
s2=mnp
-Match ^m false
-Match ^m.+ true
s3=p
-Match p$ true
s3=2nnp
-Match p$ false
-Match .n{1,3}p$ true
s4=2ybcd
-Match 2[xyz].+ true
-Match .+[abc][zv].* true

SplitWithRegex.java

package org.o7planning.tutorial.regex.stringmatches;

public class SplitWithRegex {

    public static final String TEXT = "This is my text";

    public static void main(String[] args) {
        System.out.println("TEXT=" + TEXT);
         
        // White space appears one or more times.
        // The whitespace characters: \t \n \x0b \r \f
        // Combining rules: \ s and +        
        String regex = "\\s+";
        String[] splitString = TEXT.split(regex);
        // 4
        System.out.println(splitString.length);

        for (String string : splitString) {
            System.out.println(string);
        }
        // Replace all whitespace with tabs
        String newText = TEXT.replaceAll("\\s+", "\t");
        System.out.println("New text=" + newText);
    }
}

Результат запуска примера:

TEXT=This is my text
4
This
is
my
text
New text=This    is    my    text

EitherOrCheck.java

package org.o7planning.tutorial.regex.stringmatches;

public class EitherOrCheck {

    public static void main(String[] args) {

        String s = "The film Tom and Jerry!";
 
        // Check the whole s
        // Begin by any characters appear 0 or more times
        // Next Tom or Jerry
        // End with any characters appear 0 or more times
        // Combine the rules:., *, X | Z
        // ==> true        
        boolean match = s.matches(".*(Tom|Jerry).*");
        System.out.println("s=" + s);
        System.out.println("-Match .*(Tom|Jerry).* " + match);

        s = "The cat";
        // ==> false
        match = s.matches(".*(Tom|Jerry).*");
        System.out.println("s=" + s);
        System.out.println("-Match .*(Tom|Jerry).* " + match);

        s = "The Tom cat";
        // ==> true
        match = s.matches(".*(Tom|Jerry).*");
        System.out.println("s=" + s);
        System.out.println("-Match .*(Tom|Jerry).* " + match);
    }

}

Результат запуска примера:

s=The film Tom and Jerry!
-Match .*(Tom|Jerry).* true
s=The cat
-Match .*(Tom|Jerry).* false
s=The Tom cat
-Match .*(Tom|Jerry).* true

5. Использование Pattern и Matcher

1. Pattern это модельный объект, скомпилированная версия регулярного выражения. Он не имеет никакого публичного конструктора (constructor), и мы используем статический метод compile(String) для создания объекта, с аргументом регулярного выражения.

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

3. Выражение PatternSyntaxException выбрасывается, если синтаксис регулярных выражений неверен.

String regex= ".xx.";
// Create a Pattern object through a static method.
Pattern pattern = Pattern.compile(regex);
// Get a Matcher object
Matcher matcher = pattern.matcher("MxxY");

boolean match = matcher.matches();

System.out.println("Match "+ match);

Class Pattern:

public static Pattern compile(String regex, int flags) ;

public static Pattern compile(String regex);

public Matcher matcher(CharSequence input);

public static boolean matches(String regex, CharSequence input);

Class Matcher:

public int start()

public int start(int group)

public int end()

public int end(int group)

public String group()

public String group(int group)

public String group(String name)

public int groupCount()

public boolean matches()

public boolean lookingAt()

public boolean find()

Ниже приведен пример использования Matcher и метода find() для поиска подстроки, соответствующей регулярному выражению.

MatcherFind.java

package org.o7planning.tutorial.regex;

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

public class MatcherFind {

   public static void main(String[] args) {

       final String TEXT = "This \t is a \t\t\t String";

       // Spaces appears one or more time.
       String regex = "\\s+";

       Pattern pattern = Pattern.compile(regex);

       Matcher matcher = pattern.matcher(TEXT);

       int i = 0;
       while (matcher.find()) {
           System.out.print("start" + i + " = " + matcher.start());
           System.out.print(" end" + i + " = " + matcher.end());
           System.out.println(" group" + i + " = " + matcher.group());
           i++;
       }

   }
}

Результат запуска примера:

start = 4 end = 7 group =      
start = 9 end = 10 group =  
start = 11 end = 16 group =

Method Matcher.lookingAt()

MatcherLookingAt.java

package org.o7planning.tutorial.regex;

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

public class MatcherLookingAt {

    public static void main(String[] args) {
        String country1 = "iran";
        String country2 = "Iraq";

        // Start by I followed by any character.
        // Following is the letter a or e.
        String regex = "^I.[ae]";

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

        Matcher matcher = pattern.matcher(country1);

        // lookingAt () searches that match the first part.
        System.out.println("lookingAt = " + matcher.lookingAt());

        // matches() must be matching the entire
        System.out.println("matches = " + matcher.matches());

        // Reset matcher with new text: country2
        matcher.reset(country2);

        System.out.println("lookingAt = " + matcher.lookingAt());
        System.out.println("matches = " + matcher.matches());
    }
}

6. Группа (Group)

Регулярное выражение может быть разделено на группы (group):

// A regular expression
String regex = "\\s+=\\d+";

// Writing as three group, by marking ()
String regex2 = "(\\s+)(=)(\\d+)";

// Two group
String regex3 = "(\\s+)(=\\d+)";

Группы могут быть сплетены, поэтому нужно правило индексирвания группы. Весь pattern определяется как группа 0. Остальные описаниы как в изображении ниже:

Примечание: Использовать (?:Pattern) для объявления с Java не считать это как группу (None-capturing group)

Из Java 7 вы можете определить группу с названием (? <Name>Pattern), и вы можете получить доступ к содержимому, совпадающему с Matcher.group(Stringname). Это делает Regex длиннее, но код более легкий и значимый.

Группа словленная по названию также может быть доступна через Matcher.group(int group) с той же схемой индексирования.

Внутренне, Java просто создает отображение от названия до индекса группы. Поэтому вы не можете использовать одно и то же название для того, чтобы словить две разные группы.

Давайте посмотрим на пример с использованием названия для группы (Java> = 7)

NamedGroup.java

package org.o7planning.tutorial.regex;

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

public class NamedGroup {

   public static void main(String[] args) {

   
       final String TEXT = " int a = 100;float b= 130;float c= 110 ; ";

        // Use (?<groupName>pattern) to define a group named: groupName
        // Defined group named declare: using (?<declare>...)
        // And a group named value: use: (?<value>..)
       String regex = "(?<declare>\\s*(int|float)\\s+[a-z]\\s*)=(?<value>\\s*\\d+\\s*);";

       Pattern pattern = Pattern.compile(regex);

       Matcher matcher = pattern.matcher(TEXT);

       while (matcher.find()) {
           String group = matcher.group();
           System.out.println(group);
           System.out.println("declare: " + matcher.group("declare"));
           System.out.println("value: " + matcher.group("value"));
           System.out.println("------------------------------");
       }
   }
}

Результат запуска примера:

int a = 100;
declare:  int a
value:  100
------------------------------
float b= 130;
declare: float b
value:  130
------------------------------
float c= 110 ;
declare: float c
value:  110
------------------------------

Чтобы понять, вы можете посмотреть приведенную ниже иллюстрацию:

7. Использование Pattern, Matcher, Group и *?

В некоторых ситуациях *? очень важно. Посмотрим на следующий пример:

// This is a regex
// any characters appear 0 or more times,
// followed by ' and >
String regex = ".*'>";

// TEXT1 match the regex.
String TEXT1 = "FILE1'>";

// And TEXT2 match the regex
String TEXT2 = "FILE1'> <a href='http://HOST/file/FILE2'>";

*? найдет наименьшее совпадение. Рассмотрим следующий пример:

NamedGroup2.java

package org.o7planning.tutorial.regex;

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

public class NamedGroup2 {

  public static void main(String[] args) {
      String TEXT = "<a href='http://HOST/file/FILE1'>File 1</a>"
              + "<a href='http://HOST/file/FILE2'>File 2</a>";

      // Java >= 7.
      // Define group named fileName.
      // *? ==> ? after a quantifier makes it a reluctant quantifier.
      // It tries to find the smallest match.
      String regex = "/file/(?<fileName>.*?)'>";

      Pattern pattern = Pattern.compile(regex);
      Matcher matcher = pattern.matcher(TEXT);

      while (matcher.find()) {
          System.out.println("File Name = " + matcher.group("fileName"));
      }
  }

}

Результат запуска примера:

File Name = FILE1
File Name = FILE2

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

1. Регулярные выражения (Regular expression)

2. Принцип написания регулярного выражения

3. Специальные символы в Java Regex (Special characters)

4. Использование String.matches(String)

5. Использование Pattern и Matcher

6. Группа (Group)

7. Использование Pattern, Matcher, Group и *?

Java Basic

Java Basic

Новейшие статьи