Как проверить, содержит ли строка специальные символы в Java

Введение

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

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

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/StringManipulationGroup(["String Manipulation"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java/StringManipulationGroup -.-> java/regex("RegEx") java/SystemandDataProcessingGroup -.-> java/string_methods("String Methods") subgraph Lab Skills java/regex -.-> lab-559981{{"Как проверить, содержит ли строка специальные символы в Java"}} java/string_methods -.-> lab-559981{{"Как проверить, содержит ли строка специальные символы в Java"}} end

Определение специальных символов с помощью регулярных выражений

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

Вот некоторые общие специальные символы в регулярных выражениях:

.: Соответствует любому одиночному символу (кроме символа новой строки).
*: Соответствует предыдущему элементу ноль или более раз.
+: Соответствует предыдущему элементу один или более раз.
?: Соответствует предыдущему элементу ноль или один раз.
[]: Соответствует любому одиночному символу, находящемуся в квадратных скобках.
|: Действует как оператор ИЛИ.
(): Группирует элементы вместе.
\: Экранирует специальный символ, заставляя его соответствовать литеральному символу.

Например, если мы хотим найти любую цифру, мы можем использовать \d. Если мы хотим найти любой нецифровой символ, мы используем \D. Аналогично, \s соответствует любому пробельному символу, а \S - любому не-пробельному символу.

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

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

public class HelloJava {
    public static void main(String[] args) {
        String text = "Hello! This is a test string with some special characters: @#$%^&*()_+";
        // Define a regex pattern to match special characters
        String regex = "[^a-zA-Z0-9\\s]";

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

        System.out.println("Original String: " + text);
        System.out.println("Regex Pattern: " + regex);

        System.out.print("Special characters found: ");
        while (matcher.find()) {
            System.out.print(matcher.group() + " ");
        }
        System.out.println(); // Print a newline at the end
    }
}
```
Давайте разберем новые части этого кода:
- import java.util.regex.Matcher; и import java.util.regex.Pattern;: Эти строки импортируют необходимые классы для работы с регулярными выражениями на Java.
- String regex = "[^a-zA-Z0-9\\s]";: Эта строка определяет наш шаблон регулярного выражения.
  - []: Это класс символов, то есть он будет соответствовать любому одиночному символу, находящемуся в квадратных скобках.
  - ^: Когда используется в начале класса символов ([^...]), он инвертирует класс, то есть он будет соответствовать любому символу, не входящему в класс.
  - a-zA-Z0-9: Это соответствует любой строчной букве (от a до z), любой заглавной букве (от A до Z) или любой цифре (от 0 до 9).
  - \\s: Это соответствует любому пробельному символу (пробел, табуляция, новая строка и т.д.). Мы используем \\, потому что \ - это специальный символ в строках Java и его нужно экранировать.
  - Таким образом, весь шаблон [^a-zA-Z0-9\\s] соответствует любому символу, который не является буквой, цифрой или пробельным символом. Эти символы являются нашими "специальными символами" в этом контексте.
- Pattern pattern = Pattern.compile(regex);: Эта строка компилирует шаблон регулярного выражения в объект Pattern. Компиляция шаблона улучшает производительность, если вы используете один и тот же шаблон несколько раз.
- Matcher matcher = pattern.matcher(text);: Эта строка создает объект Matcher, который используется для выполнения операций поиска соответствий в входной строке (text) с использованием скомпилированного шаблона.
- while (matcher.find()): Этот цикл находит следующую подпоследовательность входной последовательности, которая соответствует шаблону.
- matcher.group(): Это возвращает найденную подпоследовательность.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу с помощью команды javac в терминале:
```
javac HelloJava.java
```
Запустите скомпилированную программу с помощью команды java:
```
java HelloJava
```
Вы должны увидеть вывод, похожий на следующий:
```
Original String: Hello! This is a test string with some special characters: @#$%^&*()_+
Regex Pattern: [^a-zA-Z0-9\s]
Special characters found: ! : @ ## $ % ^ & * ( ) _ +
```

Вы успешно определили шаблон регулярного выражения для определения специальных символов и использовали его в программе на Java.

Использование метода `Pattern.matches()` для поиска специальных символов

На этом этапе мы рассмотрим другой способ использования регулярных выражений в Java: метод Pattern.matches(). В отличие от объекта Matcher, который мы использовали на предыдущем этапе для поиска всех вхождений шаблона, метод Pattern.matches() проверяет, соответствует ли весь входной текст заданному регулярному выражению.

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

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

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

public class HelloJava {
    public static void main(String[] args) {
        String text1 = "Hello World";
        String text2 = "Hello World!";
        // Define a regex pattern to check for the presence of special characters
        // This pattern checks if the string contains at least one character that is NOT a letter, digit, or whitespace
        String regex = ".*[^a-zA-Z0-9\\s].*";

        boolean containsSpecial1 = Pattern.matches(regex, text1);
        boolean containsSpecial2 = Pattern.matches(regex, text2);

        System.out.println("String 1: \"" + text1 + "\"");
        System.out.println("Contains special characters? " + containsSpecial1);

        System.out.println("String 2: \"" + text2 + "\"");
        System.out.println("Contains special characters? " + containsSpecial2);
    }
}
```
Рассмотрим изменения:
- Для этого метода нам нужно импортировать только java.util.regex.Pattern;.
- Теперь регулярное выражение имеет вид .*[^a-zA-Z0-9\\s].*. Разберем его:
  - .*: Это соответствует любому символу (.) ноль или более раз (*). Первое .* соответствует любым символам перед специальным символом.
  - [^a-zA-Z0-9\\s]: Это тот же класс символов, что и на предыдущем этапе, который соответствует одному специальному символу.
  - .*: Это соответствует любому символу (.) ноль или более раз (*). Второе .* соответствует любым символам после специального символа.
  - В совокупности, .*[^a-zA-Z0-9\\s].* означает "соответствует любой строке, которая содержит хотя бы один символ, который не является буквой, цифрой или пробельным символом".
- Pattern.matches(regex, text1): Этот статический метод класса Pattern принимает регулярное выражение и входную строку в качестве аргументов и возвращает true, если весь текст соответствует шаблону, и false в противном случае.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу:
```
javac HelloJava.java
```

Запустите программу:

java HelloJava

Вы должны увидеть следующий вывод:

String 1: "Hello World"
Contains special characters? false
String 2: "Hello World!"
Contains special characters? true

Этот вывод показывает, что метод Pattern.matches() правильно определил, что вторая строка содержит специальный символ (!), а первая - нет.

Подсчет специальных символов в строке

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

Мы будем использовать тот же шаблон регулярного выражения, что и на первом этапе ([^a-zA-Z0-9\\s]), чтобы определить специальные символы, и пройдем по строке с помощью объекта Matcher, чтобы подсчитать, сколько раз шаблон встречается.

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

public class HelloJava {
    public static void main(String[] args) {
        String text = "This string has 5 special characters: !@#$%";
        // Define a regex pattern to match special characters
        String regex = "[^a-zA-Z0-9\\s]";

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

        int count = 0;
        while (matcher.find()) {
            count++;
        }

        System.out.println("Original String: \"" + text + "\"");
        System.out.println("Regex Pattern: " + regex);
        System.out.println("Number of special characters found: " + count);
    }
}
```
Вот что происходит в новом коде:
- Мы снова импортируем классы Matcher и Pattern.
- Мы используем тот же шаблон регулярного выражения [^a-zA-Z0-9\\s], чтобы найти отдельные специальные символы.
- Мы инициализируем целочисленную переменную count со значением 0.
- Цикл while (matcher.find()) проходит по строке, и каждый раз, когда метод matcher.find() находит совпадение с шаблоном, выполняется код внутри цикла.
- Внутри цикла мы увеличиваем переменную count на 1 для каждого найденного специального символа.
- В конце мы выводим общее количество специальных символов.
Сохраните файл (Ctrl+S или Cmd+S).
Скомпилируйте программу:
```
javac HelloJava.java
```

Запустите программу:

java HelloJava

Вы должны увидеть следующий вывод:

Original String: "This string has 5 special characters: !@#$%"
Regex Pattern: [^a-zA-Z0-9\s]
Number of special characters found: 5

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

Резюме

В этом практическом занятии (лабораторной работе) мы научились определять специальные символы с использованием регулярных выражений (regex) в Java. Мы изучили общие специальные символы регулярных выражений и их значения, такие как ., *, +, ?, [], |, () и \. Мы также рассмотрели, как использовать предопределенные классы символов, такие как \d, \D, \s и \S.

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