Как проверить, соответствует ли строка регулярному выражению в Java

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, соответствует ли строка регулярному выражению на Java. Мы начнем с понимания основ регулярных выражений и создания простого шаблона с использованием пакета java.util.regex.

Затем вы познакомитесь с классами Pattern и Matcher для выполнения операций поиска соответствий. Наконец, вы примените свои знания для тестирования шаблонов регулярных выражений с использованием пользовательского ввода, приобретая практический опыт использования регулярных выражений для валидации и манипуляции строками на Java.

Создание простого регулярного выражения

На этом этапе мы начнем с понимания, что такое регулярные выражения (regex) и как создать базовый шаблон на Java.

Регулярные выражения - это мощные инструменты, используемые для поиска соответствий и манипуляции текстовыми строками. Представьте их как мини-язык для описания шаблонов в тексте. Они чрезвычайно полезны для таких задач, как поиск определенного текста, валидация форматов ввода (например, адресов электронной почты или номеров телефонов) и замена текста на основе шаблонов.

В Java регулярные выражения обрабатываются пакетом java.util.regex. Два основных класса, которые мы будем использовать, - это Pattern и Matcher.

Pattern: Этот класс представляет скомпилированное регулярное выражение. Вы компилируете строку регулярного выражения в объект Pattern.
Matcher: Этот класс используется для выполнения операций поиска соответствий в входной строке с использованием объекта Pattern.

Давайте создадим простую Java-программу для определения и вывода базового шаблона регулярного выражения.

Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.
Замените все содержимое файла следующим кодом:
```
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Print the pattern
        System.out.println("Our regex pattern is: " + pattern.pattern());
    }
}
```
Рассмотрим новые части кода:
- import java.util.regex.Pattern;: Эта строка импортирует класс Pattern, который нам нужен для работы с регулярными выражениями.
- String regexPattern = "Java";: Эта строка определяет простую строковую переменную regexPattern, которая содержит наше регулярное выражение. В данном случае шаблон представляет собой просто слово "Java".
- Pattern pattern = Pattern.compile(regexPattern);: Здесь мы компилируем нашу строку регулярного выражения в объект Pattern. Метод Pattern.compile() принимает строку регулярного выражения в качестве аргумента и возвращает объект Pattern.
- System.out.println("Our regex pattern is: " + pattern.pattern());: Эта строка выводит исходную строку регулярного выражения, которая была использована для создания объекта Pattern. Метод pattern() объекта Pattern возвращает строку регулярного выражения.
Сохраните файл (Ctrl+S или Cmd+S).
Теперь давайте скомпилируем нашу программу. Откройте Терминал в нижней части WebIDE и убедитесь, что вы находитесь в директории ~/project. Выполните следующую команду:
```
javac HelloJava.java
```
Если нет ошибок, в директории ~/project будет создан файл HelloJava.class.
Наконец, запустите скомпилированную программу:
```
java HelloJava
```
Вы должны увидеть следующий вывод:
```
Our regex pattern is: Java
```
Это подтверждает, что наш базовый шаблон регулярного выражения был успешно определен и скомпилирован. На следующем этапе мы будем использовать этот шаблон для поиска соответствий в заданной строке.

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

На этом этапе мы научимся использовать класс Matcher вместе с объектом Pattern для поиска вхождений шаблона в заданной входной строке.

Как мы обсуждали на предыдущем этапе, класс Pattern представляет скомпилированное регулярное выражение. Класс Matcher используется для фактического выполнения операций поиска в конкретной входной строке с использованием этого скомпилированного шаблона.

Вот как обычно работает этот процесс:

Компиляция регулярного выражения: Создайте объект Pattern из строки регулярного выражения с помощью метода Pattern.compile().
Создание объекта Matcher: Получите объект Matcher путем вызова метода matcher() на объекте Pattern, передав входную строку, в которой вы хотите выполнить поиск.
Выполнение поиска соответствий: Используйте методы объекта Matcher для поиска соответствий. Общими методами являются find() (для поиска следующего совпадения) и matches() (для проверки, соответствует ли вся входная строка шаблону).

Давайте модифицируем нашу программу HelloJava.java так, чтобы использовать объект Matcher для поиска слова "Java" в образцовом предложении.

Откройте файл HelloJava.java в редакторе WebIDE.
Замените существующий код следующим:
```
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // The input string to search within
        String inputString = "Hello, Java! Welcome to Java programming.";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
        }
    }
}
```
Вот что нового:
- import java.util.regex.Matcher;: Мы импортируем класс Matcher.
- String inputString = "Hello, Java! Welcome to Java programming.";: Мы определяем строку, в которой хотим выполнить поиск.
- Matcher matcher = pattern.matcher(inputString);: Мы создаем объект Matcher путем вызова метода matcher() на объекте pattern и передачи inputString.
- while (matcher.find()) { ... }: Этот цикл использует метод find() объекта Matcher. Метод find() пытается найти следующую подпоследовательность входной последовательности, которая соответствует шаблону. Он возвращает true, если совпадение найдено, и false в противном случае. Цикл while продолжается, пока find() возвращает true.
- System.out.println("Found match at index: " + matcher.start());: Внутри цикла, если совпадение найдено, метод matcher.start() возвращает начальный индекс совпавшей подпоследовательности во входной строке. Мы выводим этот индекс.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте модифицированную программу в Терминале:
```
javac HelloJava.java
```
Запустите скомпилированную программу:
```
java HelloJava
```
Вы должны увидеть вывод, похожий на следующий:
```
Searching for pattern: 'Java' in string: 'Hello, Java! Welcome to Java programming.'
Found match at index: 7
Found match at index: 27
```
Этот вывод показывает, что наша программа успешно нашла два вхождения слова "Java" во входной строке и вывела начальный индекс каждого совпадения.

Теперь вы успешно использовали классы Pattern и Matcher для поиска определенного шаблона в строке. На следующем этапе мы сделаем эту программу интерактивной, разрешив пользователю вводить строку для поиска.

Тестирование регулярного выражения с использованием пользовательского ввода

На этом последнем этапе мы сделаем нашу программу для работы с регулярными выражениями интерактивной, разрешив пользователю вводить строку, в которой он хочет выполнить поиск. Это сделает программу более гибкой и продемонстрирует, как сочетать регулярные выражения с взаимодействием с пользователем.

Мы будем использовать класс Scanner, который вы, возможно, помните из раздела "Ваша первая Java-лабораторная работа", для чтения ввода от пользователя.

Откройте файл HelloJava.java в редакторе WebIDE.

Замените существующий код следующим:

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

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a string
        System.out.print("Enter the string to search within: ");
        String inputString = scanner.nextLine();

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        boolean found = false;
        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
            found = true;
        }

        if (!found) {
            System.out.println("No match found.");
        }

        // Close the scanner
        scanner.close();
    }
}

Вот изменения, которые мы внесли:

import java.util.Scanner;: Мы импортируем класс Scanner.
Scanner scanner = new Scanner(System.in);: Мы создаем объект Scanner для чтения ввода с консоли.
System.out.print("Enter the string to search within: ");: Мы просим пользователя ввести строку.
String inputString = scanner.nextLine();: Мы читаем всю введенную пользователем строку и сохраняем ее в переменной inputString.
Мы добавили переменную boolean found = false; и блок if (!found), чтобы вывести сообщение, если совпадений не найдено.
scanner.close();: Мы закрываем объект Scanner, чтобы освободить системные ресурсы.

Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу в Терминале:
```
javac HelloJava.java
```
Запустите программу:
```
java HelloJava
```
Теперь программа будет ждать, пока вы введете строку. Введите строку, содержащую слово "Java" (или не содержащую его) и нажмите Enter.

Например, если вы введете:
```
Learning Java is fun!
```
Вывод будет следующим:
```
Enter the string to search within: Learning Java is fun!
Searching for pattern: 'Java' in string: 'Learning Java is fun!'
Found match at index: 9
```
Если вы введете:
```
Python is also great.
```
Вывод будет следующим:
```
Enter the string to search within: Python is also great.
Searching for pattern: 'Java' in string: 'Python is also great.'
No match found.
```

Теперь вы успешно создали интерактивную Java-программу, которая использует регулярные выражения для поиска шаблона в строке, предоставленной пользователем. Это практический пример того, как регулярные выражения могут быть использованы в реальных приложениях.

Резюме

В этой лабораторной работе мы начали с изучения основ регулярных выражений (regex) в Java, сосредоточившись на пакете java.util.regex. Мы узнали, что регулярные выражения - это мощный инструмент для поиска и манипуляции шаблонами в строках, и что ключевыми классами являются Pattern и Matcher. Затем мы практиковались в создании простого регулярного выражения, определив простую строку и скомпилировав ее в объект Pattern с помощью метода Pattern.compile(), тем самым продемонстрировав, как определить и вывести простой регулярный шаблон в Java-программе.