String как найти символ

Strings are a very important aspect from a programming perspective as many questions can be framed out among strings. There arise wide varied sets of concepts and questions that are pivotal to understanding strings. Now over here will be discussing different ways to play with strings where we will be playing with characters with strings and substrings which is a part of input strings with help of inbuilt methods and also by proposing logic listing wide varied ways as follows: 

Searching a Character in the String

Way 1: indexOf(char c)

It searches the index of specified characters within a given string. It starts searching from the beginning to the end of the string (from left to right) and returns the corresponding index if found otherwise returns -1. 

Note: If the given string contains multiple occurrences of a specified character then it returns the index of the only first occurrence of the specified character. 

Syntax: 

int indexOf(char c)
// Accepts character as argument, Returns index of 
// the first occurrence of specified character 

Way 2: lastIndexOf(char c)

It starts searching backward from the end of the string and returns the index of specified characters whenever it is encountered. 

Syntax: 

public int lastIndexOf(char c)
// Accepts character as argument, Returns an 
// index of the last occurrence specified 
// character

Way 3: indexOf(char c, int indexFrom)

It starts searching forward from the specified index in the string and returns the corresponding index when the specified character is encountered otherwise returns -1. 

Note: The returned index must be greater than or equal to the specified index. 

Syntax: 

public int IndexOf(char c, int indexFrom)

Parameters: 

• The character to be searched
• An integer from where searching

Return Type: An index of a specified character that appeared at or after the specified index in a forwarding direction.

Way 4: lastIndexOf(char c, int fromIndex)

It starts searching backward from the specified index in the string. And returns the corresponding index when the specified character is encountered otherwise returns -1. 

Note: The returned index must be less than or equal to the specified index. 

Syntax: 

public int lastIndexOf(char c, int fromIndex)

Way 5: charAt(int indexNumber)

Returns the character existing at the specified index, indexNumber in the given string. If the specified index number does not exist in the string, the method throws an unchecked exception, StringIndexOutOfBoundsException. 

Syntax:

char charAt(int indexNumber)

Example:

First occurrence of char 's' is found at : 4
Last occurrence of char 's' is found at : 28
First occurrence of char 's' after index 10 : 12
Last occurrence of char 's' after index 20 is : 15
Character at location 20: 111

 Way 6: Searching Substring in the String

The methods used for searching a character in the string which are mentioned above can also be used for searching the substring in the string. 

Example

First occurrence of char Geeks is found at : 0
Last occurrence of char Geeks is found at : 8
First occurrence of char Geeks after index 10 : -1
Last occurrence of char Geeks after index 20 is : 8

Way 7: contains(CharSequence seq): It returns true if the string contains the specified sequence of char values otherwise returns false. Its parameters specify the sequence of characters to be searched and throw NullPointerException if seq is null. 

Syntax: 

public boolean contains(CharSequence seq)

Note: CharSequence is an interface that is implemented by String class, Therefore we use string as an argument in contains() method. 

Example 

Found soft?: true
Found war? true
Found wr?: false

 Way 8: Matching String Start and End 

• boolean startsWith(String str): Returns true if the string str exists at the starting of the given string, else false.
• boolean startsWith(String str, int indexNum): Returns true if the string str exists at the starting of the index indexNum in the given string, else false.
• boolean endsWith(String str): Returns true if the string str exists at the ending of the given string, else false.

Example:

This article is contributed by Nitsdheerendra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Last Updated :
16 Feb, 2023

Like Article

Save Article

Теги: java, string, символ, поиск, строка, метод, буква, знак, contains

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

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

Для работы со строками в Java применяют классы String, StringBuilder и StringBuffer. Класс String включает методы, возвращающие позицию символа либо подстроки в строке:
— indexOf() — для поиска с начала строки;
— lastIndexOf() — для выполнения поиска с конца строки.

Таким образом, если метод indexOf() найдёт заданную букву, символ либо строку, он вернёт индекс, то есть порядковый номер. Если не найдёт, будет возвращено -1. Также он позволяет искать символ или букву, начиная с указанного индекса.

Кроме того, стоит добавить, что класс String включает в себя ещё и метод contains, возвращающий true, когда в строке содержится заданная последовательность символов. Этот метод рекомендуется использовать лишь тогда, когда вам просто нужно узнать о существовании подстроки в строке, при этом позиция не имеет значения.

Метод indexOf()

Библиотека метода:

Синтаксис следующий:

public int indexOf(char ch)
public int indexOf(char ch, int fromIndex)


либо



  


                       
  




public int indexOf(String s)
public int indexOf(String s, int fromIndex)


Соответственно, вызвать метод можно тоже несколькими способами: 
int index = str1.indexOf(myChar);
int index = str1.indexOf(myChar, start);


или:
int index = str1.indexOf(myString);
int index = str1.indexOf(myString, start);


Представьте, что нам нужно отыскать в строке индекс первого вхождения требуемого символа/буквы, а также нужного слова. Как уже было сказано выше, метод indexOf() вернёт нам индекс первого вхождения, а в случае неудачи — вернёт -1.

Посмотрите на следующий код:
public class Main {
   public static void main(String[] args) {
      String str = "Otus — онлайн-образование";

      int indexM = str.indexOf("з"); // Ищем символ в строке
      int indexJava = str.indexOf("онлайн"); // Ищем слово в строке

      if(indexM == - 1) {
         System.out.println("Символ "з" не найден.");
      } else {
         System.out.println("Символ "з" найден, его индекс: " + indexM);
      }

      if(indexJava == - 1) {
         System.out.println("Слово "онлайн" не найдено.");
      } else {
         System.out.println("Слово "онлайн" найдено, его индекс: " + indexJava);
      }
   }
}


Результат получим следующий:
Символ "з" найден, его индекс: 18
Слово "онлайн" найдено, его индекс: 7


Метод contains
Бывают ситуации, когда нам необходимо проверить, содержит ли наша строка конкретный символ/букву либо слово. Нижеследующий Java-код продемонстрирует и этот пример:



  


                       
  




public class Main {
   public static void main(String[] args) {
      String str = "Otus — онлайн-образование";
      System.out.println("Слово "Otus" есть в строке str? Ответ: " + str.contains("Otus"));
      System.out.println("Символ "z" присутствует в строке str? Ответ: " + str.contains("z"));
   }
}


В этом случае результат будет следующим:
Слово "Otus" есть в строке str? Ответ: true
Символ "z" присутствует в строке str? Ответ: false


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

Вы не сообщили, в объекте какого типа у вас хранится строка.

Ниже показана демонстрационная программа, которая осуществляет поиск символа в символьном массиве s1 и в объекте с именем s2 класса std::string.

#include <iostream>
#include <string>
#include <cstring>

int main()
{
    char s1[] = "2 * 2 = 4";
    std::string s2( s1 );
    char c = '=';

    char *p = std::strchr( s1, c );

    if ( p != nullptr ) 
    {        
        std::cout << "Character " << c << " found at position " << p - s1 << std::endl;
        std::cout << "The rest of the string is "" << p << """ << std::endl;
    }

    std::string::size_type n = s2.find( c );

    if ( n != std::string::npos ) 
    {        
        std::cout << "Character " << c << " found at position " << n << std::endl;
        std::cout << "The rest of the string is "" << s2.substr( n ) << """ << std::endl;
    }
}

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

Character '=' found at position 6
The rest of the string is "= 4"
Character '=' found at position 6
The rest of the string is "= 4"

Часто нам нужно найти символ в строке python. Для решения этой задачи разработчики используют метод find(). Он помогает найти индекс первого совпадения подстроки в строке. Если символ или подстрока не найдены, find возвращает -1.

Синтаксис

string.find(substring,start,end)

Метод find принимает три параметра:

• substring (символ/подстрока) — подстрока, которую нужно найти в данной строке.
• start (необязательный) — первый индекс, с которого нужно начинать поиск. По умолчанию значение равно 0.
• end (необязательный) — индекс, на котором нужно закончить поиск. По умолчанию равно длине строки.

Параметры, которые передаются в метод, — это подстрока, которую требуются найти, индекс начала и конца поиска. Значение по умолчанию для начала поиска — 0, а для конца — длина строки.

В этом примере используем метод со значениями по умолчанию.

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

>>> string = "Добро пожаловать!"

>>> print("Индекс первой буквы 'о':", string.find("о"))

Индекс первой буквы 'о': 1

Поиск не с начала строки с аргументом start

Можно искать подстроку, указав также начальное положение поиска.

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

>>> string = "Специалисты назвали плюсы и минусы Python"

>>> print("Индекс подстроки 'али' без учета первых 8 символов:", string.find("али", 8))

Индекс подстроки 'али' без учета первых 8 символов: 16

Поиск символа в подстроке со start и end

С помощью обоих аргументов (start и end) можно ограничить поиск и не проводить его по всей строке. Найдем индексы слова «пожаловать» и повторим поиск по букве «о».

>>> string = "Добро пожаловать!"

>>> start = string.find("п")

>>> end = string.find("ь") + 1

>>> print("Индекс первой буквы 'о' в подстроке:", string.find("о", start, end))

Индекс первой буквы 'о' в подстроке: 7

Проверка есть ли символ в строке

Мы знаем, что метод find() позволяет найти индекс первого совпадения подстроки. Он возвращает -1 в том случае, если подстрока не была найдена.

>>> string = "Добро пожаловать!"

>>> print("Есть буква 'г'?", string.find("г") != -1)

Есть буква 'г'? False

>>> print("Есть буква 'т'?", string.find("т") != -1)

Есть буква 'т'? True

Поиск последнего вхождения символа в строку

Функция rfind() напоминает find(), а единое отличие в том, что она возвращает максимальный индекс. В обоих случаях же вернется -1, если подстрока не была найдена.

В следующем примере есть строка «Добро пожаловать!». Попробуем найти в ней символ «о» с помощью методов find() и rfind().

>>> string = "Добро пожаловать"

>>> print("Поиск 'о' методом find:", string.find("о"))

Поиск 'о' методом find: 1

>>> print("Поиск 'о' методом rfind:", string.rfind("о"))

Поиск 'о' методом rfind: 11

Вывод показывает, что find() возвращает индекс первого совпадения подстроки, а rfind() — последнего совпадения.

Второй способ поиска — index()

Метод index() помогает найти положение данной подстроки по аналогии с find(). Единственное отличие в том, что index() бросит исключение в том случае, если подстрока не будет найдена, а find() просто вернет -1.

Вот рабочий пример, показывающий разницу в поведении index() и find():

>>> string = "Добро пожаловать"

>>> print("Поиск 'о' методом find:", string.find("о"))

Поиск 'о' методом find: 1

>>> print("Поиск 'о' методом index:", string.index("о"))

Поиск 'о' методом index: 1

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

>>> string = "Добро пожаловать"

>>> print("Поиск 'г' методом find:", string.find("г"))

Поиск 'г' методом find: 1

>>> print("Поиск 'г' методом index:", string.index("г"))

Traceback (most recent call last):

  File "pyshell#21", line 1, in module

    print("Поиск 'г' методом index:", string.index("г"))

ValueError: substring not found

В этом примере мы пытались найти подстроку «г». Ее там нет, поэтому find() возвращает -1, а index() бросает исключение.

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

Чтобы найти общее количество совпадений подстроки в строке можно использовать ту же функцию find(). Пройдемся циклом while по строке и будем задействовать параметр start из метода find().

Изначально переменная start будет равна -1, что бы прибавлять 1 у каждому новому поиску и начать с 0. Внутри цикла проверяем, присутствует ли подстрока в строке с помощью метода find.

Если вернувшееся значение не равно -1, то обновляем значением count.

Вот рабочий пример:

my_string = "Добро пожаловать"

start = -1

count = 0


while True:

    start = my_string.find("о", start+1)

    if start == -1:

        break

    count += 1



  


                       
  





print("Количество вхождений символа в строку: ", count )

Количество вхождений символа в строку:  4

Выводы

• Метод find() помогает найти индекс первого совпадения подстроки в данной строке. Возвращает -1, если подстрока не была найдена.
• В метод передаются три параметра: подстрока, которую нужно найти, start со значением по умолчанию равным 0 и end со значением по умолчанию равным длине строки.
• Можно искать подстроку в данной строке, задав начальное положение, с которого следует начинать поиск.
• С помощью параметров start и end можно ограничить зону поиска, чтобы не выполнять его по всей строке.
• Функция rfind() повторяет возможности find(), но возвращает максимальный индекс (то есть, место последнего совпадения). В обоих случаях возвращается -1, если подстрока не была найдена.
• index() — еще одна функция, которая возвращает положение подстроки. Отличие лишь в том, что index() бросает исключение, если подстрока не была найдена, а find() возвращает -1.
• find() можно использовать в том числе и для поиска общего числа совпадений подстроки.

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

• Знакомство со строками в C#
• Создание и инициализация объекта класса String
• Базовый API для работы со строками
  • Объединение строк. Оператор +, методы Concat и Join
  • Поиск и извлечение элементов из строки. Оператор [], методы IndexOf, IndexOfAny, LastIndexOf, LastIndexOfAny, Substring
  • Сравнение срок
  • Модификация срок
  • Методы и свойства общего назначения
• Форматирование строк
  • Представление чисел
  • Представление даты и времени
• $ — интерполяция строк
• Управляющие символы (литералы)
• @ – буквальный идентификатор
• Класс StringBuilder

Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.

За представление строк в C# отвечает класс System.String. В коде, для объявления переменной соответствующего типа, предпочтительно использовать следующий вариант написания: string – с маленькой буквы. Это ключевое слово языка, используя которое можно объявлять строковые переменные, также как int является псевдонимом для  System.Int32, а bool – для System.Boolean.

string s1 = "Hello, World!";
Console.WriteLine(s1);

Допустимо объявление строковых переменных через ключевое слово var:

var s2 = "Create by var";
Console.WriteLine(s2);

Для объединения строк используется оператор +:

string s3 = "Hello, ";
string s4 = s3 + "John!";
Console.WriteLine(s4);

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

Создание и инициализация объекта класса String

Существует несколько способов создать объект класса String и проинициализировать его. Рассмотрим варианты, которые доступны в C#. Наиболее распространенный способ сделать эту операцию – это присвоить строковое значение переменной без явного вызова конструктора, так, как мы это делали в предыдущем разделе:

string s5 = "test1";
var s6 = "test2";

Для дословного представления строки, для того чтобы проигнорировать управляющие последовательности, используйте префикс @ перед значением. Сравните вывод следующей конструкции:

Console.WriteLine("first linenSecond line");

С вариантом:

Console.WriteLine(@"first linenSecond line");

Если требуется подготовить строковое значение с использованием набора переменных, то можно воспользоваться статическим методом Format класса String, либо префиксом $:

int age = 27;
Console.WriteLine(String.Format("Age: {0}", age));
Console.WriteLine("");
Console.WriteLine($"Age: {age}");
Console.WriteLine("");

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

string s7 = new string("test3");

В качестве параметра может выступать массив Char элементов:

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
string s8 = new string(charArray);

Ещё вариант – это указать элемент типа char и количество раз, которое его нужно повторить:

string s9 = new string('O', 10); // "OOOOOOOOOO"

Для создания строки также можно использовать указатели на Char* и SByte*, но в данном уроке эта тема рассматриваться не будет.

Базовый API для работы со строками

В рамках данного раздела рассмотрим наиболее интересные и полезные методы и свойства класса String.

Объединение строк. Оператор +, методы Concat и Join

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

string s10 = "Area";
string s11 = " 51";
Console.WriteLine("Concat by +: " + s10 + s11);

В составе API, который предоставляет System.String, есть метод Concat, который может выполнять ту же работу:

Console.WriteLine("Concat by Concat(): " + string.Concat(s10, s11));

Метод Concat позволяет объединить до четырех строк через прямое перечисление. Если нужно таким образом объединить больше строковых переменных и значений, то используйте оператор +. Полезным свойством Concat является то, что он может принять на вход массив элементов типа String  и объединить их:

string[] sArr1 = {"First ", "Second ", "Third "};
Console.WriteLine(string.Concat(sArr1));

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

string[] sArr2 = {"First", "Second", "Third"};
Console.WriteLine("Join elements in array by Join() with space: " + string.Join(" ", sArr2));

В качестве разделителя можно использовать любую строку:

Console.WriteLine("Join elements in array by Join() with <->: " + string.Join("<->", sArr2));

Поиск и извлечение элементов из строки. Оператор [], методы IndexOf, IndexOfAny, LastIndexOf, LastIndexOfAny, Substring

Для получения символа из строки с конкретной позиции можно использовать синтаксис подобный тому, что применяется при работе с массивами – через квадратные скобки []:

string s12 = "Hello";
Console.WriteLine("Get element by index s12[3]: " + s12[3]);

Для решения обратной задачи: поиск индекса первого (последнего) вхождения элемента или сроки в данной строке используются методы IndexOf, IndexOfAny и LastIndexOf, LastIndexOfAny.

В таблице ниже перечислены некоторые из предоставляемых System.String вариантов этих методов.

// s1 = "Hello, World!"
// Поиск первого вхождения символа 'r'
Console.WriteLine("Index of 'r': " + s1.IndexOf('r'));
// Поиск первого вхождения символа 'l' начиная с позиции 4
Console.WriteLine("Index of 'l', start at 4: " + s1.IndexOf('l', 4));
// Поиск первого вхождения строки "World"
Console.WriteLine("Index of "World": " + s1.IndexOf("World"));
// Поиск первого вхождения символа из набора ['o', 'd', ',']
Console.WriteLine("Index of pos of any symbol in array: " + s1.IndexOfAny(new char[] {'o', 'd', ','}));

// Поиск последнего вхождения символа 'l'
Console.WriteLine("Last index of 'l': " + s1.LastIndexOf('l'));
// Поиск последнего вхождения строки "or"
Console.WriteLine("Last index of "or": " + s1.LastIndexOf("or"));
// Поиск последнего вхождения символа из набора ['o', 'd', ',']
Console.WriteLine("Last index of pos of any symbol in array: " + s1.LastIndexOfAny(new char[] {'o', 'd', ','}));

Для определения того, содержит ли данная строка указанную подстроку, а также для проверки равенства начала или конца строки заданному значению используйте методы: Contains, StartsWith и EndsWith.

Console.WriteLine("Contains "World"? " + s1.Contains("World")); // True
Console.WriteLine("Starts with "He"? " + s1.StartsWith("He")); // True
Console.WriteLine("Ends with "ld"? " + s1.EndsWith("ld")); // False

Задачу извлечения подстроки из данной строки решает метод SubString:

Console.WriteLine("Substring start at pos 7: " + s1.Substring(7));  // World!
Console.WriteLine("Substring start at pos 7 (4 chars): " + s1.Substring(7, 4)); // Worl

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

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

string t1 = "John";
string t2 = "John";
string t3 = "Mary";
Console.WriteLine("t1 == t2: " + (t1 == t2));   // True
Console.WriteLine("t1 != t2: " + (t1 != t2));   // False
Console.WriteLine("t1 == t3: " + (t1 == t3));   // False

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

Console.WriteLine("Equals method: t1.Equals(t2)" + t1.Equals(t2));   // True
Console.WriteLine("Equals method: t1.Equals(t3)" + t1.Equals(t3));   // False

Модификация срок

Класс String предоставляет довольно большое количество инструментов для изменения строк. 

Вставка строки в исходную в заданную позицию осуществляется с помощью метода Insert:

Console.WriteLine("Insert: " + "26".Insert(1, "[4]")); // 2[4]6

Для приведения строки к заданной длине с выравниванием по левому (правому) краю с заполнением недостающих символов пробелами используются методы PadLeft и PadRight:

Console.WriteLine("PadLeft: ");
Console.WriteLine("some string".PadLeft(15)); // "    some string"
Console.WriteLine("some string".PadLeft(15, '*')); // "****some string"
Console.WriteLine("PadRight: ");
Console.WriteLine("some string".PadRight(15)); // "some string    "
Console.WriteLine("some string".PadRight(15, '*')); // "some string****"

Метод Remove удаляет подстроку из исходной строки. Возможны два варианта использования:

Console.WriteLine("Remove demo1: " + "Hello".Remove(2));
Console.WriteLine("Remove demo2: " + "Hello".Remove(2, 2));

Замена элементов строки производится с помощью метода Replace. Наиболее часто используемые варианты – это замена символа на символ и строки на подстроку:

Console.WriteLine("Hello, World!".Replace('!', '.')); // Hello, World.
Console.WriteLine("Hello, World!".Replace("World", "John")); // Hello, John!

Для преобразования строки к верхнему регистру используйте метод ToUpper(), к нижнему – ToLower():

Console.WriteLine("Hello, World!".ToUpper()); // HELLO, WORLD!
Console.WriteLine("Hello, World!".ToLower()); // hello, world!

За удаление начальных и конечных символов отвечают методы, начинающиеся на Trim (см. таблицу ниже).

Console.WriteLine("   hello   ".Trim());    // "hello"
Console.WriteLine("***hello---".Trim('*'));    // "hello---"
Console.WriteLine("***hello---".Trim(new char[] {'*', '-'}));    // "hello"
Console.WriteLine("   hello   ".TrimStart());   // "hello   "           
Console.WriteLine("   hello   ".TrimEnd()); // "   hello"

Методы и свойства общего назначения

Рассмотрим некоторые из полезных методов и свойств, которые не вошли в приведенные выше группы.

System.Length – возвращает длину строки:

Console.WriteLine("Hello".Length); // 5

System.Split() – разделяет заданную строку на подстроки, в качестве разделителя используется указанный через параметр символ (или группа символов):

foreach(var s in "1 2 3".Split(' '))
Console.WriteLine(s);

foreach(var s in "1 2 3-4-5-6".Split(new char[]{' ', '-'}))
Console.WriteLine(s);

System.Empty – возвращает пустую строку.

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

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

Для начала рассмотрим на нескольких примерах работу с этими методоми:

// ToString
Console.WriteLine(12345.ToString("X"));


// String.Format
Console.WriteLine(string.Format("value: {0}", 1.23456));
Console.WriteLine(string.Format("value: {0:F}", 1.23456));
Console.WriteLine(string.Format("value: {0:d}", 1.23456));
        

// WriteLine без использования String.Format
Console.WriteLine("value: {0}", 1.23456);   // 1,23456
Console.WriteLine("value: {0:F}", 1.23456); // 1.235
Console.WriteLine("date: {0:d}", DateTime.Now); // 07.09.2020

Эта функциональность также доступна для методов  StringBuilder.AppendFormat,  TextWriter.WriteLine,  Debug.WriteLine, методов из Trace, которые выводят текстовые сообщения, например: Trace.TraceError и метод TraceSource.TraceInformation.

Каждый элемент форматирования представляется следующим образом:

{index[,alignment][:formatString]}

где index – это индекс элемента, которым будет замещена данная конструкция;

alignment – выравнивание;

formatString – формат.

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

Console.WriteLine("Only index: {0}", 123); // Only index: 123
Console.WriteLine("Index with alignment: {0,-5}{1,5}", 123, 456); // Index with alignment: 123    456
Console.WriteLine("Index with format: 0x{0:X}", 123); // Index with format: 0x7B

Представление чисел

Для представления чисел используются следующие описатели формата (список не полный, более детальную информацию можете найти в официальной документации):

Примеры использования описателей формата для чисел:

Console.WriteLine("C symbol: {0:C}", 123);      // 123,00 ₽
Console.WriteLine("D symbol: {0:D5}", 123);     // 00123
Console.WriteLine("E symbol: {0:E}", 123456789);// 1,234568E+008
Console.WriteLine("F symbol: {0:F2}", 123.4567);// 123,46
Console.WriteLine("P symbol: {0:P}", 0.123);    // 123,46
Console.WriteLine("X symbol: 0x{0:X}", 567);    // 0x237
Console.WriteLine("0 symbol: {0:000.00}", 12.6789);// 012,68
Console.WriteLine("# symbol: {0:##}", 14.6789); // 15

Представление даты и времени

Для представления даты и времени используются следующие описатели формата (список не полный, более детальную информацию можете найти в официальной документации):

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

Console.WriteLine("d symbol: {0:d}", DateTime.Now);
Console.WriteLine("D symbol: {0:D}", DateTime.Now);
Console.WriteLine("f symbol: {0:f}", DateTime.Now);
Console.WriteLine("F symbol: {0:F}", DateTime.Now);
Console.WriteLine("g symbol: {0:g}", DateTime.Now);
Console.WriteLine("G symbol: {0:G}", DateTime.Now);
Console.WriteLine("t symbol: {0:t}", DateTime.Now);
Console.WriteLine("T symbol: {0:T}", DateTime.Now);
Console.WriteLine("{0:yyyy-MM-dd}", DateTime.Now);
Console.WriteLine("{0:dd/MM/yy}", DateTime.Now);
Console.WriteLine("{0:dd/MM/yy HH:mm:ss}", DateTime.Now);

$ — интерполяция строк

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

{<interpolationExpression>[,<alignment>][:<formatString>]}

где interpolationExpression – элемент, значение, которого будет интегрироваться в строку;

alignment – выравнивание;

formatString – формат (см. форматирование строк).

Примеры работы с интерполированной строкой:

int n1 = 45678;
double d1 = 123.34567;
bool b1 = true;
string sv = "test";
Console.WriteLine($"int val: {n1}, double val: {d1:#.###}");
Console.WriteLine($"bool val: {b1}, string val: {sv}");

Управляющие символы (литералы)

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

Пример использования управляющих символов:

Console.WriteLine("aName:t"John"nAge:t"27"");

@ – буквальный идентификатор

Еще один элемент, который можно использовать при создании срок – это буквальный идентификатор @. Если его поставить перед строкой, то она будет интерпретироваться буквально, в ней, escape-последовательности представляются без преобразования.

Пример работы с буквальным идентификатором:

Console.WriteLine(@"escape is not work: atnx1234");

Класс StringBuilder

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

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

string outString = "";
for(int i = 0; i < 10; i++)
{
   outString += i.ToString() + " - ";
}
Console.WriteLine(outString);

Более эффективным решением будет использование StringBuilder:

StringBuilder sb = new StringBuilder();
for(int i = 0; i < 10; i++)
{
    sb.Append(i.ToString());
    sb.Append(" - ");
}
outString = sb.ToString();
Console.WriteLine(outString);

Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.