Как найти совпадение в строке java

Время на прочтение
6 мин

Количество просмотров 305K

Вступление

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

1. String, StringBuffer, StringBuilder (реализация строк)
2. Pattern, Matcher (регулярные выражения)

Сегодня поговорим о регулярных выражениях в Java, рассмотрим их механизм и подход к обработке. Также рассмотрим функциональные возможности пакета java.util.regex.

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

Регулярные выражения (regular expressions, далее РВ) — мощное и эффективное средство для обработки текста. Они впервые были использованы в текстовых редакторах операционной системы UNIX (ed и QED) и сделали прорыв в электронной обработке текстов конца XX века. В 1987 году более сложные РВ возникли в первой версии языка Perl и были основаны на пакете Henry Spencer (1986), написанном на языке С. А в 1997 году, Philip Hazel разработал Perl Compatible Regular Expressions (PCRE) — библиотеку, что точно наследует функциональность РВ в Perl. Сейчас PCRE используется многими современными инструментами, например Apache HTTP Server.

Большинство современных языков программирования поддерживают РВ, Java не является исключением.

Механизм

Существует две базовые технологии, на основе которых строятся механизмы РВ:

• Недетерминированный конечный автомат (НКА) — «механизм, управляемый регулярным выражением»
• Детерминированный конечный автомат (ДКА) — «механизм, управляемый текстом»

НКА — механизм, в котором управление внутри РВ передается от компонента к компоненту. НКА просматривает РВ по одному компоненту и проверяет, совпадает ли компонент с текстом. Если совпадает — проверятся следующий компонент. Процедура повторяется до тех пор, пока не будет найдено совпадение для всех компонентов РВ (пока не получим общее совпадение).

ДКА — механизм, который анализирует строку и следит за всеми «возможными совпадениями». Его работа зависит от каждого просканированного символа текста (то есть ДКА «управляется текстом»). Даний механизм сканирует символ текста, обновляет «потенциальное совпадение» и резервирует его. Если следующий символ аннулирует «потенциальное совпадение», то ДКА возвращается к резерву. Нет резерва — нет совпадений.

Логично, что ДКА должен работать быстрее чем НКА (ДКА проверяет каждый символ текста не более одного раза, НКА — сколько угодно раз пока не закончит разбор РВ). Но НКА предоставляет возможность определять ход дальнейших событий. Мы можем в значительной степени управлять процессом за счет правильного написания РВ.

Регулярные выражения в Java используют механизм НКА.

Эти виды конечных автоматов более детально рассмотрены в статье «Регулярные выражения изнутри».

Подход к обработке

В языках программирования существует три подхода к обработке РВ:

• интегрированный
• процедурный
• объектно-ориентированный

Интегрированный подход — встраивание РВ в низкоуровневый синтаксис языка. Этот подход скрывает всю механику, настройку и, как следствие, упрощает работу программиста.
Функциональность РВ при процедурном и объектно-ориентированном подходе обеспечивают функции и методы соответственно. Вместо специальных конструкций языка, функции и методы принимают в качестве параметров строки и интерпретируют их как РВ.

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

Реализация

Для работы с регулярными выражениями в Java представлен пакет java.util.regex. Пакет был добавлен в версии 1.4 и уже тогда содержал мощный и современный прикладной интерфейс для работы с регулярными выражениями. Обеспечивает хорошую гибкость из-за использования объектов, реализующих интерефейс CharSequence.
Все функциональные возможности представлены двумя классами, интерфейсом и исключением:

Pattern

Класс Pattern представляет собой скомпилированное представление РВ. Класс не имеет публичных конструкторов, поэтому для создания объекта данного класса необходимо вызвать статический метод compile и передать в качестве первого аргумента строку с РВ:

// XML тэг в формате <xxx></xxx>
Pattern pattern = Pattern.compile("^<([a-z]+)([^>]+)*(?:>(.*)<\/\1>|\s+\/>)$");

Также в качестве второго параметра в метод compile можно передать флаг в виде статической константы класса Pattern, например:

// email адрес в формате xxx@xxx.xxx (регистр букв игнорируется)
Pattern pattern = Pattern.compile("^([a-z0-9_\.-]+)@([a-z0-9_\.-]+)\.([a-z\.]{2,6})$", Pattern.CASE_INSENSITIVE);

Таблица всех доступных констант и эквивалентных им флагов:

Иногда нам необходимо просто проверить есть ли в строке подстрока, что удовлетворяет заданному РВ. Для этого используют статический метод matches, например:

// это hex код цвета?
if (Pattern.matches("^#?([a-f0-9]{6}|[a-f0-9]{3})$", "#8b2323")) { // вернет true
    // делаем что-то
}

Также иногда возникает необходимость разбить строку на массив подстрок используя РВ. В этом нам поможет метод split:

Pattern pattern = Pattern.compile(":|;");
String[] animals = pattern.split("cat:dog;bird:cow");
Arrays.asList(animals).forEach(animal -> System.out.print(animal + " "));
// cat dog bird cow 

Matcher и MatchResult

Matcher — класс, который представляет строку, реализует механизм согласования (matching) с РВ и хранит результаты этого согласования (используя реализацию методов интерфейса MatchResult). Не имеет публичных конструкторов, поэтому для создания объекта этого класса нужно использовать метод matcher класса Pattern:

// будем искать URL
String regexp = "^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$";
String url = "http://habrahabr.ru/post/260767/";

Pattern pattern = Pattern.compile(regexp);
Matcher matcher = pattern.matcher(url);

Но результатов у нас еще нет. Чтобы их получить нужно воспользоваться методом find. Можно использовать matches — этот метод вернет true только тогда, когда вся строка соответствует заданному РВ, в отличии от find, который пытается найти подстроку, которая удовлетворяет РВ. Для более детальной информации о результатах согласования можно использовать реализацию методов интерфейса MatchResult, например:

// IP адрес
String regexp = "(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
// для сравнения работы find() и matches()
String goodIp = "192.168.0.3";
String badIp = "192.168.0.3g";

Pattern pattern = Pattern.compile(regexp);

Matcher matcher = pattern.matcher(goodIp);
// matches() - true, find() - true
matcher = pattern.matcher(badIp);
// matches() - false, find() - true

// а теперь получим дополнительную информацию
System.out.println(matcher.find() ?
        "I found '"+matcher.group()+"' starting at index "+matcher.start()+" and ending at index "+matcher.end()+"." :
        "I found nothing!");
// I found the text '192.168.0.3' starting at index 0 and ending at index 11.

Также можно начинать поиск с нужной позиции используя find(int start). Стоит отметить что существует еще один способ поиска — метод lookingAt. Он начинает проверку совпадений РВ с начала строки, но не требует полного соответствия, в отличии от matches.
Класс предоставляет методы для замены текста в указанной строке:

Pattern pattern = Pattern.compile("a*b");
Matcher matcher = pattern.matcher("aabtextaabtextabtextb the end");
StringBuffer buffer = new StringBuffer();

while (matcher.find()) {
    matcher.appendReplacement(buffer, "-");
    // buffer = "-" -> "-text-" -> "-text-text-" -> "-text-text-text-"
}
matcher.appendTail(buffer);
// buffer = "-text-text-text- the end"

PatternSyntaxException

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

Спасибо за внимание. Все дополнения, уточнения и критика приветствуются.

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

Последнее обновление: 25.06.2018

Регулярные выражения представляют мощный инструмент для обработки строк. Регулярные выражения позволяют задать шаблон,
которому должна соответствовать строка или подстрока.

Некоторые методы класса String принимают регулярные выражения и используют их для выполнения операций над строками.

split

Для разделения строки на подстроки применяется метод split(). В качестве параметра он может принимать регулярное выражение,
которое представляет критерий разделения строки.

Например, разделим предложение на слова:

String text = "FIFA will never regret it";
String[] words = text.split("\s*(\s|,|!|\.)\s*");
for(String word : words){
	System.out.println(word);
}

Для разделения применяется регулярное выражение «\s*(\s|,|!|\.)\s*». Подвыражние «\s» по сути представляет пробел. Звездочка указывает, что символ может присутствовать от 0 до бесконечного количества раз.
То есть добавляем звездочку и мы получаем неопределенное количество идущих подряд пробелов — «\s*» (то есть неважно, сколько пробелов между словами). Причем пробелы может вообще не быть.
В скобках указывает группа выражений, которая может идти после неопределенного количества пробелов. Группа позволяет нам определить набо значений через вертикальную черту,
и подстрока должна соответствовать одному из этих значений. То есть в группе «\s|,|!|\.» подстрока может соответствовать пробелу,
запятой, восклицательному знаку или точке. Причем поскольку точка представляет специальную последовательность, то, чтобы указать, что мы имеем в виду имеено знак точки, а не специальную последовательность,
перед точкой ставим слеши.

Соответствие строки. matches

Еще один метод класса String — matches() принимает регулярное выражение и возвращает true, если строка соответствует
этому выражению. Иначе возвращает false.

Например, проверим, соответствует ли строка номеру телефона:

String input = "+12343454556";
boolean result = input.matches("(\+*)\d{11}");
if(result){
	System.out.println("It is a phone number");
}
else{
	System.out.println("It is not a phone number!");	
}

В данном случае в регулярном выражение сначала определяется группа «(\+*)». То есть вначале может идти знак плюса, но также он может отсутствовать.
Далее смотрим, соответствуют ли последующие 11 символов цифрам. Выражение «\d» представляет цифровой символ, а число в фигурных скобках — {11} — сколько раз данный тип символов должен повторяться.
То есть мы ищем строку, где вначале может идти знак плюс (или он может отсутствовать), а потом идет 11 цифровых символов.

Класс Pattern

Большая часть функциональности по работе с регулярными выражениями в Java сосредоточена в пакете java.util.regex.

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

Для простого поиска соответствий в классе Pattern определен статический метод boolean matches(String pattern, CharSequence input).
Данный метод возвращает true, если последовательность символов input полностью соответствует шаблону строки pattern:

import java.util.regex.Pattern;

public class StringsApp {

    public static void main(String[] args) {
        
        String input = "Hello";
        boolean found = Pattern.matches("Hello", input);
        if(found)
            System.out.println("Найдено");
        else
            System.out.println("Не найдено");
    }   
}

Но, как правило, для поиска соответствий применяется другой способ — использование класса Matcher.

Класс Matcher

Рассмотрим основные методы класса Matcher:

• boolean matches(): возвращает true, если вся строка совпадает с шаблоном

• boolean find(): возвращает true, если в строке есть подстрока, которая совпадает с шаблоном, и переходит к этой подстроке

• String group(): возвращает подстроку, которая совпала с шаблоном в результате вызова метода find.
  Если совпадение отсутствует, то метод генерирует исключение IllegalStateException.

• int start(): возвращает индекс текущего совпадения

• int end(): возвращает индекс следующего совпадения после текущего

• String replaceAll(String str): заменяет все найденные совпадения подстрокой str и возвращает измененную строку с учетом замен

Используем класс Matcher. Для этого вначале надо создать объект Pattern с помощью статического метода compile(), который позволяет установить шаблон:

Pattern pattern = Pattern.compile("Hello");

В качестве шаблона выступает строка «Hello». Метод compile() возвращает объект Pattern, который мы затем можем использовать в программе.

В классе Pattern также определен метод matcher(String input), который в качестве параметра принимает строку, где надо проводить поиск, и возвращает
объект Matcher:

String input = "Hello world! Hello Java!";
Pattern pattern = Pattern.compile("hello");
Matcher matcher = pattern.matcher(input);

Затем у объекта Matcher вызывается метод matches() для поиска соответствий шаблону в тексте:

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

public class StringsApp {

    public static void main(String[] args) {
        
        String input = "Hello";
        Pattern pattern = Pattern.compile("Hello");
        Matcher matcher = pattern.matcher(input);
        boolean found = matcher.matches();
        if(found)
            System.out.println("Найдено");
        else
            System.out.println("Не найдено");
    }   
}

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

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

public class StringsApp {

    public static void main(String[] args) {
        
        String input = "Hello Java! Hello JavaScript! JavaSE 8.";
        Pattern pattern = Pattern.compile("Java(\w*)");
        Matcher matcher = pattern.matcher(input);
        while(matcher.find())
            System.out.println(matcher.group());
    }   
}

Допустим, мы хотим найти в строке все вхождения слова Java. В исходной строке это три слова: «Java», «JavaScript» и «JavaSE». Для этого
применим шаблон «Java(\w*)». Данный шаблон использует синтаксис регулярных выражений. Слово «Java» в начале говорит о том, что все совпадения в строке
должны начинаться на Java. Выражение (\w*) означает, что после «Java» в совпадении может находиться любое количество алфавитно-цифровых символов.
Выражение w означает алфавитно-цифровой символ, а звездочка после выражения указывает на неопределенное их количество — их может быть один, два, три или вообще не быть.
И чтобы java не рассматривала w как эскейп-последовательность, как n, то выражение экранируется еще одним слешем.

Далее применяется метод find() класса Matcher, который позволяет переходить к следующему совпадению в строке. То есть первый вызов
этого метода найдет первое совпадение в строке, второй вызов найдет второе совпадение и т.д. То есть с помощью цикла while(matcher.find())
мы можем пройтись по всем совпадениям. Каждое совпадение мы можем получить с помощью метода matcher.group(). В итоге
программа выдаст следующий результат:

Замена в строке

Теперь сделаем замену всех совпадений с помощью метода replaceAll():

String input = "Hello Java! Hello JavaScript! JavaSE 8.";
Pattern pattern = Pattern.compile("Java(\w*)");
Matcher matcher = pattern.matcher(input);
String newStr = matcher.replaceAll("HTML");
System.out.println(newStr); // Hello HTML! Hello HTML! HTML 8.

Также надо отметить, что в классе String также имеется метод replaceAll() с подобным действием:

String input = "Hello Java! Hello JavaScript! JavaSE 8.";
String myStr =input.replaceAll("Java(\w*)", "HTML");
System.out.println(myStr); // Hello HTML! Hello HTML! HTML 8.

Разделение строки на лексемы

С помощью метода String[] split(CharSequence input) класса Pattern можно разделить строку на массив подстрок по
определенному разделителю. Например, мы хотим выделить из строки отдельные слова:

import java.util.regex.Pattern;

public class StringsApp {

    public static void main(String[] args) {
        
        String input = "Hello Java! Hello JavaScript! JavaSE 8.";
        Pattern pattern = Pattern.compile("[ ,.!?]");
        String[] words = pattern.split(input);
        for(String word:words)
            System.out.println(word);
    }   
}

И консоль выведет набор слов:

Hello
Java

Hello
JavaScript

JavaSE
8

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

Pattern pattern = Pattern.compile("\s*(\s|,|!|\.)\s*");

Теперь у нас останутся только слова:

Hello
Java
Hello
JavaScript
JavaSE
8

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

Проверка на наличие подстрок в строке — довольно распространенная задача в программировании. Например, иногда мы хотим разбить строку, если она содержит разделитель в точке. В других случаях мы хотим изменить поток, если строка содержит (или не имеет) определенную подстроку, которая может быть командой.

Есть несколько способов сделать это в Java, и большинство из них — то, что вы ожидаете увидеть и в других языках программирования. Однако один из подходов, уникальных для Java, — это использование класса Pattern, о котором мы расскажем позже в этой статье.

В качестве альтернативы вы можете использовать Apache Commons и вспомогательный класс StringUtils, который предлагает множество производных методов из основных методов для этой цели.

Основные способы Java

String.contains()

Первый и главный способ проверить наличие подстроки — это метод .contains(). Это обеспечивается самим классом String и очень эффективно.

Метод принимает CharSequence и возвращает true, если последовательность присутствует в строке, для которой мы вызываем метод:

String string = "Java";
String substring = "va";

System.out.println(string.contains(substring));

Запуск этого даст:

Примечание: метод .contains() чувствителен к регистру. Если бы мы попытались искать "Va" в нашем string, результат будет false.

Часто, чтобы избежать этой проблемы, так как мы не хотим быть чувствительны к регистру, вы должны сопоставить регистр обеих строк перед проверкой:

System.out.println(string.toLowerCase().contains(substring.toLowerCase()));
// OR
System.out.println(string.toUpperCase().contains(substring.toUpperCase()));

String.indexOf()

Метод .indexOf() возвращает индекс первого вхождения подстроки в строке и предлагает несколько конструкторов на выбор:

indexOf(int ch)
indexOf(int ch, int fromIndex)
indexOf(String str)
indexOf(String str, int fromIndex)

Мы можем либо искать один символ со смещением или без него, либо искать строку со смещением или без него.

Метод вернет индекс первого вхождения, если присутствует, и -1 если нет:

String string = "Lorem ipsum dolor sit amet.";

// You can also use unicode for characters
System.out.println(string.indexOf('i'));
System.out.println(string.indexOf('i', 8));
System.out.println(string.indexOf("dolor"));
System.out.println(string.indexOf("Lorem", 10));

Запуск этого кода даст:

• Первое вхождение i в слове ipsum, имеет индекс 6 от начала последовательности символов.
• Первое вхождение i со смещением 8 находится в слове sit,  имеет индекс 19 от начала.
• Первое вхождение String dolor — имеет индекс 12 с начала.
• И, наконец, слова Lorem нет при смещении 10.

В конечном счете, метод .contains() внутри себя вызывает метод .indexOf(). Это делает .indexOf() даже более эффективным, чем аналог (хотя и очень небольшой), хотя у него есть несколько иной вариант использования.

String.lastIndexOf()

В отличие от метода .indexOf(), который возвращает первое вхождение, метод .lastIndexOf() возвращает индекс последнего вхождения символа или строки со смещением или без него:

String string = "Lorem ipsum dolor sit amet.";

// You can also use unicode for characters
System.out.println(string.lastIndexOf('i'));
System.out.println(string.lastIndexOf('i', 8));
System.out.println(string.lastIndexOf("dolor"));
System.out.println(string.lastIndexOf("Lorem", 10));

Запуск этого кода даст:

Некоторые могут быть немного удивлены результатами и скажут:

lastIndexOf('i', 8) должен был вернуть 19, так как это последнее вхождение символа после 8-го символа в строке

Стоит отметить, что при запуске метода .lastIndexOf() последовательность символов меняется на противоположную. Отсчет начинается с последнего символа и идет к первому.

Это, как говорится — ожидаемый результат — 6 последнее появление символа после пропуска 8 элементов из конца последовательности.

Шаблон с регулярным выражением и Matcher

Класс Pattern существенно скомпилированное представление регулярного выражения. Он используется вместе с классом Matcher для сопоставления последовательностей символов.

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

Если они совпадают, метод .find() приводит к true. Если шаблоны не совпадают, метод приводит к false.

Pattern pattern = Pattern.compile(".*" + "some" + ".*");

Matcher matcher = pattern.matcher("Here is some pattern!");
System.out.println(matcher.find());

Это даст:

Apache Commons

Из-за его полезности и распространенности в Java, во многих проектах Apache Commons включен в classpath. Это отличная библиотека со многими полезными функциями, часто используемыми в производстве, и проверка подстрок не является исключением.

Apache Commons предлагает класс StringUtils со многими вспомогательными методами для манипуляций со строками, нуль-проверка и т.д. Для решения этой задачи, мы можем использовать любого из методов .contains(), .indexOf(), .lastIndexOf() или .containsIgnoreCase().

Если нет, то это так же просто, как добавить зависимость к вашему файлу pom.xml, если вы используете Maven:

    org.apache.commons
    commons-lang3
    {version}

Или добавив его через Gradle:

compile group: 'org.apache.commons', name: 'commons-lang3', version: '{version}'

StringUtils.contains()

Метод .contains() довольно прост и очень похож на основной Java подход.

Единственное отличие состоит в том, что мы не вызываем метод для проверяемой строки (поскольку он не наследует этот метод), а вместо этого передаем искомую строку вместе со строкой, которую мы ищем:

String string = "Checking for substrings within a String is a fairly common task in programming.";

System.out.println(StringUtils.contains(string, "common task"));

Запуск этого кода даст:

Примечание: этот метод чувствителен к регистру.

StringUtils.indexOf()

Естественно, метод .indexOf() также работает очень похоже на основной подход Java:

String string = "Checking for substrings within a String is a fairly common task in programming.";

// Search for first occurrence of 'f'
System.out.println(StringUtils.indexOf(string, 'f'));

// Search for first occurrence of 'f', skipping the first 12 elements
System.out.println(StringUtils.indexOf(string, 'f', 12));

// Search for the first occurrence of the "String" string
System.out.println(StringUtils.indexOf(string, "String"));

Запуск этого кода даст:

StringUtils.indexOfAny()

Метод .indexOfAny() принимает список символов, а не один, что позволяет нам искать первое вхождение любого из переданных символов:

String string = "Checking for substrings within a String is a fairly common task in programming.";

// Search for first occurrence of 'f' or 'n', whichever comes first
System.out.println(StringUtils.indexOfAny(string, 'f', 'n'));

// Search for the first occurrence of "String" or "for", whichever comes first
System.out.println(StringUtils.indexOfAny(string, "String", "for"));

Запуск этого кода даст:

StringUtils.indexOfAnyBut()

Метод .indexOfAnyBut() ищет первое вхождение любого символа, что это не в предоставленном комплекте:

String string = "Checking for substrings within a String is a fairly common task in programming.";

// Search for first character outside of the provided set 'C' and 'h'
System.out.println(StringUtils.indexOfAny(string, 'C', 'h'));

// Search for first character outside of the provided set 'C' and 'h'
System.out.println(StringUtils.indexOfAny(string, "Checking", "for"));

Запуск этого кода даст:

StringUtils.indexOfDifference()

Метод .indexOfDifference() сравнивает два массива символов, и возвращает индекс первого символа, отличающийся:

String s1 = "Hello World!"
String s2 = "Hello world!"

System.out.println(StringUtils.indexOfDifference(s1, s2));

Запуск этого кода даст:

StringUtils.indexOfIgnoreCase()

Метод .indexOfIgnoreCase() возвращает индекс первого вхождения символа в последовательности символов, игнорируя случай:

String string = "Checking for substrings within a String is a fairly common task in programming."

System.out.println(StringUtils.indexOf(string, 'c'));
System.out.println(StringUtils.indexOfIgnoreCase(string, 'c'));

Запуск этого кода даст:

StringUtils.lastIndexOf()

И, наконец, метод .lastIndexOf() работает почти так же, как обычный Java-метод:

String string = "Lorem ipsum dolor sit amet.";

// You can also use unicode for characters
System.out.println(StringUtils.lastIndexOf(string, 'i'));
System.out.println(StringUtils.lastIndexOf(string, 'i', 8));
System.out.println(StringUtils.lastIndexOf(string, "dolor"));
System.out.println(StringUtils.lastIndexOf(string, "Lorem", 10));

Запуск этого кода даст:

StringUtils.containsIgnoreCase()

В методе .containsIgnoreCase(), проверяет содержит строка подстроку, не обращая внимания на случай:

String string = "Checking for substrings within a String is a fairly common task in programming.";

System.out.println(StringUtils.containsIgnoreCase(string, "cOmMOn tAsK"));

Запуск этого кода даст:

StringUtils.containsOnly()

Метод .containsOnly() проверяет, если последовательность символов содержит только указанные значения.

Это может вводить в заблуждение, поэтому можно сказать, что это еще один способ — он проверяет, состоит ли последовательность символов только из указанных символов. Он принимает либо строку, либо последовательность символов:

String string = "Hello World!"
System.out.println(StringUtils.containsOnly(string, 'HleWord!'));
System.out.println(StringUtils.containsOnly(string, "wrld"));

Запуск этого даст:

Строка "Hello World!" действительно построена только из символов в последовательности 'HleWord!'.

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

StringUtils.containsNone()

Метод .containsNone(), содержит ли строка какой — либо из «запрещенных» символов из набора:

String string = "Hello World!"
System.out.println(StringUtils.containsNone(string, 'xmt'));
System.out.println(StringUtils.containsNone(string, "wrld"));

Запуск этого кода дает:

StringUtils.containsAny()

И наконец, метод .containsAny() возвращает true, если последовательность символов содержит какой-либо из переданных параметров в форме последовательности символов или строки:

String string = "Hello World!"
System.out.println(StringUtils.containsAny(string, 'h', 'm'));
System.out.println(StringUtils.containsAny(string, "hell"));

Этот код даст: