Операции со строками
Класс Convert
Класс Console
Основные классы
Оператор switch
Полноценный логический тип данных
Помните, как замысловато был представлен логический тип данных в C – числовое значение 0 воспринималось как «ложь», а любое другое – как «истина». Так что цикл while(5){. . .} хотя и выглядел странновато, оказывался бесконечным циклом. Кроме того, в C операция присваивания имела два результата – побочный (сам факт копирования значения в правую часть) и основной – значение правой части после присваивания. Это позволяло выполнять цепочечные присваивания (a=b=c;). В силу этих двух особенностей многие невнимательные программисты (а кто же всегда будет внимателен?) допускали маленькую опечатку – вместо операции сравнения == в условных выражения использовали операцию присваивания =). Хуже всего, что с точки зрения компилятора эта конструкция воспринималась правильно. В результате цикл while(a=5){. . .} также становился бесконечным циклом.
В языке C# никакого хитроумного моделирования логических значений нет – вместо этого имеется полноценный логический тип bool, на самом деле реализованный классом Boolean (помните int и Int32?).
В результате компилятор обнаруживает ошибку в условном выражении a=1 и сообщает, что не может неявно преобразовать целую величину в логическую.
Отметим две особенности, отличающие оператор switch в языках C# и C++:
1. C# не поддерживает “провала” передачи управления, возникающего при отсутствии оператора break.
Фрагмент программы
{ case 1: cout<<”Один”;
case 2: cout<<”Два”;
case 3: cout<<”Три”;
case 4: cout<<”Четыре”;
приводил к выводу на экран строки «ДваТриЧетыре».
{ case 1: Console.Write(”Один”); break;
case 2: Console.Write(”Два”); break;
case 3: Console.Write(”Три”); break;
case 4: Console.Write(”Четыре”); break;
В результате на экране появится только слово «Два»
2. В качестве выражения и констант, отмечающих варианты оператора switch можно использовать строковые данные (тип string)
string a; a=”Два”;
{ case ”Один”: Console.Write(1); break;
case ”Два”: Console.Write(2); break;
case ”Три”: Console.Write(3); break;
case ”Четыре”: Console.Write(4); break;
Такой фрагмент выводит на экран число 2.
Ниже рассмотрим использование наиболее популярных классов платформы.NET
Как вы уже успели заметить, этот класс используется для организации взаимодействия пользователя с компьютером с помощью двух устройств: клавиатура (для ввода информации) и монитор (для вывода). В предыдущих примерах были использованы методы ReadLine и WriteLine. Отметим ещё одну полезную особенность метода WriteLine.
Допустим, нужно вывести на экран значения трёх переменных x, y и z. это можно сделать следующим образом:
Console.WriteLine(“x=”+x+”, y=”+y+”, z=”+z);
При вводе такого оператора приходится внимательно следить за соблюдением порядка множества элементов, составляющих параметр метода. Намного удобнее этой же цели добиться иначе:
Console.WriteLine(“x={0}, y={1}, z={2}”,x,y,z);
В этом случае метод WriteLine имеет несколько параметров. Первый обязательно является строкой, определяющей структуру выводимой информации. В этой строке присутствуют специальные элементы ({0}{1}{2}), вместо которых выводятся значения соответствующих других параметров (в нашем примере x, y и z).
Кроме ReadLine и WriteLine класс Console содержит дополнительные методы для управления клавиатурой и выводом информации на монитор. Например, с помощью метода SetCursorPosition можно управлять позицией курсора.
Мы уже знаем о существовании метода ToInt32, осуществляющего преобразование в целое число. Кроме того, в этом классе имеется ещё ряд методов преобразования: ToBoolean, ToByte, ToChar, ToDateTime, ToDecimal, ToDouble, ToSingle, ToString. Этот (неполный!) перечень методов позволяет сделать следующие выводы:
1. Система основных типов языка в основном унаследована от языка С++, однако, в ней появились и новшества.
Как уже говорилось, в C# имеется полноценный логический тип данных Boolean.
Тип Decimal это разновидность вещественного типа данных используемого, когда важно избежать накопления погрешностей вычислений.
Два основных вещественных типа языка C++ (float и double) в C# «поменялись местами» - стандартным теперь является Double. Это означает, что вещественные константы, записываемые обычным образом, относятся к типу Double. Поэтому оператор a = 0.5 будет признан компилятором ошибочным (несовместимость типов в присваивании), если переменная a имеет тип float.
Преобразованием в тип float занимается метод ToSingle.
2. Каждый из методов преобразования является перегруженным. Это позволяет применять метод с одним и тем же именем для преобразования разнотипной исходной информации. Например:
Convert.ToInt32(3.2);
Convert.ToInt32(false);
Convert.ToInt32(“Hello”);
В связи с этим полезно будет выполнть следующее задание: написать программу, проверяющую результаты применения методов преобразования к различным типам данных. Выявить комбинации типов, приводящие к ошибкам и дать этому объяснение.
Строковый тип данных string (класс String)
Работу со строками символов в.NET очень удобно осуществлять с помощью типа данных String из пространства имен System. Переменные этого типа можно описывать также с помощью ключевого слова string.
Переменная строкового типа может получить свое значение несколькими способами:
1. Присваиванием строковой константы или строкового выражения:
name=”John”;
name=”Mr. ” + name; //для строк + действует как конкатенация
2. Путем ввода с клавиатуры
name=Console.Readline();
Сравнивать строки можно операциями == (равно) и!= (не равно). При этом проверяется точное совпадение содержимого этих строк. Однако применять для сравнения операции <, >, >= и <= нельзя. Для таких сравнений существует специальный метод Compare в классе String.
В C# сохранилась возможность работать со строкой как с массивом символов.
В следующем фрагменте программы проиллюстрированы некоторые из перечисленных возможностей:
s1 = Console.ReadLine().ToLower();
s2 = ""; //строка может быть пустой
for (int i = 0; i < s1.Length; i++) s2 += s1;
Console.WriteLine(s2);
Здесь сначала описываются две строковые переменные s1 и s2. Далее с помощью метода ToLower вводимая с клавиатуры строка переводится в нижний регистр и результат присваивается переменной s1. Обратите внимание на цепочку вызовов методов Console.ReadLine().ToLower(). Сначала ReadLine возвращает строку, а затем ToLower переводит ее в нижний регистр.
Далее выполняется цикл, переворачивающий содержимое строки s1. Перевернутое содержимое оказывается в строке s2. Обратите внимание на то, что для определения длины строки используется Length. Вы не видите спика параметров в круглых скобках после Length. Это значит, что Length не является методом, а свойством класса. Позже мы обсудим свойства подробнее.
Обращение к символам строки с помощью индексации возможно только для чтения. Попытка изменить строку с помощью индексации приводит к ошибке компиляции:
s=’!’; //Ошибка
Класс String предлагает обширный набор полезных методов. В следующей таблице указаны некоторые из них.
Таблица членов класса String
| Член | Описание |
| Length | Свойство, возвращающее длину текущей строки |
| Compare() и CompareTo() | Методы, сравнивающие два заданных объекта String и возвращающие целое число (0,1,-1), которое показывает их связь друг с другом в порядке сортировки |
| Contains() | Метод, применяемый для выяснения того, содержит ли текущий строковый объект данную строку |
| Copy() | Метод, создающий новый экземпляр String, имеющий то же значение, что и заданный экземпляр String |
| CopyTo() | Метод, копирующий заданное число знаков начиная с указанной позиции в этом экземпляре до указанной позиции в массиве знаков Юникода |
| EndsWith() и StartsWith() | Методы, определяющие, совпадает ли конец (начало) экземпляра String с указанной строкой |
| Format() | Метод, который заменяет каждый элемент формата в указанном объекте String текстовым эквивалентом значения соответствующего объекта |
| IndexOf() | Метод, возвращающий индекс первого вхождения String или одного или нескольких знаков в данной строке |
| IndexOfAny() | Метод, возвращающий индекс первого обнаруженного в данном экземпляре знака из указанного массива знаков Юникода |
| Insert() | Метод, используемый для получения копии текущей строки, содержащей добавляемые строковые данные |
| Join() | Метод, который вставляет заданный разделитель типа String между элементами заданного массива String, создавая одну сцепленную строку |
| LastIndexOf() | Возвращает индекс последнего вхождения указанного знака Юникода или String в пределах данного экземпляра |
| LastIndexOfAny() | Возвращает индекс последнего вхождения в данном экземпляре какого-либо одного или нескольких знаков, указанных в массиве знаков Юникод |
| PadLeft() и PadRight() | Выравнивает знаки в данном экземпляре по левому (правому) краю, добавляя справа (слева) пробелы или указанные знаки Юникода до указанной общей длины |
| Remove() Replace() | Методы, используемые для получения копии строки с соответствующими модификациями (при удалении или замене символов) |
| Split() | Возвращает строковый массив, содержащий подстроки данного экземпляра, разделенные элементами заданной строки или массива знаков Юникода |
| Substring() | Метод, возвращающий строку, которая представляет подстроку текущей отроки |
| ToCharArray() | Метод, возвращающий массив символов, из которых состоит текущая строка |
| ToUpper() ToLower() | Методы, создающие копию данной строки, представленную символами в верхнем или, соответственно, нижнем регистре |
| Trim() | Удаляет все начальные и конечные вхождения заданных наборов знаков из текущего объекта String |
| TrimEnd() и TrimStart() | Удаляет все конечные (начальные) вхождения набора знаков, заданного в виде массива, из текущего объекта String |
Рассмотрим подробнее использование некоторых методов класса String.
Английское слово split означает «разбить на части». Одним вызовом этого метода можно решить популярную задачу разбиения текста на некоторые фрагменты.
Рассмотрим следующую постановку задачи:
Дан некоторый текст. Определить среднюю длину всех слов, содержащихся в этом тексте. Слова отделяются друг от друга одним или несколькими символами-разделителями, в число которых входят пробел, запятая и точка.
Очевидно, что для решения этой задачи нужно выделять в тексте отдельные слова. Это достаточно сложный циклический процесс, поскольку слова отделяются друг от друга множеством разных символов-разделителей. Именно эту задачу решает метод Split.
Исходную строку можно получить путём ввода с клавиатуры.
string text = Console.ReadLine();
Для успешной работы методу Split нужно передать параметр – массив символов-разделителей.
char separators = new char {" ", ",", "."};
(читатели, знакомые с массивами в языке С++ заметят, что описание и инициализация массивов в C# выглядит несколько иначе; об этом подробнее будет рассказано далее).
Метод Split в результате своей работы возвращает массив строк, полученных в результате выделения их из всего текста на основе информации о символах-разделителях.
string words = text.Split(separators);
Вот и всё! Однако, в этой короткой строчке содержится очень важное новшество, непосредственно относящее к объектно-ориентированному программированию. Метод Split вызывается в форме text.Split(…), то есть метод Split как будто принадлежит строковой переменной text. Это действительно правильная точка зрения, которую Вы должны усвоить в ходе этого курса. Будьте внимательны, поскольку некоторые методы класса String вызываются «от имени» класса, например, String.Format(…). Такие методы называются статическими . Методы, подобные Split называются нестатическими или методами экземпляра класса.
Теперь, имея массив слов текста легко окончательно решить задачу – найти среднюю длину всех слов. Для этого будет использован стандартный циклический алгоритм суммирования.
for(int i = 0; i double aL = Convert.ToDouble(L) / words.Length; Здесь мы видим, что по своей форме цикл for в C# такой же, как и в С++. Новшеством является удобная возможность задать границу цикла (количество
элементов массива!) с помощью свойства
Length массива words, то есть массив сам содержит информацию о своём размере. Аналогично можно определить и длину (количество символов) одной строки: words[i].Length. Приведение Convert.ToDouble понадобилось для того, чтобы операция «деления» выдала вещественный, а не целый результат. В C# имеется возможность несколько улучшить последний цикл, используя новую разновидность оператора цикла – foreach. foreach(string w in words) L += w.Length; Для читателя, знающего английский язык, этот цикл выглядит очень естественно, поскольку хорошо «переводится» на «человеческий» язык. В переводе на русский это звучит примерно так: «Для каждой строки w из words выполнить некоторое действие». Формальный синтаксис этого оператора следующий: foreach(<тип> <переменная> in
<массив>)
<тело цикла>;
Несмотря на правильную структуру, эта программа выдаёт неверный результат. Причина этого станет понятнее, если в цикл добавить вывод слов на экран. foreach(…) { Console.WriteLine(w); L += w.Length; } Выполнение программы с входной строкой " yes, no hello." покажет, что метод Split разбил эту строку не на три, а на шесть строк: пустая строка, “yes”, пустая строка, “no”,“hello”, пустая строка. Это произошло потому, что метод Split считает «словом» любую строку, расположенную между символами-разделителями. Чтобы избавиться от этой проблемы можно «заставить» метод Split работать несколько иначе – не
выделять в качестве «слов» пустые строки между соседними символами-разделителями. Для этого в метод Split нужно передать дополнительный
параметр - StringSplitOptions.RemoveEmptyEntries. Теперь вызов метода выглядит так: text.Split(separators, StringSplitOptions.RemoveEmptyEntries); Здесь мы опять встречаемся с использованием перегруженного варианта метода, который, благодаря дополнительному параметру, исключает пустые строки. Ещё больший интерес представляет форма записи и тип этого параметра. Тип параметра является перечислением
(подробнее об этом в следующем параграфе). --- Руководство по C# --- Строки С точки зрения регулярного программирования строковый тип данных string
относится к числу самых важных в C#. Этот тип определяет и поддерживает символьные
строки. В целом ряде других языков программирования строка представляет собой
массив символов. А в C# строки являются объектами. Следовательно, тип string относится к числу ссылочных. Самый простой способ построить символьную строку - воспользоваться строковым литералом . Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал: String str = "Пример строки"; В данном случае переменная str инициализируется последовательностью символов "Пример строки".
Объект типа string можно также создать из массива типа char. Например: Char chararray = {"e", "x", "a", "m", "p", "l", "e"};
string str = new string(chararray); Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки. Как ни странно, содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но
данное ограничение способствует более эффективной реализации символьных строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в
преимущество. Так, если требуется строка в качестве разновидности уже имеющейся
строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения. А поскольку неиспользуемые строковые объекты автоматически собираются в "мусор", то о дальнейшей судьбе ненужных строк можно даже не беспокоиться. Следует, однако, подчеркнуть, что переменные ссылки на строки (т.е. объекты типа
string) подлежат изменению, а следовательно, они могут ссылаться на другой объект. Но содержимое самого объекта типа string не меняется после его создания. Рассмотрим пример: Static void addNewString()
{
string s = "This is my stroke";
s = "This is new stroke";
} Скомпилируем приложение и загрузим результирующую сборку в утилиту ildasm.exe . На рисунке показан CIL-код, который будет сгенерирован
для метода void addNewString(): Обратите внимание на наличие многочисленных вызовов кода операции ldstr (загрузка строки).
Этот код операции ldstr в CIL предусматривает выполнение загрузки нового объекта string в управляемую кучу. В результате предыдущий объект, в котором содержалось
значение "This is my stroke", будет в конечном итоге удален сборщиком мусора. В классе System.String
предоставляется набор методов для определения длины символьных данных, поиска подстроки в текущей строке, преобразования символов из верхнего регистра в нижний и наоборот, и т.д. Далее мы рассмотрим этот класс более подробно. В классе String определено единственное поле: Public static readonly string Empty; Поле Empty обозначает пустую строку, т.е. такую строку, которая не содержит символы. Этим оно отличается от пустой ссылки типа String, которая просто делается на несуществующий объект. Помимо этого, в классе String определен единственный индексатор, доступный только для чтения: Public char this { get; } Этот индексатор позволяет получить символ по указанному индексу. Индексация строк, как и массивов, начинается с нуля. Объекты типа String отличаются постоянством и не изменяются, поэтому вполне логично, что в классе String поддерживается индексатор, доступный только для чтения. И наконец, в классе String определено единственное свойство, доступное только для чтения: Public int Length { get; } Свойство Length возвращает количество символов в строке. В примере ниже показано использование индексатора и свойства Length: Using System;
class Example
{
static void Main()
{
string str = "Простая строка";
// Получить длину строки и 6й символ в строке используя индексатор
Console.WriteLine("Длина строки - {0}, 6й символ - "{1}"",
str.Length, str);
}
} В классе String перегружаются два следующих оператора: == и!=. Оператор == служит для проверки двух символьных строк на равенство. Когда оператор == применяется к ссылкам на объекты, он обычно проверяет, делаются ли обе ссылки на один и тот же объект. А когда оператор == применяется к ссылкам на объекты типа String, то на предмет равенства сравнивается содержимое самих строк. Это же относится и к оператору!=. Когда он применяется к ссылкам на объекты типа String, то на предмет неравенства сравнивается содержимое самих строк. В то же время другие операторы отношения, в том числе =, сравнивают ссылки на объекты типа String таким же образом, как и на объекты других типов. А для того чтобы проверить, является ли одна строка больше другой, следует вызвать метод Compare(), определенный в классе String. Как станет ясно дальше, во многих видах сравнения символьных строк используются сведения о культурной среде. Но это не относится к операторам == и!=. Ведь они просто сравнивают порядковые значения символов в строках. (Иными словами, они сравнивают двоичные значения символов, не видоизмененные нормами культурной среды, т.е. региональными стандартами.) Следовательно, эти операторы выполняют сравнение строк без учета регистра и настроек культурной среды. В следующей таблице перечислены некоторые наиболее интересные методы этого класса, сгруппированные по назначению: Public static int Compare(string strA, string strB, bool ignoreCase) Public static int Compare(string strA, string strB, StringComparison comparisonType) Public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo culture) Статический метод, сравнивает строку strA со строкой strB. Возвращает положительное значение, если строка strA больше строки strB; отрицательное значение, если строка strA меньше строки strB; и нуль, если строки strA и strB равны. Сравнение выполняется с учетом регистра и культурной среды. Если параметр ignoreCase принимает логическое значение true, то при сравнении не учитываются различия между прописным и строчным вариантами букв. В противном случае эти различия учитываются. Параметр comparisonType определяет конкретный способ сравнения строк. Класс CultureInfo определен в пространстве имен System.Globalization. Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, CultureInfo culture)
Сравнивает части строк strA и strB. Сравнение начинается со строковых элементов strA и strB и включает количество символов, определяемых параметром length. Метод возвращает положительное значение, если часть строки strA больше части строки strB; отрицательное значение, если часть строки strA меньше части строки strB; и нуль, если сравниваемые части строк strA и strB равны. Сравнение выполняется с учетом регистра и культурной среды. Public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int count)
Делает то же, что и метод Compare(), но без учета локальных установок Сравнивает вызывающую строку со строковым представлением объекта value. Возвращает положительное значение, если вызывающая строка больше строки value; отрицательное значение, если вызывающая строка меньше строки value; и нуль, если сравниваемые строки равны Сравнивает вызывающую строку со строкой strB Возвращает логическое значение true, если вызывающая строка содержит ту же последовательность символов, что и строковое представление объекта obj. Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды Public bool Equals(string value, StringComparison comparisonType)
Возвращает логическое значение true, если вызывающая строка содержит ту же последовательность символов, что и строка value. Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды. Параметр comparisonType определяет конкретный способ сравнения строк Public static bool Equals(string a, string b, StringComparison comparisonType)
Возвращает логическое значение true, если строка a содержит ту же последовательность символов, что и строка b . Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды. Параметр comparisonType определяет конкретный способ сравнения строк public static string Concat(params string values);
Public bool StartsWith(string value, StringComparison comparisonType)
Возвращает логическое значение true, если вызывающая строка начинается с подстроки value. В противном случае возвращается логическое значение false. Параметр comparisonType определяет конкретный способ выполнения поиска Public bool EndsWith(string value, StringComparison comparisonType)
Возвращает логическое значение true, если вызывающая строка оканчивается подстрокой value. В противном случае возвращает логическое значение false. Параметр comparisonType определяет конкретный способ поиска Public int IndexOf(string value)
Находит первое вхождение заданной подстроки или символа в строке. Если искомый символ или подстрока не обнаружены, то возвращается значение -1 Public int IndexOf(string value, int startIndex) Public int IndexOf(char value, int startIndex, int count) Public int IndexOf(string value, int startIndex, int count)
Возвращает индекс первого вхождения символа или подстроки value в вызывающей строке. Поиск начинается с элемента, указываемого по индексу startIndex, и охватывает число элементов, определяемых параметром count (если указан). Метод возвращает значение -1, если искомый символ или подстрока не обнаружен То же, что IndexOf, но находит последнее вхождение символа или подстроки, а не первое Public int IndexOfAny(char anyOf, int startIndex) Public int IndexOfAny(char anyOf, int startIndex, int count)
Возвращает индекс первого вхождения любого символа из массива anyOf, обнаруженного в вызывающей строке. Поиск начинается с элемента, указываемого по индексу startIndex, и охватывает число элементов, определяемых параметром count (если они указаны). Метод возвращает значение -1, если не обнаружено совпадение ни с одним из символов из массива anyOf. Поиск осуществляется порядковым способом Возвращает индекс последнего вхождения любого символа из массива anyOf, обнаруженного в вызывающей строке Public string Split(params char separator, int count)
Метод, возвращающий массив string с присутствующими в данном экземпляре подстроками внутри, которые отделяются друг от друга элементами из
указанного массива char или string. В первой форме метода Split() вызывающая строка разделяется на составные части. В итоге возвращается массив, содержащий подстроки, полученные из вызывающей
строки. Символы, ограничивающие эти подстроки, передаются в массиве separator. Если массив separator пуст или ссылается на пустую строку, то в качестве разделителя подстрок используется пробел. А во второй форме данного метода возвращается количество подстрок, определяемых параметром count. Public string Split(string separator, StringSplitOptions options) Public string Split(params char separator, int count, StringSplitOptions options) Public string Split(string separator, int count, StringSplitOptions options)
В двух первых формах метода Split() вызывающая строка разделяется на части и возвращается массив, содержащий подстроки, полученные из вызывающей строки. Символы, разделяющие эти подстроки, передаются в массиве separator. Если массив separator пуст, то в качестве разделителя используется пробел. А в третьей и четвертой формах данного метода возвращается количество строк, ограничиваемое параметром count. Но во всех формах параметр options обозначает конкретный способ обработки пустых строк, которые образуются в том случае, если два разделителя оказываются рядом. В перечислении StringSplitOptions определяются только два значения: None
и RemoveEmptyEntries
. Если параметр options принимает значение None, то пустые строки включаются в конечный результат разделения исходной строки. А если параметр options принимает значение RemoveEmptyEntries, то пустые строки исключаются из конечного результата разделения исходной строки. Public static string Join(string separator, string value, int startIndex, int count)
Строит новую строку, комбинируя содержимое массива строк. В первой форме метода Join() возвращается строка, состоящая из сцепляемых подстрок, передаваемых в массиве value. Во второй форме также возвращается строка, состоящая из подстрок, передаваемых в массиве value, но они сцепляются в определенном количестве count, начиная с элемента массива value. В обеих формах каждая последующая строка отделяется от предыдущей разделительной строкой, определяемой параметром separator. Public string Trim(params char trimChars)
Метод, который позволяет удалять все вхождения определенного набора символов с начала и конца текущей строки. В первой форме метода Trim() из вызывающей строки удаляются начальные и конечные пробелы. А во второй форме этого метода удаляются начальные и конечные вхождения в вызывающей строке символов из массива trimChars. В обеих формах возвращается получающаяся в итоге строка. Public string PadLeft(int totalWidth, char paddingChar)
Позволяет дополнить строку символами слева. В первой форме метода PadLeft() вводятся пробелы с левой стороны вызывающей строки, чтобы ее общая длина стала равной значению параметра totalWidth. А во второй форме данного метода символы, обозначаемые параметром paddingChar, вводятся с левой стороны вызывающей строки, чтобы ее общая длина стала равной значению параметра totalWidth. В обеих формах возвращается получающаяся в итоге строка. Если значение параметра totalWidth меньше длины вызывающей строки, то возвращается копия неизмененной вызывающей строки. Позволяет дополнить строку символами справа. Используется для вставки одной строки в другую, где value обозначает строку, вставляемую в вызывающую строку по индексу startIndex. Метод возвращает получившуюся в итоге строку. Public string Remove(int startIndex, int count)
Используется для удаления части строки. В первой форме метода Remove() удаление выполняется, начиная с места, указываемого по индексу startIndex, и продолжается до конца строки. А во второй форме данного метода из строки удаляется количество символов, определяемое параметром count, начиная с места, указываемого по индексу startIndex. Public string Replace(string oldValue, string newValue)
Используется для замены части строки. В первой форме метода Replace() все вхождения символа oldChar в вызывающей строке заменяются символом newChar. А во второй форме данного метода все вхождения строки oldValue в вызывающей строке заменяются строкой newValue. Делает заглавными все буквы в вызывающей строке. Делает строчными все буквы в вызывающей строке. Public string Substring(int startIndex, int length)
В первой форме метода Substring() подстрока извлекается, начиная с места, обозначаемого параметром startIndex, и до конца вызывающей строки. А во второй форме данного метода извлекается подстрока, состоящая из количества символов, определяемых параметром length, начиная с места, обозначаемого параметром startIndex. Пример следующей программы использует несколько из вышеуказанных методов: Using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string args)
{
// Сравним первые две строки
string s1 = "это строка";
string s2 = "это текст, а это строка";
if (String.CompareOrdinal(s1, s2) != 0)
Console.WriteLine("Строки s1 и s2 не равны");
if (String.Compare(s1, 0, s2, 13, 10, true) == 0)
Console.WriteLine("При этом в них есть одинаковый текст");
// Конкатенация строк
Console.WriteLine(String.Concat("\n" + "Один, два ","три, четыре"));
// Поиск в строке
// Первое вхождение подстроки
if (s2.IndexOf("это") != -1)
Console.WriteLine("Слово \"это\" найдено в строке, оно "+
"находится на: {0} позиции", s2.IndexOf("это"));
// Последнее вхождение подстроки
if (s2.LastIndexOf("это") != -1)
Console.WriteLine("Последнее вхождение слова \"это\" находится "
+ "на {0} позиции", s2.LastIndexOf("это"));
// Поиск из массива символов
char myCh = {"Ы","х","т"};
if (s2.IndexOfAny(myCh) != -1)
Console.WriteLine("Один из символов из массива ch "+
"найден в текущей строке на позиции {0}", s2.IndexOfAny(myCh));
// Определяем начинается ли строка с заданной подстроки
if (s2.StartsWith("это текст") == true)
Console.WriteLine("Подстрока найдена!");
// Определяем содержится ли в строке подстрока
// на примере определения ОС пользователя
string myOS = Environment.OSVersion.ToString();
if (myOS.Contains("NT 5.1"))
Console.WriteLine("Ваша операционная система Windows XP");
else if (myOS.Contains("NT 6.1"))
Console.WriteLine("Ваша операционная система Windows 7");
Console.ReadLine();
}
}
} Вероятно, из всех операций обработки символьных строк чаще всего выполняется сравнение одной строки с другой. Прежде чем рассматривать какие-либо методы сравнения строк, следует подчеркнуть следующее: сравнение строк может быть выполнено в среде.NET Framework двумя основными способами: Во-первых, сравнение может отражать обычаи и нормы отдельной культурной среды, которые зачастую представляют собой настройки культурной среды, вступающие в силу при выполнении программы. Это стандартное поведение некоторых, хотя и не всех методов сравнения. И во-вторых, сравнение может быть выполнено независимо от настроек культурной среды только по порядковым значениям символов, составляющих строку. Вообще говоря, при сравнении строк без учета культурной среды используется лексикографический порядок (и лингвистические особенности), чтобы определить, является ли одна строка больше, меньше или равной другой строке. При порядковом сравнении строки просто упорядочиваются на основании невидоизмененного значения каждого символа. В силу отличий способов сравнения строк с учетом культурной среды и порядкового сравнения, а также последствий каждого такого сравнения настоятельно рекомендуется руководствоваться лучшими методиками, предлагаемыми в настоящее время корпорацией Microsoft. Ведь выбор неверного способа сравнения строк может привести к неправильной работе программы, когда она эксплуатируется в среде, отличающей от той, в которой она разработана. Выбор способа сравнения символьных строк представляет собой весьма ответственное решение. Как правило и без всяких исключений, следует выбирать сравнение строк с учетом культурной среды, если это делается для целей отображения результата пользователю (например, для вывода на экран ряда строк, отсортированных в лексикографическом порядке). Но если строки содержат фиксированную информацию, не предназначенную для видоизменения с учетом отличий в культурных средах, например, имя файла, ключевое слово, адрес веб-сайта или значение, связанное с обеспечением безопасности, то следует выбрать порядковое сравнение строк. Разумеется, особенности конкретного разрабатываемого приложения будут диктовать выбор подходящего способа сравнения символьных строк. В классе String предоставляются самые разные методы сравнения строк, которые перечислены в таблице выше. Наиболее универсальным среди них является метод Compare(). Он позволяет сравнивать две строки полностью или частично, с учетом или без учета регистра, способа сравнения, определяемого параметром типа StringComparison
, а также сведений о культурной среде, предоставляемых с помощью параметра типа CultureInfo
. Те перегружаемые варианты метода Compare(), которые не содержат параметр типа StringComparison, выполняют сравнение символьных строк с учетом регистра и культурной среды. А в тех перегружаемых его вариантах, которые не содержат параметр типа CultureInfo, сведения о культурной среде определяются текущей средой выполнения. Тип StringComparison представляет собой перечисление, в котором определяются значения, приведенные в таблице ниже. Используя эти значения, можно организовать сравнение строк, удовлетворяющее потребностям конкретного приложения. Следовательно, добавление параметра типа StringComparison расширяет возможности метода Compare() и других методов сравнения, например, Equals(). Это дает также возможность однозначно указывать способ предполагаемого сравнения строк. В силу имеющих отличий между сравнением строк с учетом культурной среды и порядковым сравнением очень важно быть предельно точным в этом отношении. В любом случае метод Compare() возвращает отрицательное значение, если первая сравниваемая строка оказывается меньше второй; положительное значение, если первая сравниваемая строка больше второй; и наконец, нуль, если обе сравниваемые строки равны. Несмотря на то что метод Compare() возвращает нуль, если сравниваемые строки равны, для определения равенства символьных строк, как правило, лучше пользоваться методом Equals() или же оператором ==. Дело в том, что метод Compare() определяет равенство сравниваемых строк на основании порядка их сортировки. Так, если выполняется сравнение строк с учетом культурной среды, то обе строки могут оказаться одинаковыми по порядку их сортировки, но не равными по существу. По умолчанию равенство строк определяется в методе Equals(), исходя из порядковых значений символов и без учета культурной среды. Следовательно, по умолчанию обе строки сравниваются в этом методе на абсолютное, посимвольное равенство подобно тому, как это делается в операторе ==. Несмотря на большую универсальность метода Compare(), для простого порядкового сравнения символьных строк проще пользоваться методом CompareOrdinal(). И наконец, следует иметь в виду, что метод CompareTo() выполняет сравнение строк только с учетом культурной среды. В приведенной ниже программе демонстрируется применение методов Compare(), Equals(), CompareOrdinal(), а также операторов == и!= для сравнения символьных строк. Обратите внимание на то, что два первых примера сравнения наглядно демонстрируют отличия между сравнением строк с учетом культурной среды и порядковым сравнением в англоязычной среде: Using System;
class Example
{
static void Main()
{
string str1 = "alpha";
string str2 = "Alpha";
string str3 = "Beta";
string str4 = "alpha";
string str5 = "alpha, beta";
int result;
// Сначала продемонстрировать отличия между сравнением строк
// с учетом культурной среды и порядковым сравнением
result = String.Compare(str1, str2, StringComparison.CurrentCulture);
Console.Write("Сравнение строк с учетом культурной среды: ");
if (result 0)
Console.WriteLine(str1 + " больше " + str2);
else
Console.WriteLine(str1 + " равно " + str2);
result = String.Compare(str1, str2, StringComparison.Ordinal);
Console.Write("Порядковое сравнение строк: ");
if (result 0)
Console.WriteLine(str1 + " больше " + str2);
else
Console.WriteLine(str1 + " равно " + str4);
// Использовать метод CompareOrdinal()
result = String.CompareOrdinal(str1, str2);
Console.Write("Сравнение строк методом CompareOrdinal():\n");
if (result 0)
Console.WriteLine(str1 + " больше " + str2);
else
Console.WriteLine(str1 + " равно " + str4);
Console.WriteLine();
// Определить равенство строк с помощью оператора ==
// Это порядковое сравнение символьных строк
if (str1 == str4)
Console.WriteLine(str1 + " == " + str4);
// Определить неравенство строк с помощью оператора!=
if(str1 != str3)
Console.WriteLine(str1 + " != " + str3);
if(str1 != str2)
Console.WriteLine(str1 + " != " + str2);
Console.WriteLine();
// Выполнить порядковое сравнение строк без учета регистра,
// используя метод Equals()
if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase))
Console.WriteLine("Сравнение строк методом Equals() с " +
"параметром OrdinalIgnoreCase:\n" +
str1 + " равно " + str2);
Console.WriteLine ();
// Сравнить части строк
if(String.Compare(str2, 0, str5, 0, 3,
StringComparison.CurrentCulture) > 0) {
Console.WriteLine("Сравнение строк с учетом текущей культурной среды:" +
"\n3 первых символа строки " + str2 +
" больше, чем 3 первых символа строки " + str5);
}
}
} Выполнение этой программы приводит к следующему результату: Последнее обновление: 31.10.2015 Конкатенация строк или объединение может производиться как с помощью операции + , так и с помощью метода Concat: String s1 = "hello";
string s2 = "world";
string s3 = s1 + " " + s2; // результат: строка "hello world"
string s4 = String.Concat(s3, "!!!"); // результат: строка "hello world!!!"
Console.WriteLine(s4);
Метод Concat является статическим методом класса String, принимающим в качестве параметров две строки. Также имеются другие версии
метода, принимающие другое количество параметров. Для объединения строк также может использоваться метод Join: String s5 = "apple";
string s6 = "a day";
string s7 = "keeps";
string s8 = "a doctor";
string s9 = "away";
string values = new string { s5, s6, s7, s8, s9 };
String s10 = String.Join(" ", values);
// результат: строка "apple a day keeps a doctor away"
Метод Join также является статическим. Использованная выше версия метода получает два параметра: строку-разделитель (в данном случае пробел) и
массив строк, которые будут соединяться и разделяться разделителем. Для сравнения строк применяется статический метод Compare: String s1 = "hello";
string s2 = "world";
int result = String.Compare(s1, s2);
if (result<0)
{
Console.WriteLine("Строка s1 перед строкой s2");
}
else if (result > 0)
{
Console.WriteLine("Строка s1 стоит после строки s2");
}
else
{
Console.WriteLine("Строки s1 и s2 идентичны");
}
// результатом будет "Строка s1 перед строкой s2"
Данная версия метода Compare принимает две строки и возвращает число. Если первая строка по алфавиту стоит выше второй, то возвращается число меньше нуля.
В противном случае возвращается число больше нуля. И третий случай - если строки равны, то возвращается число 0. В данном случае так как символ h по алфавиту стоит выше символа w, то и первая строка будет стоять выше. С помощью метода IndexOf мы можем определить индекс первого вхождения отдельного символа или подстроки в строке: String s1 = "hello world";
char ch = "o";
int indexOfChar = s1.IndexOf(ch); // равно 4
Console.WriteLine(indexOfChar);
string subString = "wor";
int indexOfSubstring = s1.IndexOf(subString); // равно 6
Console.WriteLine(indexOfSubstring);
Подобным образом действует метод LastIndexOf , только находит индекс последнего вхождения символа или подстроки в строку. Еще одна группа методов позволяет узнать начинается или заканчивается ли строка на определенную подстроку. Для этого предназначены методы
StartsWith и EndsWith . Например, у нас есть задача удалить из папки все файлы с расширением exe: String path = @"C:\SomeDir";
string files = Directory.GetFiles(path);
for (int i = 0; i < files.Length; i++)
{
if(files[i].EndsWith(".exe"))
File.Delete(files[i]);
}
С помощью функции Split мы можем разделить строку на массив подстрок. В качестве параметра функция Split
принимает массив символов или строк, которые и будут служить разделителями. Например, подсчитаем количество слов в сроке,
разделив ее по пробельным символам: String text = "И поэтому все так произошло";
string words = text.Split(new char { " " });
foreach (string s in words)
{
Console.WriteLine(s);
}
Это не лучший способ разделения по пробелам, так как во входной строке у нас могло бы быть несколько подряд идущих пробелов и в итоговый массив
также бы попадали пробелы, поэтому лучше использовать другую версию метода: String words = text.Split(new char { " " }, StringSplitOptions.RemoveEmptyEntries);
Второй параметр StringSplitOptions.RemoveEmptyEntries говорит, что надо удалить все пустые подстроки. Для обрезки начальных или концевых символов используется функция Trim: String text = " hello world ";
text = text.Trim(); // результат "hello world"
text = text.Trim(new char { "d", "h" }); // результат "ello worl"
Функция Trim без параметров обрезает начальные и конечные пробелы и возвращает обрезанную строку. Чтобы явным образом указать, какие
начальные и конечные символы следует обрезать, мы можем передать в функцию массив этих символов. Эта функция имеет частичные аналоги: функция TrimStart обрезает начальные символы, а функция TrimEnd обрезает конечные символы. Обрезать определенную часть строки позволяет функция Substring
: String text = "Хороший день";
// обрезаем начиная с третьего символа
text = text.Substring(2);
// результат "роший день"
Console.WriteLine(text);
// обрезаем сначала до последних двух символов
text = text.Substring(0, text.Length - 2);
// результат "роший де"
Console.WriteLine(text);
Функция Substring также возвращает обрезанную строку. В качестве параметра первая использованная версия применяет индекс, начиная с
которого надо обрезать строку. Вторая версия применяет два параметра - индекс начала обрезки и длину вырезаемой части строки. Для вставки одной строки в другую применяется функция Insert: String text = "Хороший день";
string subString = "замечательный ";
text = text.Insert(8, subString);
Console.WriteLine(text);
Первым параметром в функции Insert является индекс, по которому надо вставлять подстроку, а второй параметр - собственно подстрока. Удалить часть строки помогает метод Remove: String text = "Хороший день";
// индекс последнего символа
int ind = text.Length - 1;
// вырезаем последний символ
text = text.Remove(ind);
Console.WriteLine(text);
// вырезаем первые два символа
text = text.Remove(0, 2);
Первая версия метода Remove принимает индекс в строке, начиная с которого надо удалить все символы. Вторая версия принимает еще один параметр - сколько
символов надо удалить. Чтобы заменить один символ или подстроку на другую, применяется метод Replace
: String text = "хороший день";
text = text.Replace("хороший", "плохой");
Console.WriteLine(text);
text = text.Replace("о", "");
Console.WriteLine(text);
Во втором случае применения функции Replace строка из одного символа "о" заменяется на пустую строку, то есть фактически удаляется из текста.
Подобным способом легко удалять какой-то определенный текст в строках. Для приведения строки к верхнему и нижнему регистру используются соответственно функции ToUpper()
и
ToLower()
: String hello = "Hello world!";
Console.WriteLine(hello.ToLower()); // hello world!
Console.WriteLine(hello.ToUpper()); // HELLO WORLD!
Над
строками определены следующие операции: Присваивание
(=); Две операции
проверки эквивалентности (= =) и (!=); Конкатенация
или сцепление строк (+); Взятие индекса
(). Начнем
с присваивания, имеющего важную особенность. Поскольку string
- это ссылочный
тип, то в результате присваивания создается ссылка на константную строку,
хранимую в «куче». С одной и той же строковой константой в «куче» может быть
связано несколько переменных строкового типа. Но эти переменные не являются
псевдонимами - разными именами одного и того же объекта. Дело в том, что
строковые константы в «куче» не изменяются (о неизменяемости строкового типа
будем далее говорить подробно), поэтому, когда одна из переменных получает
новое значение, она связывается с новым константным объектом в «куче».
Остальные переменные сохраняют свои связи. Для программиста это означает, что
семантика присваивания строк аналогична семантике значимого присваивания. В
отличие от других ссылочных типов операции, проверяющие эквивалентность,
сравнивают значения строк, а не ссылки. Эти операции выполняются как над
значимыми типами. Бинарная
операция «+» сцепляет две строки, приписывая вторую строку к хвосту первой. Возможность
взятия индекса при работе со строками отражает тот приятный факт, что строку
можно рассматривать как массив и получать без труда каждый ее символ. Каждый
символ строки имеет типchar
,
доступный только
для чтения, но не для записи. Вот пример, в котором над строками
выполняются данные операции: public
void
TestOpers
() {
Статические методы класса
String
Сводка статических методов классаString
приводится в
таблице 6. Таблица 6. Статические
методы класса String Метод
Описание
Возвращается
пустая строка. Свойство со статусом read only Сравнение двух
строк. Метод перегружен. Реализации метода позволяют сравнивать как строки,
так и подстроки. При этом можно учитывать или не учитывать регистр,
особенности национального форматирования дат, чисел и т.д. Сравнение двух
строк. Метод перегружен. Реализации метода позволяют сравнивать как строки,
так и подстроки. Сравниваются коды символов Конкатенация
строк. Метод перегружен, допускает сцепление произвольного числа строк Создается
копия строки Выполняет
форматирование в соответствии с заданными спецификациями формата. Ниже
приведено более полное описание метода Intern,
Islntern Отыскивается и
возвращается ссылка на строку, если таковая уже хранится во внутреннем пуле
данных. Если же строки нет, то первый из методов добавляет строку во
внутренний пул, второй - возвращает null. Методы
применяются обычно тогда, когда строка создается с использованием построителя
строк - класса StringBuilder Конкатенация
массива строк в единую строку. При конкатенации между элементами массива
вставляются разделители. Операция, заданная методом Join, является
обратной к операции, заданной методом Split. Последний
является динамическим методом и, используя разделители, осуществляет
разделение строки на элементы Методы
Join
и
Split
МетодыJoin
иSplit
выполняют над
строкой текста взаимно обратные преобразования. Динамический методSplit
позволяет
осуществить разбор текста на элементы. Статический методJoin
выполняет
обратную операцию, собирая строку из элементов. Заданный
строкой текст зачастую представляет собой совокупность структурированных
элементов - абзацев, предложений, слов, скобочных выражений и т.д. При работе с
таким текстом необходимо разделить его на элементы, пользуясь специальными
разделителями элементов, - это могут быть пробелы, скобки, знаки препинания.
Практически подобные задачи возникают постоянно при работе со
структурированными текстами. Методы Split и Join облегчают
решение этих задач. Динамический
методSplit
,
как обычно, перегружен. Наиболее часто
используемая реализация имеет следующий синтаксис: public
string[
]
Split(params char[
])
На
вход методуSplit
передается один
или несколько символов, интерпретируемых как разделители. Объектstring
,
вызвавший метод,
разделяется на подстроки, ограниченные этими разделителями. Из этих подстрок
создается массив, возвращаемый в качестве результата метода. Другая реализация
позволяет ограничить число элементов возвращаемого массива. Синтаксис
статического методаJoin
таков: public
static string Join(string delimiters, string[
]
items)
В
качестве результата метод возвращает строку, полученную конкатенацией элементов
массиваitems
,
между которыми вставляется строка
разделителейdelimiters
.
Как правило,
строкаdelimiters
состоит из
одного символа, который и разделяет в результирующей строке элементы массива items
;
но в отдельных
случаях ограничителем может быть строка из нескольких символов. Рассмотрим
примеры применения этих методов. В первом из них строка представляет
сложноподчиненное предложение, которое разбивается на простые предложения. Во
втором предложение разделяется на слова. Затем производится обратная сборка
разобранного текста. Вот код соответствующей процедуры: public
void
TestSplitAndJoin
()
{
Результаты
выполнения этой процедуры показаны на рис. 30. Рисунок 30. Разбор и сборка строки текста Обратите
внимание, что методыSplit
иJoin
хорошо работают,
когда при разборе используется только один разделитель. В этом случае сборка
действительно является обратной операцией и позволяет восстановить исходную
строку. Если же при разборе задается некоторое множество разделителей, то
возникают две проблемы: 1. Невозможно
при сборке восстановить строку в прежнем виде, поскольку не сохраняется
информация о том, какой из разделителей был использован при разборе строки.
Поэтому при сборке между элементами вставляется один разделитель, возможно,
состоящий из нескольких символов; 2. При разборе
двух подряд идущих разделителей предполагается, что между ними находится пустое
слово. Обратите внимание в тексте нашего примера, как и положено, после запятой
следует пробел. При разборе текста на слова в качестве разделителей указаны
символы пробела и запятой. По этой причине в массиве слов, полученном в
результате разбора, имеются пустые слова. Если
при разборе предложения на слова использовать в качестве разделителя только
пробел, то пустые слова не появятся, но запятая будет являться частью некоторых
слов. Как
всегда, есть несколько способов справиться с проблемой. Один из них состоит в
том, чтобы написать собственную реализацию этих функций, другой - в
корректировке полученных результатов, третий - в использовании более мощного
аппарата регулярных выражений. Динамические
методы класса
String
Операции,
разрешенные над строками в C#, разнообразны. Методы этого класса
позволяют выполнять вставку, удаление, замену, поиск вхождения подстроки в
строку. КлассString
наследует методы
классаObject
,
частично их переопределяя. КлассString
наследует и,
следовательно, реализует методы четырех интерфейсов:ICompareable
,
ICloneable
,
IConvertible
,
Enumerable
.
Три из них уже
рассматривались при описании классов-массивов. Рассмотрим
наиболее характерные методы при работе со строками. Сводка
методов, приведенная в таблице 7, дает достаточно полную картину широких
возможностей, имеющихся при работе со строками в C#. Следует помнить,
что классstring
является неизменяемым. ПоэтомуReplace
,
Insert
и другие методы
представляют собой функции, возвращающие новую строку в качестве результата и
не изменяющие строку, вызвавшую метод. Таблица
7. Динамические методы класса
String
Метод
Описание
Вставляет
подстроку в заданную позицию Удаляет
подстроку в заданной позиции Заменяет
подстроку в заданной позиции на новую подстроку Выделяет
подстроку в заданной позиции IndexOf,
IndexOfAny, LastIndexOf, LastIndexOfAny Определяются
индексы первого и последнего вхождения заданной подстроки или любого символа
из заданного набора StartsWith,
EndsWith Возвращается true или false, в зависимости
от того, начинается или заканчивается строка заданной подстрокой PadLeft,
PadRight Выполняет
набивку нужным числом пробелов в начале и в конце строки Trim,TrimStart,
TrimEnd Обратные
операции к методам Pad. Удаляются пробелы в начале и в конце
строки, или только с одного ее конца Преобразование
строки в массив символовПостроение строк
Постоянство строк
Работа со строками
Поле, индексатор и свойство класса String
Операторы класса String
Методы класса String
Методы работы со строками
Метод
Структура и перегруженные версии
Назначение
Сравнение строк
Compare()
public static int Compare(string strA, string strB)
public static int Compare(string strA, int indexA, string strB, int indexB, int length)
CompareOrdinal()
public static int CompareOrdinal(string strA, string strB)
CompareTo()
public int CompareTo(object value)
public int CompareTo(string strB)
Equals()
public override bool Equals(object obj)
public bool Equals(string value)
public static bool Equals(string a, string b)
Конкатенация (соединение) строк
Concat()
public static string Concat(string str0, string str1);
Комбинирует отдельные экземпляры строк в одну строку (конкатенация)
Поиск в строке
Contains()
public bool Contains(string value)
Метод, который позволяет определить, содержится ли в строке определенная подстрока (value)
StartsWith()
public bool StartsWith(string value)
EndsWith()
public bool EndsWith(string value)
IndexOf()
public int IndexOf(char value)
public int IndexOf(char value, int startIndex)
LastIndexOf()
Перегруженные версии аналогичны методу IndexOf()
IndexOfAny()
public int IndexOfAny(char anyOf)
LastIndexOfAny
Перегруженные версии аналогичны методу IndexOfAny()
Разделение и соединение строк
Split
public string Split(params char separator)
public string Split(params char separator, StringSplitOptions options)
Join()
public static string Join(string separator, string value)
Заполнение и обрезка строк
Trim()
public string Trim()
PadLeft()
public string PadLeft(int totalWidth)
PadRight()
Аналогично PadLeft()
Вставка, удаление и замена строк
Insert()
public string Insert(int startIndex, string value)
Remove()
public string Remove(int startIndex)
Replace()
public string Replace(char oldChar, char newChar)
Смена регистра
ToUpper()
public string ToUpper()
ToLower()
public string ToLower()
Получение подстроки из строки
Substring()
public string Substring(int startIndex)
Немного о сравнении строк в C#
Значения, определяемые в перечислении StringComparison
Значение
Описание
CurrentCulture
Сравнение строк производится с использованием текущих настроек параметров культурной среды
CurrentCultureIgnoreCase
Сравнение строк производится с использованием текущих настроек параметров культурной среды, но без учета регистра
InvariantCulture
Сравнение строк производится с использованием неизменяемых, т.е. универсальных данных о культурной среде
InvariantCultureIgnoreCase
Сравнение строк производится с использованием неизменяемых, т.е. универсальных данных о культурной среде и без учета регистра
Ordinal
Сравнение строк производится с использованием порядковых значений символов в строке. При этом лексикографический порядок может нарушиться, а условные обозначения, принятые в отдельной культурной среде, игнорируются
OrdinalIgnoreCase
Сравнение строк производится с использованием порядковых значений символов в строке, но без учета регистра
Конкатенация
Сравнение строк
Поиск в строке
Разделение строк
Обрезка строки
Вставка
Удаление строк
Замена
Смена регистра
//операции
над строками
string
s1
=
"ABC",
s2
=
"CDE";
string
s3
=
s1
+
s2;
bool
b1
=
(s1
==
s2);
char
ch1
=
s1,
ch2
=
s2;
+
s2
=
s1;
b1
=
(s1
!=
s2);
ch2
=
s2;
Console.WriteLine("s1={0},
s2={1}, b1={2},"
+
"ch1={3},
ch2={4}", s1, s2, b1, ch1, ch2);
//Неизменяемые значения
s
1
=
"
Zenon
";
//
s
1="
L
";
}
string
txt
= "А это
пшеница, которая в темном чулане хранится" +
", в доме, который
построил Джек!";
Console
.
WriteLine
("
txt
={0}",
txt
);
Console
.
WriteLine
("Разделение
текста на простые предложения:");
string[
]
SimpleSentences,
Words;
//
размерность
массивов
SimpleSentences
и
Words
//устанавливается
автоматически в соответствии с
//размерностью массива, возвращаемого методом
Split
SimpleSentences
=
txt.Split(",");
for (int i
= 0;
i
<
SimpleSentences.Length;
i++)
Console.WriteLine("SimpleSentences[{0}]=
{1}",
i,
SimpleSentences[i]);
string txtjoin
=
string.Join(",",
SimpleSentences);
Words
=
txt.Split(",",
"
");
for
(int i
=
0;
i
<
Words.Length;
i++)
Console.WriteLine("Words[{0}]=
{1}",
i,
Words[i]);
txtjoin
=
string.Join("
",
Words);
Console.WriteLine("txtjoin={0}",
txtjoin);
}
//
TestSplitAndJoin