Java: Проверьте, начинается ли строка с другой строки

Вступление

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

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

Однако эта проблема отличается от проверки того, содержит ли строка только определенную подстроку, и есть несколько способов сделать это как в Core Java , так и в Apache Commons :

Строка.StartsWith()
Stream.anyMatch()
Строка.индекс()
Шаблон с регулярным выражением
Использование цикла for
StringUtils.indexOf()
StringUtils.StartsWith()
StringUtils.startsWithAny()
StringUtils.startsWithIgnoreCase()

Ядро Java

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

Строка.StartsWith()

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

String string = "every end is a new beginning";

System.out.println(string.toLowerCase().startsWith("new".toLowerCase()));
System.out.println(string.toLowerCase().startsWith("EVERY".toLowerCase()));
System.out.println(string.toLowerCase().startsWith(""));

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

false
true
true

Примечание: Если переданный параметр является пустой строкой, результат всегда true .

Конечно, этот метод чувствителен к регистру и всегда должен использоваться в паре с прописными буквами() или прописными буквами () , когда мы просто ищем конкретное ключевое слово и нам все равно, совпадают ли регистры.

Stream.anyMatch()

Еще одна вещь, которую мы могли бы проверить, – это то, начинается ли строка с нескольких подстрок. Скажем, у нас есть несколько стандартизированных префиксов – мы можем использовать Поток подстрок и запустить любое совпадение() для проверки строки, которую мы проверяем.

Давайте посмотрим, как это сделать:

String string = "every end is a new beginning";
System.out.println(Stream.of("every", "none").anyMatch(string::startsWith));

Здесь мы создали Поток возможных подстрок и проверили, присутствуют ли какие-либо из них в начале данной строки с помощью вызова ссылки на метод StartsWith() .

Этот код приводит к:

true

Строка.индекс()

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

Метод возвращает индекс первого вхождения подстроки в строке, если она найдена, в противном случае -1 .

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

public int indexOf(String str)

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

Например:

String string = "Just a sample String";

System.out.println(string.toLowerCase().indexOf("just".toLowerCase()));
System.out.println(string.toLowerCase().indexOf("String".toLowerCase()));
System.out.println(string.toLowerCase().indexOf("something else".toLowerCase()));

выведет:

0
14
-1

Ответ, который мы ищем, найден в нашем первом примере, так как он вернулся 0 – именно то, что нам нужно, то есть ваша строка начинается с заданного параметра.
Мы можем ясно видеть, что во втором примере параметр "Строка" , который мы дали, действительно находится в нашей строке, но в позиции 14 , а это не то, что мы искали.
Третий пример даже не содержится в нашей строке и возвращает -1 .

Используя приведенную выше информацию, мы можем накопить логику в функции:

public static boolean startsWithSubstring(String text, String keyword) {
    return text.toLowerCase().indexOf(keyword.toLowerCase()) == 0;
}

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

Класс Pattern представляет собой скомпилированное представление регулярного выражения. С помощью этого Шаблона мы можем затем сгенерировать механизм, который распознает указанное регулярное выражение – мы можем сгенерировать Совпадения .

Мы будем использовать метод find() в сочетании с start () , чтобы проверить, начинается ли наш экземпляр Matcher с заданной строки:

public static boolean startsWithSubstring(String text, String keyword) {
    String inputString = text.toLowerCase();
    String subString = keyword.toLowerCase();


    // We compile the regular expression to generate a Pattern object
    Pattern pattern = Pattern.compile(subString);

    // Then we generate an engine (Matcher) which can be used
    // to recognize and match the regular expression it was
    // generated from (in our case "this").
    Matcher matcher = pattern.matcher(inputString);

    // find() compares the assigned and compiled patterns, and will return a boolean value indicating if they match.
    // That's where the start() method comes into play; it returns the index of the position 
    // where the two strings matched, or -1 if it's not found.
    if (matcher.find()) {
          return matcher.start() == 0;
    }
    return false;
}

Давайте протестируем этот метод:

System.out.println(startsWithSubstring(string, "every"));

Это приводит к:

true

Использование цикла for

Более низкоуровневым способом решения этой проблемы было бы использование цикла for.

Мы перебираем всю длину строки поиска, сравниваем первую строку поиска .длина() символов и возвращает true , если все совпадают.

Давайте посмотрим, как все это работает в коде:

public static boolean startsWithSubstring(String text, String keyword) {
    for (int i = 0; i < keyword.length(); i++) {
          if (text.toLowerCase().charAt(i) != keyword.toLowerCase().charAt(i)) {
              System.out.println("String doesn't start with " + "\"" + keyword + "\"");
        return false;
          } else if (i == keyword.length() - 1) {
              System.out.println("String starts with " + "\"" + keyword + "\"");
              return true;
          }
    }
    return false;
}

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

Давайте протестируем этот метод:

String string = "Just a sample String";

System.out.println(startsWithSubstring(string, "just"));
System.out.println(startsWithSubstring(string, "String"));
System.out.println(startsWithSubstring(string, "something else"));

Это приводит к:

String starts with "just"
true
String doesn't start with "String"
false
String doesn't start with "something else"
false

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

Apache Commons

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

Apache Commons предлагает класс StringUtils , который содержит множество методов, используемых для управления строками. Большинство из этих методов очень похожи на те, которые можно найти в java.lang.Строка . Основное отличие состоит в том, что все методы в классе StringUtils являются безопасными для нуля .

Однако для этой задачи нам понадобится всего несколько методов из этого класса:

.Индекс()
.Стартсвит()
.startsWithIgnoreCase() .

Если еще нет, включите библиотеку Apache Commons в свой проект, добавив зависимость в свой pom.xml файл, если вы используете Maven:


    org.apache.commons
    commons-lang3
    3.11

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

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

StringUtils.indexOf()

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

Мы сосредоточимся на следующем варианте этого метода:

public static int indexOf(CharSequence seq, CharSequence searchSeq)

Этот метод принимает две Строки s/|/последовательности s.

Параметр seq представляет строку, которую мы будем искать, чтобы найти searchSeq . Применяется та же логика, что и раньше – если эта функция возвращает 0 , мы будем знать, что ваша строка начинается с заданной поисковой строки подстроки.

Также имейте в виду, что этот метод, как и его аналог , также чувствителен к регистру , поэтому для обеспечения поведения без учета регистра необходимо использовать .toLowerCase() или .toUpperCase () .

Использование этого метода очень похоже на использование индекса() из java.lang.Строка :

String string = "a simple string to search in";

System.out.println(StringUtils.indexOf(string.toLowerCase(), "a simple".toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), "string".toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), "something".toLowerCase()));

Это даст:

0
9
-1

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

public static boolean startsWithSubstring(String text, String keyword) {
    return StringUtils.indexOf(text.toLowerCase(), keyword.toLowerCase()) == 0;
}

StringUtils.StartsWith()

Этот метод делает именно то, что вы ожидаете. Он также чувствителен к регистру, как и его предшественники, и принимает те же два параметра.

Он возвращает true , если текст начинается с ключевого слова , или false , если это не так.

Сравнение двух нулевых значений приведет к истине :

String string = "a simple string to search in";

System.out.println(StringUtils.startsWith(string.toLowerCase(), "A SIMPLE"));
System.out.println(StringUtils.startsWith(string.toLowerCase(), "A SIMPLE".toLowerCase()));
System.out.println(StringUtils.startsWith(null, null));

Запуск этого приведет к выходу:

false
true
true

StringUtils.startsWithAny()

startsWithAny() не имеет аналога в java.lang.Строка класс и уникальна для StringUtils .

Однако это очень близко к тому, что мы сделали с любым совпадением() в потоке – он проверяет, начинается ли Строка с любой из заданных подстрок, возвращая true или false соответствующим образом.

Это также чувствительно к регистру:

String string = "a simple string to search in";

System.out.println(StringUtils.startsWithAny(string, "something", "a simple"));
System.out.println(StringUtils.startsWithAny(string, "something", "string"));
System.out.println(StringUtils.startsWithAny(string, "something", null));
System.out.println(StringUtils.startsWithAny(string, "something", ""));

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

true
false
false
true

StringUtils.startsWithIgnoreCase()

Поскольку во время сравнения может раздражать постоянный вызов toLowerCase() для строк, вы также можете подать в суд на метод startsWithIgnoreCase () .

Как и метод StartsWith() из того же класса, он принимает два типа строк (или Последовательность символов ), и возвращаемое значение true или false в зависимости от того, действительно ли текст начинается с предоставленного ключевого слова:

String string = "a simple string to search in";

System.out.println(StringUtils.startsWithIgnoreCase(string, "something"));
System.out.println(StringUtils.startsWithIgnoreCase(string, "A SIMPLE"));
System.out.println(StringUtils.startsWithIgnoreCase(string, ""));
System.out.println(StringUtils.startsWithIgnoreCase(string, null));

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

false
true
true
false

Вывод

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

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

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

Вступление

Ядро Java

Строка.StartsWith()

Stream.anyMatch()

Строка.индекс()

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

Использование цикла for

Git Essentials

Apache Commons

StringUtils.indexOf()

StringUtils.StartsWith()

StringUtils.startsWithAny()

StringUtils.startsWithIgnoreCase()

Вывод

Читайте ещё по теме: