Можно ли обратиться к элементу строки с заданным номером как это сделать

Добавил пользователь Алексей Ф.
Обновлено: 02.10.2024

Функциональность класса System.String наиболее полно раскрывается через его методы, основными из которых являются следующие:

Compare — сравнивает две строки с учетом текущих региональных настроек (локали) пользователя
CompareOrdinal — сравнивает две строки без учета локали
Contains — проверяет, содержится ли заданная подстрока в строке
Concat — объединяет строки
CopyTo — копирует часть строки, начиная с определенного индекса, в массив
EndsWith — проверяет совпадает ли конец строки с подстрокой
Format — форматирует строку
IndexOf — находит индекс первого вхождения символа или подстроки в строке
Insert — вставляет в строку подстроку
Join — соединяет элементы массива строк
LastIndexOf — находит индекс последнего вхождения символа или подстроки в строке
Replace — заменяет в строке символ или подстроку другим символом или подстрокой
Split — разделяет одну строку на массив строк
Substring — извлекает из строки подстроку, начиная с указанной позиции
ToLower — переводит все символы строки в нижний регистр
ToUpper — переводит все символы строки в верхний регистр
Trim — удаляет начальные и конечные пробелы из строки

Рассмотрим представленные методы более подробно.

Результатом выполнения метода является целое число Int32. Это число означает следующее:

Результат Compare	Что означает
Меньше нуля	strA предшествует strB в порядке сортировки (стока strA меньше строки strB ).
Нуль	strA занимает ту же позицию в порядке сортировки, что и объект strB (строки равны)
Больше нуля	strA следует за strB в порядке сортировки (стока strA больше строки strB ).

Вернет значение 0 так как строки равны.

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

или определить свои настройки сравнения строк, используя следующий вариант метода Compare :

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

Метод CompareOrdinal сравнивает два объекта String , оценивая числовые значения соответствующих объектов Char в каждой строке. Результат выполнения метода такой же, как и у предыдущего метода Compare (см. таблицу выше).

Метод Contains проверяет, входит ли заданная подстрока в строку. Этот метод не статический, поэтому использовать его необходимо только после создания объекта, то есть следующим образом:

В примере выше мы проверяем содержится ли подстрока "ока" в строке "Строка" . Очевидно, что результатом выполнения метода будет true .

Также возможно объединять и массивы строк:

Для приведенного выше примера в консоли мы получим следующую объединенную строку:

Для того, чтобы продемонстрировать работу метода, воспользуемся следующим примером:

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

В этом примере из строки s6 копируется 4 символа, начиная с символа с индексом 2 (так как нумерация начинается с нуля, то первый копируемый символ r ) и вставляется в массив charArr , начиная с первого элемента (с индексом 0 )

Также можно воспользоваться статическим методом Copy для создания полной копии строки:

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

Результатом будет следующая строка:

Этот метод возвращает индекс первого вхождения указанного символа или подстроки в строку. Например,

Результатом выполнения будут следующие строки в консоли:

Индекс первого символа искомой подстроки 18

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

Этот метод вставляет в строку, начиная с индекса startIndex подстроку value и возвращает в результате новый экземпляр строки. Например,

Например, заменим все символы o с строке на символы А :

В качестве параметров метод Split принимает один или несколько символов ( Char ), используемых в качестве разделителя, а на выходе возвращает массив строк. Рассмотрим работу метода Split на примере

Здесь в качестве разделителей мы используем два символа — пробел и запятую. Результатом выполнения кода будет следующий вывод в консоли:

Для извлечения подстрок из строки используется метод Substring :

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

Пример использования метода представлен ниже:

Метод ToLower меняет регистр всех символов в строке на нижний, а метод ToUpper , напротив — меняет регистр всех символов в строке на верхний. Пример

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

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

Что такое строка в Python?

Строка Python – это набор символов, заключенных в одинарные, двойные или тройные кавычки. Компьютер не понимает персонажей; внутри он хранит манипулируемый символ как комбинацию нулей и единиц.

Каждый символ кодируется символом ASCII или Unicode. Таким образом, мы можем сказать, что строки Python также называются набором символов Unicode.

В Python строки можно создавать, заключая символ или последовательность символов в кавычки. Python позволяет нам использовать одинарные кавычки, двойные кавычки или тройные кавычки для создания строки.

Рассмотрим следующий пример на Python для создания строки.

Проверим тип переменной str с помощью скрипта

В Python строки рассматриваются как последовательность символов, что означает, что Python не поддерживает символьный тип данных; вместо этого одиночный символ, записанный как ‘p’, рассматривается как строка длины 1.

Создание строки в Python

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

Индексирование и разбивка строк

Рассмотрим следующий пример:

Как показано в Python, оператор slice [] используется для доступа к отдельным символам строки. Однако мы можем использовать оператор:(двоеточие) в Python для доступа к подстроке из данной строки. Рассмотрим следующий пример.

Здесь мы должны заметить, что верхний диапазон, указанный в операторе среза, всегда является исключающим, т.е. если задано str = ‘HELLO’, тогда str [1: 3] всегда будет включать str [1] = ‘E’, str [2 ] = ‘L’ и ничего больше.

Рассмотрим следующий пример:

Мы можем сделать отрицательную нарезку строки; она начинается с крайнего правого символа, который обозначается как -1. Второй крайний правый индекс указывает -2 и так далее. Рассмотрим следующее изображение.

Рассмотрим следующий пример:

Переназначение строк

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

Рассмотрим следующий пример.

Однако в примере 1 строку str можно полностью присвоить новому содержимому, это указано в следующем примере.

Удаление строки

Как мы знаем, строки неизменяемы. Мы не можем удалить символы из строки. Но мы можем удалить всю строку с помощью ключевого слова del.

Теперь мы удаляем всю строку.

Строковые операторы

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

Форматирование строки Python

Управляющая последовательность

Предположим, нам нужно написать текст – They said, “Hello what’s going on?” – данный оператор может быть записан в одинарные или двойные кавычки, но он вызовет ошибку SyntaxError, поскольку он содержит как одинарные, так и двойные кавычки.

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

Мы можем использовать тройные кавычки для решения этой проблемы, но Python предоставляет escape-последовательность.

Символ обратной косой черты(/) обозначает escape-последовательность. За обратной косой чертой может следовать специальный символ, который интерпретируется по-разному. Одиночные кавычки внутри строки должны быть экранированы. Мы можем применить то же самое, что и в двойных кавычках.

Список escape-последовательностей приведен ниже:

Вот простой пример escape-последовательности.

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

Метод format()

Метод format() – самый гибкий и полезный метод форматирования строк. Фигурные скобки <> используются в качестве заполнителя в строке и заменяются аргументом метода format(). Посмотрим на данный пример:

Форматирование строки Python с использованием оператора %

Python позволяет нам использовать спецификаторы формата, используемые в инструкции printf языка C. Спецификаторы формата в Python обрабатываются так же, как и в C. Однако Python предоставляет дополнительный оператор%, который используется в качестве интерфейса между спецификаторами формата и их значениями. Другими словами, мы можем сказать, что он связывает спецификаторы формата со значениями.

Рассмотрим следующий пример.

Строковые функции Python

Python предоставляет различные встроенные функции, которые используются для обработки строк.

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

Общее представление о массиве

Массив (в питоне еще принято название "список", это то же самое) — это переменная, в которой хранится много значений. Массив можно представлять себе в виде такой последовательности ячеек, в каждой из которых записано какое-то число:

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

a = [7, 5, -3, 12, 2, 0]

Теперь переменная a хранит этот массив. К элементам массива можно обращаться тоже через квадратные скобки: a[2] — это элемент номер 2, т.е. в нашем случае это -3 . Аналогично, a[5] — это 0. В квадратных скобках можно использовать любые арифметические выражения и даже другие переменные: a[2*2-1] — это 12, a[i] обозначает "возьми элемент с номером, равным значению переменной i ", аналогично a[2*i+1] обозначает "возьми элемент с номером, равным 2*i+1", или даже a[a[4]] обозначает "возьми элемент с номером, равным четвертому элементу нашего массива" (в нашем примере a[4] — это 2 , поэтому a[a[4]] — это a[2] , т.е. -3 ).

Если указанный номер слишком большой (больше длины массива), то питон выдаст ошибку (т.е. в примере выше a[100] будет ошибкой, да и даже a[6] тоже). Если указан отрицательный номер, то тут действует хитрое правило. Отрицательные номера обозначают нумерацию массива с конца: a[-1] — это всегда последний элемент, a[-2] — предпоследний и т.д. В нашем примере a[-6] равно 7. Слишком большой отрицательный номер тоже дает ошибку (в нашем примере a[-7] уже ошибка).

С элементами массива можно работать как с привычными вам переменными. Можно им присваивать значения: a[3] = 10 , считывать с клавиатуры: a[3] = int(input()) , выводить на экран: print(a[3]) , использовать в выражениях: a[3+i*a[2]] = 3+abs(a[1]-a[0]*2+i) (здесь i — какая-то еще целочисленная переменная для примера), использовать в if'ах: if a[i]>a[i-2]: , или for a[2] in range(i) и т.д. Везде, где вы раньше использовали переменные, можно теперь использовать элемент массива.

Обход массива

Но обычно вам надо работать сразу со всеми элементами массива. Точнее, сразу со всеми как правило не надо, надо по очереди с каждым (говорят: "пробежаться по массиву"). Для этого вам очень полезная вещь — это цикл for . Если вы знаете, что в массиве n элементов (т.е. если у вас есть переменная n и в ней хранится число элементов в массиве), то это делается так:

например, вывести все элементы массива на экран:

или увеличить все элементы массива на единицу:

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

Если же у вас нет переменной n , то вы всегда можете воспользоваться специальной функцией len , которая возвращает количество элементов в массиве:

for i in range(len(a)): .

Функцию len , конечно, можно использовать где угодно, не только в заголовке цикла. Например, просто вывести длину массива — print(len(a)) .

Операции на массиве

Еще ряд полезных операций с массивами:

a[i] (на всякий случай повторю, чтобы было легче найти) — элемент массива с номером i .
len(a) (на всякий случай повторю, чтобы было легче найти) — длина массива.
a.append(x) — приписывает к массиву новый элемент со значением x , в результате длина массива становится на 1 больше. Конечно, вместо x может быть любое арифметическое выражение.
a.pop() — симметричная операция, удаляет последний элемент из массива. Длина массива становится на 1 меньше. Если нужно запомнить значение удаленного элемента, надо просто сохранить результат вызова pop в новую переменную: res = a.pop() .
a * 3 — это массив, полученный приписыванием массива a самого к себе три раза. Например, [1, 2, 3] * 3 — это [1, 2, 3, 1, 2, 3, 1, 2, 3] . Конечно, на месте тройки тут может быть любое арифметическое выражение. Самое частое применение этой конструкции — если вам нужен массив длины n , заполненный, например, нулями, то вы пишете [0] * n .
b = a — присваивание массивов. Теперь в b записан тот же массив, что и в a . Тот же — в прямом смысле слова: теперь и a , и b соответствуют одному и тому же массиву, и изменения в b отразятся в a и наоборот. Еще раз, потому что это очень важно. Присваивание массивов (и вообще любых сложных объектов) в питоне не копирует массив, а просто обе переменные начинают ссылаться на один и тот же массив, и изменения массива через любую из них меняет один и тот же массив. При этом на самом деле тут есть многие тонкости, просто будьте готовы к неожиданностям.
b = a[1:4] ("срез") — делает новый массив, состоящий из элементов старого массива начиная со первого (помните про нумерацию с нуля!) и заканчивая третьим (т.е. до четвертого, но не включительно, аналогично тому, как работает range ); этот массив сохраняется в b . Для примера выше получится [5, -3, 12] . Конечно, на месте 1 и 4 может быть любое арифметическое выражение. Более того, эти индексы можно вообще не писать, при этом автоматически подразумевается начало и конец массива. Например, a[:3] — это первые три элемента массива (нулевой, первый и второй), a[1:] — все элементы кроме нулевого, a[:-1] — все элементы кроме последнего (!), а a[:] — это копия всего массива. И это именно копия, т.е. запись b = a[:] именно копирует массив, получающиеся массивы никак не связаны, и изменения в b не влияют на a (в отличие от b = a ).

Ввод-вывод массива

Как вам считывать массив? Во-первых, если все элементы массива задаются в одной строке входного файла. Тогда есть два способа. Первый — длинный, но довольно понятный:

Второй — покороче, но попахивает магией:

Может показаться страшно, но на самом деле map(int, input().split()) вы уже встречали в конструкции

когда вам надо было считать два числа из одной строки. Это считывает строку ( input() ), разбивает по пробелам ( .split() ), и превращает каждую строку в число ( map(int, . ) ). Для чтения массива все то же самое, только вы еще заворачиваете все это в list(. ) , чтобы явно сказать питону, что это массив.

Какой из этих двух способов использовать для чтения данных из одной строки — выбирать вам.

Обратите внимание, что в обоих способах вам не надо знать заранее, сколько элементов будет в массиве — получится столько, сколько чисел в строке. В задачах часто бывает что задается сначала количество элементов, а потом (обычно на следующей строке) сами элементы. Это удобно в паскале, c++ и т.п., где нет способа легко считать числа до конца строки; в питоне вам это не надо, вы легко считываете сразу все элементы массива до конца строки, поэтому заданное число элементов вы считываете, но дальше не используете:

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

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

Как выводить массив? Если надо по одному числу в строку, то просто:

Если же надо все числа в одну строку, то есть два способа. Во-первых, можно команде print передать специальный параметр end=" " , который обозначает "заканчивать вывод пробелом (а не переводом строки)":

Есть другой, более простой способ:

Эта магия обозначает вот что: возьми все элементы массива a и передай их отдельными аргументами в одну команду print . Т.е. получается print(a[0], a[1], a[2], . ) .

Двумерные массивы

Выше везде элементами массива были числа. Но на самом деле элементами массива может быть что угодно, в том числе другие массивы. Пример:

Что здесь происходит? Создаются три обычных массива a , b и c , а потом создается массив z , элементами которого являются как раз массивы a , b и c .

Что теперь получается? Например, z[1] — это элемент №1 массива z , т.е. b . Но b — это тоже массив, поэтому я могу написать z[1][2] — это то же самое, что b[2] , т.е. -3 (не забывайте, что нумерация элементов массива идет с нуля). Аналогично, z[0][2]==30 и т.д.

То же самое можно было записать проще:

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

z содержит три элемента, и не важно, что каждый из них тоже массив), а len(z[2]) — длина внутреннего массива на позиции 2 (т.е. 2 в примере выше). Для массива x выше (того, у которого каждый подмассив имеет свою длину) получим len(x)==5 , и, например, len(x[3])==0 .

Аналогично работают все остальные операции. z.append([1,2]) приписывает к "внешнему" массиву еще один "внутренний" массив, а z[2].append(3) приписывает число 3 к тому "внутреннему" массиву, который находится на позиции 2. Далее, z.pop() удаляет последний "внутренний" из "внешнего" массива, а z[2].pop() удаляет последний элемент из "внутреннего" массива на позиции 2. Аналогично работают z[1:2] и z[1][0:1] и т.д. — все операции, которые я приводил выше.

Обход двумерного массива

Конечно, чтобы обойти двумерный массив, надо обойти каждый его "внутренний" массив. Чтобы обойти внутренний массив, нужен цикл for , и еще один for нужен, чтобы перебрать все внутренние массивы:

Создание пустого массива

Неожиданно нетривиальная операция на двумерных массивах — это создание двумерного массива определенного размера, заполненного, например, нулями. Вы помните, что одномерный массив длины n можно создавать как [0] * n . Возникает желание написать a = ([0] * m) * n , чтобы создать двумерный массив размера n x m (мы хотим, чтобы первый индекс массива менялся от 0 до n-1 , а второй индекс до m-1 , поэтому это именно ([0] * m) * n , а не ([0] * n) * m ). Но это сработает не так, как вы можете думать. Дело опять в том, что в питоне массивы по умолчанию не копируются полностью, поэтому то, что получается — это массив длина n , в котором каждый элемент соответствует одному и тому же массиву длины n . В итоге, если вы будете менять, например, a[1][2] , то так же будет меняться и a[0][2] , и a[3][2] и т.д. — т.к. все внутренние массивы на самом деле соответствуют одному и тому же массиву.

Поэтому массив размера n x m делается, например, так:

мы вручную n раз приписали к массиву a один и тот же массив.

Или еще есть магия в одну строчку:

a = [[0] * m for i in range(n)]

Я пока не буду объяснять, как это работает, просто можете запомнить. Или пользоваться предыдущим вариантом.

Обратите внимание, что тут важный момент — хотим мы, чтобы n соответствовало первому индексу или второму. В примерах выше n — размер первого индекса (т.е. размер "внешнего" массива), a m — размер второго индекса (т.е. размер каждого "внутреннего" массива). Если вы хотите, то можно делать и наоборот, но это вы сами должны решить и делать согласованно во всей программе.

Ввод-вывод двумерного массива

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

Мы считываем очередную строку и получаем очередной "внутренний" массив: list(map(int, input().split())) , и приписываем его ( append ) ко внешнему массиву.

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

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

Многомерные массивы

Аналогично двумерным, бывают и трехмерные и т.д. массивы. Просто каждый элемент "внутреннего" массива теперь сам будет массивом:

Здесь a[0] — это двумерный массив [[1, 2], [3, 4]] , и a[1] — двумерный массив [[5, 6], [7, 8]] . Например, a[1][0][1] == 6 .

Многомерные массивы в простых задачах не нужны, но на самом деле бывают полезны и не представляют из себя чего-то особо сложного. С ними все аналогично тому, что мы обсуждали про двумерные массивы.

Для соединения строк можно использовать операцию сложения ("+"):

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

Фактически же при сложении строк с нестроковыми объектами будет вызываться метод valueOf() класса String. Данный метод имеет множество перегрузок и преобразует практически все типы данных к строке. Для преобразования объектов различных классов метод valueOf вызывает метод toString() этих классов.

Другой способ объединения строк представляет метод concat() :

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

Еще один метод объединения - метод join() позволяет объединить строки с учетом разделителя. Например, выше две строки сливались в одно слово "HelloJava", но в идеале мы бы хотели, чтобы две подстроки были разделены пробелом. И для этого используем метод join() :

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

Извлечение символов и подстрок

Для извлечения символов по индексу в классе String определен метод char charAt(int index) . Он принимает индекс, по которому надо получить символов, и возвращает извлеченный символ:

Как и в массивах индексация начинается с нуля.

Если надо извлечь сразу группу символов или подстроку, то можно использовать метод getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) . Он принимает следующие параметры:

srcBegin : индекс в строке, с которого начинается извлечение символов

srcEnd : индекс в строке, до которого идет извлечение символов

dst : массив символов, в который будут извлекаться символы

dstBegin : индекс в массиве dst, с которого надо добавлять извлеченные из строки символы

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

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

В отличие от сравнения числовых и других данных примитивных типов для строк не применяется знак равенства ==. Вместо него надо использовать метод equals() .

Еще один специальный метод regionMatches() сравнивает отдельные подстроки в рамках двух строк. Он имеет следующие формы:

Метод принимает следующие параметры:

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

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

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

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

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

В данном случае метод сравнивает 3 символа с 6-го индекса первой строки ("wor") и 3 символа со 2-го индекса второй строки ("wor"). Так как эти подстроки одинаковы, то возвращается true .

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

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

Поиск в строке

Метод indexOf() находит индекс первого вхождения подстроки в строку, а метод lastIndexOf() - индекс последнего вхождения. Если подстрока не будет найдена, то оба метода возвращают -1:

Метод startsWith() позволяют определить начинается ли строка с определенной подстроки, а метод endsWith() позволяет определить заканчивается строка на определенную подстроку:

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

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

Обрезка строки

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

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

Изменение регистра

Метод toLowerCase() переводит все символы строки в нижний регистр, а метод toUpperCase() - в верхний:

Split

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

Читайте также: