Java string

Введение в строки. Класс String

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

Строка представляет собой последовательность символов. Для работы со строками в Java определен класс String, который предоставляет ряд методов для манипуляции строками.
Физически объект String представляет собой ссылку на область в памяти, в которой размещены символы.

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

public static void main(String[] args) {
        
    String str1 = "Java";
    String str2 = new String(); // пустая строка
    String str3 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
    String str4 = new String(new char[]{'w', 'e', 'l', 'c', 'o', 'm', 'e'}, 3, 4);//3 -начальный индекс, 4 -кол-во символов
        
    System.out.println(str1); // Java
    System.out.println(str2); //
    System.out.println(str3); // hello
    System.out.println(str4); // come
}

При работе со строками важно понимать, что объект String является неизменяемым (immutable). То есть при любых операциях
над строкой, которые изменяют эту строку, фактически будет создаваться новая строка

Поскольку строка рассматривается как набор символов, то мы можем применить метод length() для нахождения длины строки или длины набора символов:

String str1 = "Java";
System.out.println(str1.length()); // 4

А с помощью метода toCharArray() можно обратно преобразовать строку в массив символов:

String str1 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
char[] helloArray = str1.toCharArray();

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

String s = "";   // строка не указывает на объект
if(s.length() == 0) System.out.println("String is empty");

В этом случае длина строки, возвращаемая методом length(), равна 0.

Класс String имеет специальный метод, который позволяет проверить строку на пустоту — isEmpty(). Если строка пуста, он возвращает true:

String s = "";   // строка не указывает на объект
if(s.isEmpty()) System.out.println("String is empty");

Переменная String может не указывать на какой-либо объект и иметь значение null:

String s = null;   // строка не указывает на объект
if(s == null) System.out.println("String is null");

Значение null не эквивалентно пустой строке. Например, в следующем случае мы столкнемся с ошибкой выполнения:

String s = null;   // строка не указывает на объект
if(s.length()==0) System.out.println("String is empty");	// ! Ошибка

Так как переменная не указывает ни на какой объект String, то соответственно мы не можем обращаться к методам объекта String.
Чтобы избежать подобных ошибок, можно предварительно проверять строку на null:

String s = null;   // строка не указывает на объект
if(s!=null && s.length()==0) System.out.println("String is empty");

Основные методы класса String

Основные операции со строками раскрывается через методы класса String, среди которых можно выделить следующие:

  • concat(): объединяет строки

  • valueOf(): преобразует объект в строковый вид

  • join(): соединяет строки с учетом разделителя

  • сompareTo(): сравнивает две строки

  • charAt(): возвращает символ строки по индексу

  • getChars(): возвращает группу символов

  • equals(): сравнивает строки с учетом регистра

  • equalsIgnoreCase(): сравнивает строки без учета регистра

  • regionMatches(): сравнивает подстроки в строках

  • indexOf(): находит индекс первого вхождения подстроки в строку

  • lastIndexOf(): находит индекс последнего вхождения подстроки в строку

  • startsWith(): определяет, начинается ли строка с подстроки

  • endsWith(): определяет, заканчивается ли строка на определенную подстроку

  • replace(): заменяет в строке одну подстроку на другую

  • trim(): удаляет начальные и конечные пробелы

  • substring(): возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса

  • toLowerCase(): переводит все символы строки в нижний регистр

  • toUpperCase(): переводит все символы строки в верхний регистр

Разберем работу этих методов.

НазадВперед

Производительность конкатенации

При объединении строк вам следует остерегаться возможных проблем с производительностью. Конкатенация двух строк будет преобразована компилятором Java в нечто вроде этого:

String one = "Hello";
String two = " World";

String three = new StringBuilder(one).append(two).toString();

Создается новый StringBuilder, который передает первую строку в свой конструктор, а вторую — в свой метод append(), прежде чем вызвать метод toString(). Этот код фактически создает два объекта: экземпляр StringBuilder и новый экземпляр String, возвращенный методом toString().

При выполнении самих себя в виде одного оператора эти дополнительные затраты на создание объекта незначительны. Однако когда выполняется внутри цикла, это другая история.

Вот цикл, содержащий вышеуказанный тип конкатенации строк:

String[] strings = new String[]{"one", "two", "three", "four", "five" };

String result = null;
for(String string : strings) {
    result = result + string;
}

Этот код будет скомпилирован в нечто похожее на это:

String[] strings = new String[]{"one", "two", "three", "four", "five" };

String result = null;
for(String string : strings) {
    result = new StringBuilder(result).append(string).toString();
}

Теперь для каждой итерации в этом цикле создается новый StringBuilder. Кроме того, объект String создается методом toString(). Это приводит к небольшим расходам на создание экземпляров за одну итерацию: один объект StringBuilder и один объект String. Само по себе не является настоящим убийцей производительности, хотя.

Каждый раз, когда выполняется новый код StringBuilder(result), конструктор StringBuilder копирует все символы из результирующего String в StringBuilder. Чем больше итераций цикла, тем больше будет результат String. Чем больше растет результат String, тем больше времени требуется для копирования символов из него в новый StringBuilder и повторного копирования символов из StringBuilder во временную строку, созданную методом toString(). Другими словами, чем больше итераций, тем медленнее становится каждая итерация.

Самый быстрый способ объединения строк — создать StringBuilder один раз и повторно использовать один и тот же экземпляр внутри цикла. Вот как это выглядит:

String[] strings = new String[]{"one", "two", "three", "four", "five" };

StringBuilder temp  = new StringBuilder();
for(String string : strings) {
    temp.append(string);
}
String result = temp.toString();

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

Метод format()

Для придания получившихся в итоге выполнения программы готовых строк используется метод String.format. Java обзавелась этим решением, начиная с 5 версии.

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

В общем, если нужно привести выходные значения к удобному для воприятия виду, то используется String.format. Java оборудована всем необходимым для этого.

Сравнение строк

Для простого сравнения
строк используются методы equals() (с учетом регистра) и equalsIgnoreCase()
(без учета регистра). Оба метода в качестве параметра принимают строку, с
которой сравниваются:

String str1 = "Hello";
String str2 = "hello";
 
System.out.println(str1.equals(str2)); // false
System.out.println(str1.equalsIgnoreCase(str2)); // true

Обратите
внимание, что в отличие сравнения числовых и других данных примитивных типов
для сравнения строк не рекомендуется использовать оператор ==. То есть,
записывать вот такое сравнение лучше не использовать:

if(str1 == str2) System.out.println("Сроки равны");

(хотя, оно тоже
будет работать). Вместо этого следует использовать метод equals() класса String.

Другая пара методов:

int compareTo(String str) и int compareToIgnoreCase(String str)

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

Для определения
больше или меньше одна строка, чем другая, используется лексикографический
порядок. То есть, например, строка «A» меньше, чем строка
«B», так как символ ‘A’ в алфавите стоит перед символом ‘B’. Если
первые символы строк равны, то в расчет берутся следующие символы. Например:

String str1 = "hello";
String str2 = "world";
String str3 = "hell";
 
System.out.println(str1.compareTo(str2)); // -15 - str1 меньше чем str2
System.out.println(str1.compareTo(str3)); // 1 - str1 больше чем str3
System.out.println(str1.compareTo(str1)); // 0 - str1 равна str1

Еще один
специальный метод

regionMatches()

сравнивает
отдельные подстроки в пределах двух строк. Он имеет такие реализации:

boolean
regionMatches(int toffset, String other, int oofset, int len)

boolean
regionMatches(boolean ignoreCase, int toffset, String other, int oofset, int
len)

  • ignoreCase:
    надо ли игнорировать регистр символов при сравнении (если значение true, то регистр
    игнорируется);

  • toffset:
    начальный индекс в вызывающей строке, с которого начнется сравнение;

  • other:
    строка, с которой сравнивается вызывающая;

  • oofset: начальный
    индекс в сравниваемой строке, с которого начнется сравнение;

  • len: количество
    сравниваемых символов в обеих строках.

Например, ниже в
строке str1 сравнивается
подстрока wor с подстрокой wor строки str2:

String str1 = "Hello world";
String str2 = "I work";
boolean result = str1.regionMatches(6, str2, 2, 3);
System.out.println(result); // true

Сравнение строк

В JavaScript для сравнения строк можно использовать операторы меньше и больше:

В JavaScript строки сравниваются посимвольно в алфавитном порядке. Сначала сравниваются первые символы строк, затем вторые, третьи… И как только какой-то символ оказывается меньше, строка считается меньше, даже если в строке больше символов. Если у какой-то строки заканчиваются символы, то она считается меньше, а если символы закончились у обоих строк одновременно – они одинаковые.

Но стоит отметить, что строки имеют внутреннюю кодировку Юникод – каждому символу соответствует свой числовой код.

Есть метод для получения символа по его коду String.fromCharCode():

Выполнить код »
Скрыть результаты

А вот метод charCodeAt() наоборот возвращает числовое значение Unicode символа, индекс которого был передан методу в качестве аргумента:

Выполнить код »
Скрыть результаты

А теперь давайте выведем интервал символов Unicode с кодами от 1025 до 1105:

Выполнить код »
Скрыть результаты

Как видите, не все символы в Юникоде соответствуют их месту в алфавите. Есть некоторые исключения. Строчные буквы идут после заглавных, поэтому они всегда больше. А буква ‘ё’, имеет код, больший чем ‘я’, поэтому ‘ё’(код 1105) > ‘я’(код 1103).

Для правильного сравнения строк используйте метод str1.localeCompare(str2), который сравнивает одну строку с другой и возвращает одно из трех значений:

  • Если строка str1 должна располагаться по алфавиту перед str2, возвращается -1.
  • Если строка str1 равна str2, возвращается .
  • Если строка str1 должна располагаться по алфавиту после str2, возвращается 1.

Методы String

Метод Описание
charAt() Возвращает символ строки с указанным индексом (позицией).
charCodeAt() Возвращает числовое значение Unicode символа, индекс которого был передан методу в качестве аргумента.
concat() Возвращает строку, содержащую результат объединения двух и более предоставленных строк.
fromCharCode() Возвращает строку, созданную с помощью указанной последовательности значений символов Unicode.
indexOf() Возвращает позицию первого символа первого вхождения указанной подстроки в строке.
lastIndexOf() Возвращает позицию последнего найденного вхождения подстроки или -1, если подстрока не найдена.
localeCompare() Возвращает значение, указывающее, эквивалентны ли две строки в текущем языковом стандарте.
match() Ищет строку, используя предоставленный шаблон регулярного выражения, и возвращает результат в виде массива. Если совпадений не найдено, метод возвращает значение null.
replace() Ищет строку для указанного значения или регулярного выражения и возвращает новую строку, где указанные значения будут заменены. Метод не изменяет строку, для которой он вызывается.
search() Возвращает позицию первого соответствия указанной подстроки или регулярного выражения в строке.
slice() Позволяет извлечь подстроку из строки. Первый аргумент указывает индекс с которого нужно начать извлечение. Второй необязательный аргумент указывает позицию, на которой должно остановиться извлечение. Если второй аргумент не указан, то извлечено будет все с той позиции, которую указывает первый аргумент, и до конца строки.
split() Разбивает строку на подстроки, возвращая массив подстрок. В качестве аргумента можно передать символ разделитель (например запятую), используемый для разбора строки на подстроки.
substr() Позволяет извлечь подстроку из строки. Первый аргумент указывает индекс с которого нужно начать извлечение. Второй аргумент указывает количество символов, которое нужно извлечь.
substring() Извлекает символы из строки между двух указанных индексов, если указан только один аргумент, то извлекаются символы от первого индекса и до конца строки.
toLocaleLowerCase() Преобразует символы строки в нижний регистр с учетом текущего языкового стандарта.
toLocaleUpperCase() Преобразует символы строки в верхний регистр с учетом текущего языкового стандарта.
toLowerCase() Конвертирует все символы строки в нижний регистр и возвращает измененную строку.
toString() Возвращает строковое представление объекта.
toUpperCase() Конвертирует все символы строки в верхний регистр и возвращает измененную строку.
trim() Удаляет пробелы в начале и конце строки и возвращает измененную строку.
valueOf() Возвращает примитивное значение объекта.

Разбиение строки на подстроки

Метод split()
позволяет разбить строку на подстроки по определенному разделителю. Разделитель
– это какой-нибудь символ или набор символов (передается в качестве параметра).
Например, разобьем текст на отдельные слова (учитывая, что слова разделены
пробелом):

String text = "Я люблю язык Java!";
String words = text.split(" ");
 
for(String word  words)
    System.out.println(word);

Видео по теме

#1 Установка пакетов и первый запуск программы

#2 Структура программы, переменные, константы, оператор присваивания

#3 Консольный ввод/вывод, импорт пакетов

#4 Арифметические операции

#5 Условные операторы if и switch

#6 Операторы циклов while, for, do while

#7 Массивы, обработка элементов массива

#8 (часть 1) Строки в Java, методы класса String

#8 (часть 2) Строки — классы StringBuffer и StringBuider

#9 Битовые операции И, ИЛИ, НЕ, XOR

#10 Методы, их перегрузка и рекурсия

5 ответов

Лучший ответ

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

Дает тебе:

1

Bentaye
5 Мар 2018 в 14:42

1

Santosh Thapa
5 Мар 2018 в 09:35

Вы можете использовать регулярные выражения:

1

thibsc
5 Мар 2018 в 09:37

Ниже у вас есть мое предложение. Работает правильно для упомянутых тестовых данных

( 1a, 12a, 1ab, 12ab, 123a, 123abc )

Решение:

1

Schakal
5 Мар 2018 в 10:02

Объяснение :

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

— граница слова

— цифра от одного до трех раз

— символы от до от одного до трех раз

— это положительный взгляд, вы говорите, что после этих букв вы хотите присутствовать или границы слова, но вы не хотите, чтобы они присутствовали в соответствующей группе (вызывается с {{ Х2 } } )

— совпадающие группы в скобках — в моем регулярном выражении я использовал две совпадающие группы: # 1: # 2: (они печатаются с и {{ Х4 } } )

Если вы еще не очень знакомы с синтаксисом регулярных выражений, возможно, вы захотите взглянуть на документацию Java API по адресу класс Pattern. Существует список доступных вариантов использования регулярных выражений. Стоит попробовать регулярные выражения, так как это может сэкономить много времени при работе со строками в будущем.

Редактировать:

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

Есть положительный вид сзади — это означает, что вы хотите, чтобы цифрам предшествовала граница слова (включая запятые в заголовке и lookbehind было избыточно, поэтому я удалил его).

1

Przemysław Moskal
5 Мар 2018 в 11:07

Действительно ли объект String неизменен?

Как упоминалось выше, хотя value украшен final, это может гарантировать только то, что vaue не может указывать на другие объекты, но состояние объекта, на который указывает value, может быть изменено, то есть элементы в массиве символов, на который указывает value, могут быть изменены. Поскольку value имеет частный тип, вы можете использовать отражение только для получения атрибута value объекта String, а затем изменить элементы в массиве символов, на которые указывает значение. Подтвердите с помощью следующего кода:

Результат печати:

В приведенном выше коде s всегда указывает на один и тот же объект String, но после операции отражения содержимое этого объекта String изменяется. Другими словами, неизменяемые объекты, такие как String, могут быть изменены посредством отражения.

2. Цели проектирования (почему String должен быть неизменным)

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

Метод сравнения String equalsIgnoreCase()

С помощью метода equalsIgnoreCase() вы выполните сравнение строк, что называется, лексикографически, причём различия регистра будут игнорированы. Здесь значение true возвращается в том случае, если аргумент является объектом String и представляет такую же последовательность символов, что и у объекта. Прекрасное решение, если надо осуществить проверку строки на равенство, не учитывая при этом регистр.

class TestClass{
  public static void main (String[] args){
    String str1 = "Java";
    String str2 = "JAVA";
    // возвращается true, ведь обе строки равны без учёта регистра
    if(str1.equalsIgnoreCase(str2)){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
    // возвращается false, т. к. учитывается регистр символов
    if(str1.equals(str2)){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
  }
}

Результат

Statement  is true
Statement is false

Анализ неизменности класса String.

Сначала посмотрите на следующий код:

Результат печати:

Увидев это, вы можете усомниться в том, что String является неизменяемым объектом, потому что из распечатанного результата видно, что значение s действительно изменилось. На самом деле это не так, потому что s — это просто ссылка на объект String, а не на сам объект String. Когда выполняется строка кода в (1), в пуле констант времени выполнения области метода будет создан объект String «abc», а затем ссылка на объект String будет создана в стеке Java. s, и пусть s указывает на «abc», как показано ниже:

фигура 1

Когда строка кода в (2) выполняется, новый объект String «123» будет создан в пуле констант времени выполнения области метода, а затем ссылка s будет перенаправлена ​​на этот новый объект, а исходный объект «abc» В памяти нет изменений, как показано на следующем рисунке:

фигура 2

Принцип неизменности класса String.

Чтобы понять неизменность класса String, сначала посмотрите, какие переменные-члены находятся в классе String. В JDK1.8 переменные-члены String в основном имеют следующее:

Прежде всего, вы можете видеть, что класс String использует модификатор final, указывая на то, что класс String не наследуется. Затем мы в основном сосредотачиваемся на значении переменной-члене класса String. Это значение имеет тип char [], поэтому объект String фактически инкапсулируется с этим массивом символов. Если посмотреть на модификатор значения, используется private, а метод setter не предоставляется. Следовательно, значение не может быть изменено за пределами класса String, а значение также изменяется с помощью final. Тогда значение не может быть изменено внутри класса String, но приведенное выше является окончательным. В содержании измененных переменных ссылочного типа упоминалось, что это может только гарантировать, что значение не может указывать на другие объекты, но состояние объекта, на который указывает значение, может быть изменено.Посмотрев на исходный код класса String, мы можем обнаружить, что класс String является неизменным.Ключ состоит в том, что инженеры компании SUN очень осторожны, чтобы не перемещать элементы в массиве символов во всех стоящих за ним методах String. Таким образом, ключ к неизменности класса String заключается в базовой реализации, а не только в финале.

Нахождение длины строки

java string length() возвращает общее количество символов в строке. Длина строки Java такая же, как в коде Unicode.

Пример:

public class LengthExample{  
public static void main(String args[]){  
String s1="javatpoint";  
String s2="python";  
System.out.println("string length is: "+s1.length());//10 is the length of javatpoint string  
System.out.println("string length is: "+s2.length());//6 is the length of python string  
}}  

Еще один способ:

public class LengthExample2 {  
    public static void main(String[] args) {  
        String str = "Javatpoint";  
        if(str.length()>0) {  
            System.out.println("String is not empty and length is: "+str.length());  
        }  
        str = "";  
        if(str.length()==0) {  
            System.out.println("String is empty now: "+str.length());  
        }  
    }  
}  

Соединение строк в Java

Чтобы соединить строки в Java, подойдёт операция сложения «+»:

String str1 = "Java";
String str2 = "Hi";
String str3 = str1 + " " + str2;

System.out.println(str3); // Hi Java

Если же в предстоящей операции сложения строк будет применяться нестроковый объект, допустим, число, данный объект преобразуется к строке:

String str3 = "Год " + 2020;

По факту, когда мы складываем строки с нестроковыми объектами, вызывается метод valueOf() класса String. Этот метод преобразует к строке почти все типы данных. Чтобы преобразовать объекты разных классов, valueOf вызывает метод toString() данных классов.

Объединять строки можно и с помощью concat():

String str1 = "Java";
String str2 = "Hi";
str2 = str2.concat(str1); // HiJava

Метод принимает строку, с которой нужно объединить вызывающую строку, возвращая нам уже соединённую строку.

Также мы можем использовать метод join(), позволяющий объединять строки с учетом разделителя. Допустим, две строки выше слились в слово «HiJava», однако мы бы хотели разделить подстроки пробелом. Тут и пригодится join():

String str1 = "Java";
String str2 = "Hi";
String str3 = String.join(" ", str2, str1); // Hi Java

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

Разделение

Класс Java String содержит метод split(), который можно использовать для разделения String на массив объектов String:

String   source = "A man drove with a car.";
String[] occurrences = source.split("a");

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

"A m"
"n drove with "
" c"
"r."

Исходная строка была разделена на символы a. Возвращенные строки не содержат символов a. Символы a считаются разделителями для деления строки, а разделители не возвращаются в результирующий массив строк.

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

Метод String split() существует в версии, которая принимает ограничение в качестве второго параметра — limit:

String   source = "A man drove with a car.";
int      limit  = 2;
String[] occurrences = source.split("a", limit);

Параметр limit устанавливает максимальное количество элементов, которое может быть в возвращаемом массиве. Если в строке больше совпадений с регулярным выражением, чем заданный лимит, то массив будет содержать совпадения с лимитом — 1, а последним элементом будет остаток строки из последнего среза — 1 совпадением. Итак, в приведенном выше примере возвращаемый массив будет содержать эти две строки:

"A m"
"n drove with a car."

Первая строка соответствует регулярному выражению. Вторая — это остальная часть строки после первого куска.

Выполнение примера с ограничением 3 вместо 2 приведет к тому, что эти строки будут возвращены в результирующий массив String:

"A m"
"n drove with "
" car."

Обратите внимание, что последняя строка по-прежнему содержит символ в середине. Это потому, что эта строка представляет остаток строки после последнего совпадения (a после ‘n водил с’)

Выполнение приведенного выше примера с пределом 4 или выше приведет к тому, что будут возвращены только строки Split, поскольку в String есть только 4 совпадения с регулярным выражением a.

Константы

Если вы используете ту же строку (например, «Hello World») в других объявлениях переменных String, виртуальная машина Java может создать в памяти только один экземпляр String. Таким образом, строковый литерал становится де-факто константой или синглтоном. Различные переменные, инициализированные одной и той же константной строкой, будут указывать на один и тот же экземпляр String в памяти.

String myString1 = "Hello World";
String myString2 = "Hello World";

В этом случае виртуальная машина заставит myString1 и myString2 указывать на один и тот же объект String.

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

Если вы хотите быть уверены, что две строковые переменные указывают на отдельные строковые объекты, используйте оператор new следующим образом:

String myString1 = new String("Hello World");
String myString2 = new String("Hello World");

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

StartWith() и EndWith()

Методы StartWith() и EndWith() проверяют, начинается ли String с определенной подстроки:

String one = "This is a good day to code";

System.out.println( one.startsWith("This")    );
System.out.println( one.startsWith("This", 5) );

System.out.println( one.endsWith("code")    );
System.out.println( one.endsWith("shower")  );

В этом примере создается строка и проверяется, начинается ли она и заканчивается ли она различными подстроками.

  • Первая строка (после объявления String) проверяет, начинается ли String с подстроки «This». Поскольку это происходит, метод startWith() возвращает true.
  • Вторая строка проверяет, начинается ли строка с подстроки «This» при запуске сравнения с символа с индексом 5. Результат равен false, поскольку символ с индексом 5 равен «i».
  • Третья строка проверяет, заканчивается ли String подстрокой «code». Поскольку это происходит, метод endWith() возвращает true.
  • Четвертая строка проверяет, заканчивается ли String подстрокой «shower». Так как это не так, метод endWith() возвращает false.
Добавить комментарий

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

Adblock
detector