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

В Java, регулярные выражения (Regular Expressions или сокращённо Regex) — это API для определения шаблонов строк, которые можно использовать для поиска, обработки и редактирования строк. Проверка корректности email и паролей — одни из основных областей применения Regex для задания ограничений. Регулярные выражения в Java предоставляются в пакете java.util.regex.

Пример:

// Java-программа, демонстрирующая работу метода matches() из класса Pattern

import java.util.regex.Pattern;

class GFG {
    public static void main(String args[]){
        // Следующая строка выведет "true", потому что вся
        // строка "geeksforgeeks" соответствует шаблону
        // "geeksforge*ks"
        System.out.println(Pattern.matches(
            "geeksforge*ks","geeksforgeeks"));

        // Следующая строка выведет "false", потому что вся
        // строка "geeksfor" не соответствует шаблону "g*geeks*"
        System.out.println(Pattern.matches(
                "g*geeks*","geeksfor"));
    }
}

Вывод:

true
false

Классы и интерфейсы Regex

Пакет java.util.regex включает в себя 3 класса и 1 интерфейс. Основные из них представлены в таблице ниже:

Класс/Интерфейс Описание
Pattern Class Используется для определения шаблонов
Matcher Class Выполняет операции сопоставления текста с шаблонами
PatternSyntaxException Class Сигнализирует об ошибках синтаксиса в регулярном выражении
MatchResult Interface Представляет результат операции сопоставления

Подробнее структура и взаимосвязи этих классов можно увидеть на соответствующей диаграмме (изображение в оригинальной статье).

Класс Pattern

Класс Pattern представляет собой компиляцию регулярного выражения (pattern), позволяющую задавать различные шаблоны поиска. Он не имеет публичных конструкторов. Объект Pattern создаётся вызовом статического метода compile(), который принимает регулярное выражение в качестве аргумента и возвращает скомпилированный шаблон.

Методы класса Pattern:

Метод Описание
compile(String regex) Компилирует переданное регулярное выражение в объект Pattern.
compile(String regex, int flags) Компилирует регулярное выражение с учётом заданных флагов.
flags() Возвращает флаги, применённые к данному шаблону.
matcher(CharSequence input) Создаёт объект Matcher для сопоставления входной последовательности с шаблоном.
matches(String regex, CharSequence input) Компилирует регулярное выражение и пытается определить, соответствует ли входная строка шаблону.
pattern() Возвращает исходное регулярное выражение, из которого скомпилирован Pattern.
quote(String s) Возвращает строку, представляющую буквальный шаблон для заданной строки.
split(CharSequence input) Разбивает входную последовательность по совпадениям с шаблоном.
split(CharSequence input, int limit) Разбивает входную последовательность с ограничением на количество разбиений.
toString() Возвращает строковое представление шаблона.

Пример использования Pattern:

// Java-программа, демонстрирующая работу метода matches() класса Pattern

import java.util.regex.Pattern;

class GFG {
    public static void main(String args[]){
        // Выводит "true" - вся строка "geeksforgeeks" соответствует шаблону "geeks.*"
        System.out.println(Pattern.matches(
            "geeks.*", "geeksforgeeks"));

        // Выводит "false" - строка "geeks12s" не соответствует шаблону "geeks[0-9]+"
        System.out.println(Pattern.matches(
            "geeks[0-9]+", "geeks12s"));
    }
}

Вывод:

true
false

Класс Matcher

Объект Matcher используется для выполнения операций сопоставления с входной строкой, применяя ранее скомпилированные шаблоны Pattern. Класс не имеет публичных конструкторов. Экземпляр Matcher создаётся вызовом метода matcher() у объекта Pattern.

Методы Matcher:

Метод Описание
find() Ищет первое или последующее вхождение шаблона в тексте.
find(int start) Начинает поиск с заданного индекса в тексте.
start() Возвращает индекс начала найденного соответствия.
end() Возвращает индекс символа, следующего за последним символом найденного соответствия.
groupCount() Возвращает количество подгрупп, найденных в сопоставлении.
group() Возвращает найденное соответствие.
matches() Проверяет, соответствует ли вся входная строка шаблону.

Обратите внимание:
Метод Pattern.matches() проверяет, соответствует ли весь текст шаблону целиком. Другие методы (например, find()) предназначены для поиска нескольких вхождений шаблонов в тексте.

Рассмотрим примеры программ с использованием compile(), find(), start(), end() и split() для лучшего понимания класса Matcher.

Пример 1: Поиск шаблона в строке

// Java-программа, демонстрирующая работу поиска строк с помощью Matcher

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

class GFG {
    public static void main(String args[])
    {
        // Создаём шаблон для поиска
        Pattern p = Pattern.compile("geeks");

        // Ищем шаблон в строке "geeksforgeeks.org"
        Matcher m = p.matcher("geeksforgeeks.org");

        // Используем find() для нахождения всех вхождений
        while (m.find())
            // Выводим начальный и конечный индексы найденного шаблона в строке
            System.out.println("Pattern found from " + m.start() + " to " + (m.end() - 1));
    }
}

Вывод: 

Pattern found from 0 to 4
Pattern found from 8 to 12

Классы символов Regex (Character Classes)

Класс символов Описание
[xyz] Символы x, y или z
[^xyz] Любые символы, кроме x, y или z
[a-zA-Z] Символы из диапазона a–z или A–Z
[a-f[m-t]] Объединение диапазонов a–f и m–t
[a-z&&p-y] Пересечение диапазонов (только символы, присутствующие в обоих)
[a-z&&[^bc]] Диапазон a–z за исключением b и c
[a-z&&[^m-p]] Диапазон a–z за исключением диапазона m–p

Пример:

// Java-программа для проверки Character Classes в Regex

import java.io.*;
import java.util.regex.*;

class GFG {
    public static void main(String[] args)
    {
        // Проверка, что строка — одиночный символ от a до z
        System.out.println(Pattern.matches("[a-z]", "g"));

        // Проверка, что строка — одиночный символ из диапазона a–z или A–Z
        System.out.println(Pattern.matches("[a-zA-Z]", "Gfg")); // Обратите внимание, что здесь строка состоит из трех символов, а шаблон рассчитан на один символ
    }
}

Вывод: 

true
false

Метасимволы Regex

Регулярное выражение Описание
X? X встречается один раз или не встречается
X+ X встречается один или более раз
X* X встречается ноль или более раз
X{n} X встречается ровно n раз
X{n,} X встречается n или более раз
X{n,m} X встречается от n до m раз (включительно)

Пример:

// Java-программа для проверки метасимволов Regex

import java.io.*;
import java.util.regex.*;

class GFG {
    public static void main(String[] args)
    {
        // Проверяем, что строка соответствует заданному шаблону
        System.out.println(Pattern.matches("[b-z]?", "a"));

        // Проверка, что строка состоит из символов в диапазоне a–z или A–Z
        System.out.println(Pattern.matches("[a-zA-Z]+", "GfgTestCase"));

        // Проверка, что символ НЕ в диапазоне a–z (или отсутствует)
        System.out.println(Pattern.matches("[^a-z]?", "g"));

        // Проверка, что строка состоит только из символов g, e, k или s
        System.out.println(Pattern.matches("[geks]*", "geeksgeeks"));
    }
}

Вывод: 

false
true
false
true

Пример поиска с помощью Java Regex Finder

Regex Описание
. Любой символ
\d Любая цифра [0-9]
\D Любой нецифровой символ [^0-9]
\s Пробельный символ (таб, перевод строки и др.)
\S Не пробельный символ [^\s]
\w Символ слова (буква, цифра, _)
\W Не является символом слова [^\w]
\b Граница слова
\B Не граница слова

Пример программы:

// Java-программа, демонстрирующая использование Java Regex Finder

import java.io.*;
import java.util.regex.*;

class GFG {
    public static void main(String[] args)
    {
        // Проверка, что строка состоит только из цифр
        System.out.println(Pattern.matches("\\d+", "1234"));

        // Проверка, что строка состоит только из нецифровых символов
        System.out.println(Pattern.matches("\\D+", "1234"));

        // Проверка, что строка состоит только из нецифровых символов (буквы и др.)
        System.out.println(Pattern.matches("\\D+", "Gfg"));

        // Проверка, что строка состоит из непробельных символов
        System.out.println(Pattern.matches("\\S+", "gfg"));
    }
}

Вывод: 

true
false
true
true

Заключение

Итоговые ключевые моменты из статьи:

  1. Объект Pattern создаётся вызовом статического метода Pattern.compile(), конструктора у класса нет.
  2. Экземпляр Matcher создаётся через вызов метода matcher() у объекта Pattern.
  3. Статический метод Pattern.matches() проверяет, соответствует ли вся входная строка заданному шаблону.
  4. Метод find() используется для поиска нескольких вхождений шаблона в тексте.
  5. Метод split() позволяет разбивать строку на части по шаблону-разделителю.

🔑 Ключевые моменты:

  • В Java регулярные выражения реализованы через пакет java.util.regex, предоставляющий основные классы Pattern и Matcher.

  • Pattern используется для компиляции шаблона, Matcher — для поиска и сопоставления в тексте.

  • Regex позволяет легко проверять строки на соответствие сложным правилам (например, валидация email, пароля).

  • Методы find() и matches() служат разным целям: поиск вхождений и проверка полного соответствия.

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

Похожие записи

Ответить

Ваш адрес email не будет опубликован. Обязательные поля помечены *