Как найти последнее вхождение подстроки в строку

Sometimes, while working with strings, we need to find if a substring exists in the string. This problem is quite common and its solution has been discussed many times before. The variation of getting the last occurrence of the string is discussed here. Let’s discuss certain ways in which we can find the last occurrence of substring in string in Python. 

Using rindex() to find last occurrence of substring

rindex() method returns the last occurrence of the substring if present in the string. The drawback of this function is that it throws the exception if there is no substring in the string and hence breaks the code. 

The original string : GfG is best for CS and also best for Learning
Index of last occurrence of substring is : 28

Using rfind() to find last occurrence of substring

rfind() is the alternate method to perform this task. The advantage that this function offers better than the above method is that, this function returns a “-1” if a substring is not found rather than throwing the error. 

The original string : GfG is best for CS and also best for Learning
Index of last occurrence of substring is : 28

Using lambda() with rlocate() function

Here we are using the more_itertools library that provides us with rlocate() function that helps us to find the last occurrence of the substring in the given string.

Output:

The original string : GfG is best for CS and also best for Learning
Index of last occurrence of substring is : 28

Using find() and replace() methods

The original string : GfG is best for CS and also best for Learning
Index of last occurrence of substring is : 28

Time Complexity: O(n), where n is length of test_string.

Auxiliary Space: O(1)

Using the re module:

The re (regular expression) module in Python allows you to search for patterns in strings. In this approach, we use the finditer function from the re module to find all occurrences of the substring in the string. The finditer function returns an iterator yielding MatchObject instances that have information about the search, such as the start and end indices of the match.

We can then use a for loop to iterate through the matches and keep track of the index of the last occurrence by updating the last_occurrence variable whenever we find a match. Finally, we print the index of the last occurrence.

Index of last occurrence of substring is: 28

Time complexity: O(n), where n is the length of the string
Auxiliary Space : O(n)

Using reversed() function and index()

Step-by-step approach:

1. Reverse the test_string and tar_word
2. Use the index() method to get the first occurrence of the reversed tar_word in the reversed test_string.
3. Calculate the index of the last occurrence of the tar_word by subtracting the index from the length of the test_string and the length of the tar_word.

Index of last occurrence of substring is : 28

Time complexity: O(n) where n is the length of the string
Space complexity: O(1)

Using the numpy:

Algorithm:

1. Initialize the test string and target word.
2. Create an empty numpy array to store the indices of all occurrences of the target word.
3. Iterate over all possible substrings of length equal to the length of the target word in the test string. For each substring, check if it matches the target word or not. If the substring matches the target word, append the index of the first character of the substring to the numpy array.
4. Check if any occurrences of the target word were found or not. If the numpy array is not empty, set the result to be the last element of the array (i.e., the index of the last occurrence of the target word in the test string). Otherwise, set the result to -1 (indicating that the target word was not found in the test string).
5. Print the original string and the index of the last occurrence of the target word (or -1 if the target word was not found).

Below is the implementation of the above approach:

Output:

The original string : GfG is best for CS and also best for Learning
Index of last occurrence of substring is : 28

Time Complexity: O(n * m), where n is the length of the test string and m is the length of the target word. This is because the list comprehension iterates over all possible substrings of length m in the test string, which takes O(n * m) time in the worst case.

Space Complexity: O(k), where k is the number of occurrences of the target word in the test string. This is because the indices of all occurrences of the target word are stored in a numpy array, which takes O(k) space. The rest of the variables used in the code take constant space.

Using rpartition() method

• Define the string and target word to find last occurrence of substring.
• Use the rpartition() method to split the string at the last occurrence of the target word.
• If the length of split list is 1, print that the substring was not found in the string.
• Otherwise, calculate the index of the last occurrence of the target word using the length of the original string, the length of the third element in the split list (which contains the characters after the last occurrence of the target word), and the length of the target word.
• Print the index of the last occurrence of the target word.

The original string : GfG is best for CS and also best for Learning
Index of last occurrence of substring is : 28

Time Complexity: O(n), where n is the length of the input string.

Auxiliary Space: O(1), as no extra is used.

Last Updated :
17 Apr, 2023

Like Article

Save Article

Обзор PHP-функций для работы со строками и практическое их применение с учетом кодировки UTF-8.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';

echo strlen($text); // 105
echo mb_strlen($text); // 59

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$str = mb_ereg_replace('[s]', '', $text);
echo mb_strlen($str); // 49

$text = 'Lorem Ipsum - is simply dummy!';
echo str_word_count($text); // 6

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo str_word_count($text); // 1

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$str = preg_replace("/[[:punct:]]/", '', $text);
$str = mb_ereg_replace('[s]+', ' ', $str);
$words = explode(' ', $str);
echo count($words); // 10

$text = 'Съешь ещё - этих 
мягких французских булок, 
да выпей же чаю.';

echo substr_count($text, PHP_EOL); // 2

$text = 'Съешь ещё этих мягких французских булок, да выпей же чаю.';
echo $str = preg_replace('/[^a-zа-яё]/ui', '', $text);
echo mb_strlen($str); // 46

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$str = preg_replace('/[^0-9]/ui', '', $text);
echo mb_strlen($str); // 0

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$str = preg_replace("/[^[:punct:]]/", '', $text);
echo mb_strlen($str); // 3

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo substr_count($text, ' '); // 10

$text = '     Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_strlen($text) - mb_strlen(ltrim($text, ' ')); // 5

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.   ';
echo mb_strlen($text) - mb_strlen(rtrim($text, ' ')); // 3

$text = 'Съешь ещё - этих мягких французских булок, да ещё выпей же чаю.';
echo mb_substr_count($text, 'ещё'); // 2

$text = 'Съешь ещё - этих мягких французских булок, да ещё выпей же чаю.';
echo mb_strpos($text, 'ещё'); // 6

// Без учета регистра:
$text = 'Съешь ещё - этих мягких французских булок, да ещё выпей же чаю.';
echo mb_stripos($text, 'ещё'); // 6

$text = 'Съешь ещё - этих мягких французских булок, да ещё выпей же чаю.';
echo mb_strrpos($text, 'ещё'); // 46

// Без учета регистра:
$text = 'Съешь ещё - этих мягких французских булок, да ещё выпей же чаю.';
echo mb_strirpos($text, 'ещё'); // 46

$text = 'Съешь ещё - этих мягких французских булок, да ещё выпей же чаю.';

$offset = 0;
$allpos = array();
while (($pos = mb_strpos($text, 'ещё', $offset)) !== false) {
	$offset   = $pos + 1;
	$allpos[] = $pos;
}

print_r($allpos); // Array ([0] => 6 [1] => 46)

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_substr($text, 0, 1); // С

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_substr($text, 0, 3); // Съе

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_strstr($text, ' ', true); // Съешь

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_strstr($text, ' ', false); // ещё - этих мягких французских булок, да выпей же чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_substr($text, -1, 1); // .

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_substr($text, -1, 3); // аю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$array = explode(' ', $text);
echo end($array); // чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$str = mb_substr($text, 0, mb_strrpos($text, ' '));
echo $str; // Съешь ещё - этих мягких французских булок, да выпей же

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$array = explode(' ', $text);
echo $array[1]; // ещё

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
echo mb_substr($text, 0, mb_strpos($text, ' - ')); // Съешь ещё

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$str = mb_substr($text, mb_strpos($text, ' - ') + mb_strlen(' - '), -1);
echo $str; // этих мягких французских булок, да выпей же чаю

$text = 'Разнообразный опыт укрепление и развитие структуры требуют 
определения направлений прогрессивного развития! Не следует забывать, 
что постоянный рост и сфера активности в  степени обуславливает создание 
системы обучения кадров? С другой стороны дальнейшее развитие различных 
форм влечет за собой процесс внедрения и модернизации.';

$pos = mb_strpos($text, "n");
$str = trim(mb_substr($text, 0, $pos));
echo $str; // Разнообразный опыт укрепление и развитие структуры требуют 

// или
$lines = explode("n", $text);
echo $lines[0]; // Разнообразный опыт укрепление и развитие структуры требуют 

$text = 'Разнообразный опыт укрепление и развитие структуры требуют 
определения направлений прогрессивного развития! Не следует забывать, 
что постоянный рост и сфера активности в  степени обуславливает создание 
системы обучения кадров? С другой стороны дальнейшее развитие различных 
форм влечет за собой процесс внедрения и модернизации.';

$pos = mb_strrpos($text, "n");
$str = trim(mb_substr($text, $pos));
echo $str; // форм влечет за собой процесс внедрения и модернизации.

// или
$lines = explode("n", $text);
echo end($lines); // форм влечет за собой процесс внедрения и модернизации.

$text = ''Съешь' "ещё" «этих» [мягких] (французских) {булок} <да>';

// '...'
preg_match_all("/'(.+?)'/", $text, $matches);
echo $matches[1][0]; // Съешь

// "..."
preg_match_all("/"(.+?)"/", $text, $matches);
echo $matches[1][0]; // ещё

// «...»
preg_match_all("/«(.+?)»/", $text, $matches);
echo $matches[1][0]; // этих

// [...]
preg_match_all("/[(.+?)]/", $text, $matches);
echo $matches[1][0]; // мягких

// (...)
preg_match_all("/((.+?))/", $text, $matches);
echo $matches[1][0]; // французских

// {...}
preg_match_all("/{(.+?)}/", $text, $matches);
echo $matches[1][0]; // булок

// <...>
preg_match_all("/<(.+?)>/", $text, $matches);
echo $matches[1][0]; // да

if (!function_exists('mb_substr_replace')) {
	function mb_substr_replace($original, $replacement, $position, $length)
	{
		$startString = mb_substr($original, 0, $position, 'UTF-8');
		$endString = mb_substr($original, $position + $length, mb_strlen($original), 'UTF-8');
		$out = $startString . $replacement . $endString;
		return $out;
	}
}

$text = 'Съешь ещё - этих мягких французских булок.';
echo mb_substr_replace($text, '!', 0, 1); // !ъешь ещё - этих мягких французских булок.

$text = 'Съешь ещё - этих мягких французских булок.';
echo mb_substr_replace($text, '!!!', 0, 3); // !!!шь ещё - этих мягких французских булок.

$text = 'Съешь ещё - этих мягких французских булок.';
echo mb_substr_replace($text, '!', -1, 0); // Съешь ещё - этих мягких французских булок!

$text = 'Съешь ещё - этих мягких французских булок.';
echo mb_substr_replace($text, '!!!', -3, 0); // Съешь ещё - этих мягких французских бул!!!

$text = 'Съешь ещё - этих мягких французских булок.';
echo str_replace(' ', '-', $text); // Съешь-ещё---этих-мягких-французских-булок.

$text = 'Съешь ещё - этих мягких французских булок.';
echo str_replace('мягких', 'твердых', $text); // Съешь ещё - этих твердых французских булок.

$text = 'Съешь ещё - этих мягких французских булок.';

$str = 'Не ешь' . mb_substr($text, mb_strpos($text, ' - '), -1);
echo $str; // Не ешь - этих мягких французских булок

$text = 'Съешь ещё - этих мягких французских булок.';

$str = mb_substr($text, 0, mb_strpos($text, ' - ') + 3) . 'печенек';
echo $str; // Съешь ещё - печенек

$text = 'Съешь ещё - этих мягких французских булок.';

$str = mb_substr_replace($text, '!!!', 10, 0);
echo $str; // Съешь ещё !!!- этих мягких французских булок.

$text = 'Съешь ещё - этих мягких французских булок.';

$str = str_replace(' ещё ', ' же ещё ', $text); 
echo $str; // Съешь же ещё - этих мягких французских булок.

$text = 'Съешь ещё - этих мягких французских булок.';
$str = str_replace(' ещё ', ' ещё немного ', $text); 
echo $str; // Съешь ещё немного - этих мягких французских булок.

if (!function_exists('mb_str_split')) {
	function mb_str_split($str, $l = 0) {
		if ($l > 0) {
			$ret = array();
			$len = mb_strlen($str, "UTF-8");
			for ($i = 0; $i < $len; $i += $l) {
				$ret[] = mb_substr($str, $i, $l, "UTF-8");
			}
			return $ret;
		}
		return preg_split("//u", $str, -1, PREG_SPLIT_NO_EMPTY);
	}
}

$text = 'Съешь ещё - этих мягких французских булок.';

$array = mb_str_split($text);;
$new = implode(' ', $array);
echo $new; // С ъ е ш ь   е щ ё   -   э т и х   м я г к и х   ф р а н ц у з с к и х   б у л о к .

if (!function_exists('mb_str_pad')) {
	function mb_str_pad($input, $pad_length, $pad_string = ' ', $pad_type = STR_PAD_RIGHT)
	{
		$diff = strlen($input) - mb_strlen($input);
		return str_pad($input, $pad_length + $diff, $pad_string, $pad_type);
	}
}

$text = 'Привет Мир';
echo mb_str_pad($text,  20, '-', STR_PAD_LEFT); // ----------Привет Мир

$text = 'Привет Мир';
echo mb_str_pad($text,  20, '-', STR_PAD_RIGHT); // Привет Мир----------

$text = 'Привет Мир';
echo mb_str_pad($text,  20, '-', STR_PAD_BOTH); // -----Привет Мир-----

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = mb_substr($text, 1);
echo $new; // ъешь ещё - этих мягких французских булок, да выпей же чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = mb_substr($text, 3);
echo $new; // шь ещё - этих мягких французских булок, да выпей же чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = mb_substr($text, mb_strpos($text, ' '));
echo $new; // ещё - этих мягких французских булок, да выпей же чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = mb_substr($text, 0, -1);
echo $new; // Съешь ещё - этих мягких французских булок, да выпей же чаю

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = mb_substr($text, 0, -3);
echo $new; // Съешь ещё - этих мягких французских булок, да выпей же ч

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = mb_substr($text, 0, mb_strrpos($text, ' '));
echo $new; // Съешь ещё - этих мягких французских булок, да выпей же

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = str_replace(' мягких', '', $text);
echo $new; // Съешь ещё - этих французских булок, да выпей же чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = strstr($text, '-'); 
echo $new; // - этих мягких французских булок, да выпей же чаю.

$text = 'Съешь ещё - этих мягких французских булок, да выпей же чаю.';
$new = strstr($text, '-', true); 
echo $new; // Съешь ещё

// Второй вариант:
$pos = mb_strpos($text, '-');
$new = mb_substr($text, 0, $pos + 1);
echo $new; // Съешь ещё -

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

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

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

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

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

Для сравнения двух строк в C# удобно использовать метод Compare.

public static int Compare (string strA, string strB);

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

Например,

string s1 = "Строка";
string s2 = "Строка";
int res = string.Compare(s1, s2);
Console.WriteLine(res);

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

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

public static int Compare(String? strA, String? strB, bool ignoreCase);

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

public static int Compare(String? strA, String? strB, StringComparison comparisonType);

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

string.Compare(s1, s2, true, System.Globalization.CultureInfo.InvariantCulture);

Сравнение строк в C# без учёта региональных настроек

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

Проверка вхождения подстроки в строку в C#

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

string s1 = "Строка";
string s2 = "ока";

if (s1.Contains(s2))
{
    Console.WriteLine($"Строка {s1} содержит подстроку {s2}");
}
else
{
    Console.WriteLine($"Строка {s1} не содержит подстроку {s2}");
}

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

Объединение строк в C# (конкатенация строк)

Для объединения строк в C# удобно использовать метод Concat. Этот метод принимает два или более параметров, позволяя объединять не только строки, но и строковые представления любых объектов. Например:

string s1 = "Hello";
string s2 = " world";
string s3 = string.Concat(s1, s2);
Console.WriteLine(s3);

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

string[] strArr = new string[3] { "Это", "массив", "строк" };
string s4 = string.Concat(strArr);
Console.WriteLine(s4);

Объединение строк с использованием разделителя в C#

Для того, чтобы объединить несколько строк с использованием заданного разделителе, в C# используется метод Join. В качестве входных параметров метод Join принимает массив или коллекцию строк и символ-разделитель, например:

string[] strArr = new string[3] { "Это", "массив", "строк" };
string s5 = string.Join('|', strArr);
Console.WriteLine(s5);

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

Копирование строк в C#

Для копирования строк в C# можно воспользоваться не статическим методом CopyTo. Этот метод копирует из строки часть символов, начиная с заданной позиции, и вставляет их в массив символов, также с указанной позиции. Сигнатура метода следующая:

(int sourceIndex, char[] destination, int destinationIndex, int count);

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

char[] charArr = new char[] { 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd' };
string s6 = "string";
s6.CopyTo(2, charArr, 0, 4);
Console.WriteLine(charArr);

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

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

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

string s6 = "string";
string s7 = string.Copy(s6);
Console.WriteLine(s7);

Проверка совпадения строк в C#

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

public bool EndsWith(String value);
public bool StartsWith(String value);

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

string s6 = "string";
if (s6.StartsWith("str"))
    Console.WriteLine("Найдено совпадение подстроки "str" в начале строки");
if (s6.EndsWith("ing"))
    Console.WriteLine("Найдено совпадение подстроки "ing" в конце строки");

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

Помимо использования регулярных и буквальных литералов при работе со строками, мы также можем создавать строки в C# используя метод Format. Для того, чтобы раскрыть все возможности форматирования строк, думаю, что потребуется написать отдельную статью. Сейчас же я просто продемонстрирую некоторые основные возможности использования этого метода.

double value = 7.123456789;
double value2 = 7.12;
string s8 = string.Format("Строка для форматирования. Первое число {0},  второе число {1}", value, value2);
Console.WriteLine(s8);

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

Поиск в строках C#

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

public int IndexOf(String value, StringComparison comparisonType);
public int IndexOf(String value, int startIndex, StringComparison comparisonType);
public int IndexOf(String value, int startIndex, int count, StringComparison comparisonType);
public int IndexOf(String value, int startIndex, int count);
public int IndexOf(String value);
public int IndexOf(char value, StringComparison comparisonType);
public int IndexOf(char value, int startIndex, int count);
public int IndexOf(char value, int startIndex);
public int IndexOf(char value);

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

string s9 = "Строка для поиска символов и подстрок";
int index = s9.IndexOf("о");
if (index > -1)
    Console.WriteLine("Индекс первого вхождения символа в строку {0}", index);
index = s9.IndexOf("сим");
if (index > -1)
    Console.WriteLine("Индекс первого символа искомой подстроки {0}", index);

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

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

public int LastIndexOf(char value, int startIndex, int count);
public int LastIndexOf(char value, int startIndex);
public int LastIndexOf(String value, StringComparison comparisonType);
public int LastIndexOf(String value, int startIndex, StringComparison comparisonType);
public int LastIndexOf(char value);
public int LastIndexOf(String value, int startIndex, int count);
public int LastIndexOf(String value, int startIndex);
public int LastIndexOf(String value);
public int LastIndexOf(String value, int startIndex, int count, StringComparison comparisonType);

Вставка подстроки в строку C#

Для вставки одной строки в другую в C# можно воспользоваться методом Insert:

public String Insert(int startIndex, String value);

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

string s10 = "Hello ";
string s11 = s10.Insert(6, "world");
Console.WriteLine(s11);

Результат

Замена символов и подстрок в строках C#

Для замены символов и подстрок в строках C# используется метод Replace:

public String Replace(char oldChar, char newChar);
public String Replace(String oldValue, String? newValue);
public String Replace(String oldValue, String? newValue, bool ignoreCase, CultureInfo? culture);
public String Replace(String oldValue, String? newValue, StringComparison comparisonType);

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

string s12 = "Исходная строка для замены всех символов о на символы А";
string s13 = s12.Replace('о', 'А');
Console.WriteLine(s13);

Результат

Разделение строк на подстроки в C#

Разделение строк на подстроки в C# также является достаточно частой задачей в программировании. Для этого можно воспользоваться методом Split

public String[] Split(String[]? separator, int count, StringSplitOptions options);
public String[] Split(String? separator, int count, StringSplitOptions options = StringSplitOptions.None);
public String[] Split(String[]? separator, StringSplitOptions options);
public String[] Split(char[]? separator, int count, StringSplitOptions options);
public String[] Split(String? separator, StringSplitOptions options = StringSplitOptions.None);
public String[] Split(char[]? separator, StringSplitOptions options);
public String[] Split(char separator, StringSplitOptions options = StringSplitOptions.None);
public String[] Split(params char[]? separator);
public String[] Split(char[]? separator, int count);
public String[] Split(char separator, int count, StringSplitOptions options = StringSplitOptions.None);

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

string s14 = "Эта строка, которая будет разделена на подстроки с использованием двух разделителей";
string[] res = s14.Split(new char[] { ' ', ',' });
foreach (string s in res)
{
    Console.WriteLine(s);
}

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

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

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

public String Substring(int startIndex);
public String Substring(int startIndex, int length);

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

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

string s15 = "hello world";
string s16 = s15.Substring(6);
string s17 = s15.Substring(7, 3);
Console.WriteLine(s16);
Console.WriteLine(s17);

Результат выполнения

Изменение регистра строк в C#

Для изменения регистра символов в строке в C# можно воспользоваться двумя методами:

public String ToLower();
public String ToLower(CultureInfo? culture);
public String ToUpper();
public String ToUpper(CultureInfo? culture);

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

string s15 = "HelLo World";
string s16 = s15.ToLower();
string s17 = s15.ToUpper();
Console.WriteLine(s16);
Console.WriteLine(s17);

Результат выполнения

Обрезка строк в C#

Иногда требуется избавиться в строке от лишних символов в начале, в конце или одновременно и вначале и в конце. «Лишними» могут быть как обычные проблелы, так и прочие символы. Для обрезки строки в C# можно воспользоваться методами Trim*:

public String Trim();
public String Trim(char trimChar);
public String Trim(params char[]? trimChars);
public String TrimEnd(char trimChar);
public String TrimEnd(params char[]? trimChars);
public String TrimStart();
public String TrimStart(char trimChar);
public String TrimStart(params char[]? trimChars);

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

string s15 = " HelLo World ";
string s16 = s15.Trim(); //обрезаем пробелы
string s17 = s16.Trim(new char[] {'H', 'd'}); //обрезаем заданные символы
Console.WriteLine(s16);
Console.WriteLine(s17);

Итого

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

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

Соединение строк в 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 есть метод char charAt(int index). Этот метод принимает индекс, по которому необходимо получить символы, возвращая извлеченный символ:
String str = "Java";
char c = str.charAt(2);
System.out.println(c); // v


Обратите внимание, что индексация начинается с нуля, впрочем, как и в массивах.

Если же нужно извлечь сразу группу символов либо подстроку, подойдёт getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin). Этот метод принимает ряд параметров:

• srcBegin: индекс в нашей строке, с которого осуществляется начало извлечения символов;

• srcEnd: индекс в нашей строке, до которого осуществляется извлечение символов;

• dst: массив символов (именно в него будут эти символы извлекаться);

• dstBegin: индекс в массиве dst (с него надо добавлять символы, извлечённые из строки).
String str = "Hi world!";
int start = 6;
int end = 11;
char[] dst=new char[end - start];
str.getChars(start, end, dst, 0);
System.out.println(dst); // world


Сравниваем строки в Java
Мы уже писали о том, как сравнивать строки в Java, используя для этого метод equals() (регистр учитывается) и equalsIgnoreCase() (регистр не учитывается). Хотелось бы сказать пару слов про ещё одну пару методов: int compareTo(String str) и int compareToIgnoreCase(String str) — они позволяют не только сравнить 2 строки, но и узнать, больше ли одна другой. Если значение, которое возвращается, больше 0, первая строка больше, если меньше нуля, всё наоборот. Когда обе строки равны, вернётся ноль.
Для определения используется лексикографический порядок. Допустим, строка «A» меньше строки «B», ведь символ ‘A’ в алфавите находится перед символом ‘B’. Когда первые символы строк равны, в расчёт берутся следующие символы. К примеру:
String str1 = "hello";
String str2 = "world";
String str3 = "hell";

System.out.println(str1.compareTo(str2)); // -15 - str1 меньше, чем strt2
System.out.println(str1.compareTo(str3)); // 1 - str1 больше, чем str3


Поиск в строке в Java
Чтобы найти индекс первого вхождения подстроки в строку, используют метод indexOf(), последнего — метод lastIndexOf(). Если подстрока не найдена, оба метода вернут -1:
String str = "Hello world";
int index1 = str.indexOf('l'); // 2
int index2 = str.indexOf("wo"); //6
int index3 = str.lastIndexOf('l'); //9


Чтобы определить, начинается строка с определённой подстроки, применяют метод startsWith(). Что касается метода endsWith(), то он даёт возможность определить оканчивается ли строка на определенную подстроку:
String str = "myfile.exe";
boolean start = str.startsWith("my"); //true
boolean end = str.endsWith("exe"); //true


Выполняем замену в строке в Java
Заменить в нашей строке одну последовательность символов другой можно с помощью метода replace():
String str = "Hello world";
String replStr1 = str.replace('l', 'd'); // Heddo wordd
String replStr2 = str.replace("Hello", "Bye"); // Bye world


Обрезаем строки в Java
Для удаления начальных и конечных пробелов применяют метод trim():
String str = "  hello world  ";
str = str.trim(); // hello world 


Также существует метод substring() — он возвращает подстроку, делая это с какого-нибудь конкретного индекса до конца либо до определённого индекса:
String str = "Hello world";
String substr1 = str.substring(6); // world
String substr2 = str.substring(3,5); //lo


Меняем регистр в Java
При необходимости вы можете перевести все символы вашей строки в нижний регистр (toLowerCase()) или в верхний (toUpperCase()):
String str = "Hello World"; 
System.out.println(str.toLowerCase()); // hello world
System.out.println(str.toUpperCase()); // HELLO WORLD


Split
С помощью этого метода вы сможете разбить строку на подстроки по конкретному разделителю. Под разделителем понимается какой-либо символ либо набор символов, передаваемые в метод в качестве параметра. Давайте для примера разобьём небольшой текст на отдельные слова:
String text = "OTUS is a good company";
String[] words = text.split(" ");
for(String word : words){
    System.out.println(word);
}


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

Вот и всё! Узнать больше всегда можно на наших курсах:


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

1. «Java-примеры: найти последнее вхождение подстроки в строке».

2. «Основные операции со строками».