Уровень 22. Ответы на вопросы к собеседованию по теме уровня
Метод equalsIgnoreCase – совпадают ли строки, игнорируя регистр букв.
Как отсортировать список строк в алфавитном порядке?
Используя метод Collections.sort() .
В какой кодировке хранятся строки в Java?
Строки в java хранятся в Unicode.
Как преобразовать строку в кодировку Windows-1251?
Как разбить строку на отдельные слова?
-
String[] split(String regex)
Как развернуть строку задом наперед?
Что происходит, когда мы пишем «A»+»b»+»C»?
Что такое mutable и immutable типы?
Объекты, которые после их создания изменить нельзя, называются неизменяемыми или immutable .
Объекты, которые после создания можно изменить, называются изменяемыми или mutable .
Что дает типу String то, что его сделали immutable ?
String широко используется, как параметр для многих классов Java, в частности для открытия сетевых соединений, подключений к БД, открытию файлов и пр. И если бы строка изменялась, то мы могли получить доступ к объекту (файлу например), на который мы имеем право, затем изменить строку с именем (случайно или намеренно) и получить доступ уже к другому файлу.
Так же String используется в механизме загрузки файлов, и это – фундаментальный аспект. И если бы строка изменялась, то запрос на загрузку «java.io.Writer» мог бы быть изменён на «DiskErasingWriter«.
Из-за того, что строка не изменяется, она кэширует свой хэшкод и не вычисляет его каждый раз, когда мы его вызываем, что делает строку очень быстрой как ключ для hashmap .
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Кодировать строку в UTF-8 в Java
Введение При работе со строками в Java нам часто требуется кодировать их в определенной кодировке, такой как UTF-8. > UTF-8 представляет собой кодировку символов переменной ширины, которая использует от одного до четырех восьмибитных байтов для представления всех допустимых кодовых точек Unicode. Кодовая точка может представлять отдельные символы, но также может иметь другие значения, например, для форматирования. "Переменная ширина" означает, что он кодирует каждую кодовую точку с разным количеством байтов (от одного до четырех) и как пробел-sa
Время чтения: 6 мин.
Вступление
При работе со строками в Java нам часто требуется кодировать их в определенной кодировке, такой как UTF-8 .
UTF-8 представляет собой кодировку символов переменной ширины, которая использует от одного до четырех восьмибитных байтов для представления всех допустимых кодовых точек Unicode .
Кодовая точка может представлять отдельные символы, но также может иметь другие значения, например, для форматирования. «Переменная ширина» означает, что он кодирует каждую кодовую точку с различным количеством байтов (от одного до четырех), и в качестве меры экономии места обычно используемые кодовые точки представлены меньшим количеством байтов, чем те, которые используются реже.
UTF-8 использует один байт для представления кодовых точек от 0 до 127 , что делает первые 128 кодовых точек однозначным отображением с символами ASCII, поэтому UTF-8 обратно совместим с ASCII.
Примечание. Java кодирует все строки в UTF-16, в котором для хранения кодовых точек используется минимум два байта. Зачем тогда нужно преобразовывать в UTF-8?
Не весь ввод может быть в кодировке UTF-16 или UTF-8, если на то пошло. На самом деле вы можете получить строку в кодировке ASCII, которая не поддерживает такое количество символов, как UTF-8. Кроме того, не весь вывод может обрабатывать UTF-16, поэтому имеет смысл преобразовать его в более универсальный UTF-8.
Мы будем работать с несколькими строками, которые содержат символы Unicode, с которыми вы, возможно, не сталкиваетесь ежедневно, — например, č , ß и あ , имитирующие ввод данных пользователем.
Выпишем пару строк:
Теперь давайте воспользуемся конструктором String(byte[] bytes, Charset charset) для String, чтобы воссоздать эти строки, но с другим Charset символов, имитирующим ввод ASCII, который пришел к нам в первую очередь:
После того, как мы создали эти строки и закодировали их как символы ASCII, мы можем распечатать их:
В то время как первые две строки содержат всего несколько символов, которые не являются допустимыми символами ASCII, последняя не содержит их .
Чтобы избежать этой проблемы, мы можем предположить, что не весь ввод уже может быть закодирован по нашему вкусу, и закодировать его, чтобы самостоятельно устранить такие случаи. Есть несколько способов кодирования строки в UTF-8 в Java:
Кодирование строки в Java просто означает вставку определенных байтов в массив байтов, составляющий строку, — предоставление дополнительной информации, которая может быть использована для ее форматирования после того, как мы сформируем экземпляр String
Использование метода getBytes ()
Класс String , состоящий из байтов, естественно, предлагает getBytes() , который возвращает массив байтов, используемый для создания String. Поскольку кодирование на самом деле просто манипулирует этим массивом байтов, мы можем пропустить этот массив через Charset чтобы сформировать его при получении данных.
По умолчанию, без предоставления Charset , байты кодируются с использованием Charset платформ по умолчанию, который может быть не UTF-8 или UTF-16. Давайте возьмем байты String и распечатаем их:
Это кодовые точки для наших закодированных символов, и они не очень полезны для человеческого глаза. Хотя, опять же, мы можем использовать конструктор String для создания удобочитаемой строки из этой самой последовательности. Учитывая тот факт, что мы закодировали этот массив байтов в UTF_8 , мы можем продолжить и безопасно создать новую строку из этого:
Примечание. Вместо того, чтобы кодировать их с помощью getBytes() , вы также можете кодировать байты с помощью конструктора String:
Теперь это выводит ту же строку, с которой мы начали, но в кодировке UTF-8:
Закодируйте строку в UTF-8 с помощью Java 7 StandardCharsets
Начиная с Java 7 , мы познакомились с StandardCharsets , который имеет несколько Charset таких как US_ASCII , ISO_8859_1 , UTF_8 и UTF-16 среди других.
Каждый Charset имеет encode() и decode() , которые принимают CharBuffer (который implements CharSequence , как String ). На практике это означает, что мы можем вставить String в методы encode() Charset .
Метод encode() возвращает ByteBuffer который мы можем легко снова превратить в String.
Раньше, когда мы использовали наш getBytes() , мы сохраняли полученные байты в массиве байтов, но при использовании StandardCharsets все немного по-другому. Сначала нам нужно использовать класс ByteBuffer для хранения наших байтов. Затем нам нужно как кодировать, так и декодировать обратно наши недавно выделенные байты. Посмотрим, как это работает в коде:
Выполнение этого кода приводит к:
Закодируйте строку в UTF-8 с помощью Apache Commons
Пакет кодеков Apache Commons содержит простые кодировщики и декодеры для различных форматов, таких как Base64 и Hexadecimal . Помимо этих широко используемых кодеров и декодеров, пакет кодеков также поддерживает набор утилит фонетического кодирования .
Чтобы мы могли использовать кодек Apache Commons, нам нужно добавить его в наш проект в качестве внешней зависимости.
Используя Maven, давайте добавим commons-codec к нашему файлу pom.xml
В качестве альтернативы, если вы используете Gradle:
Теперь мы можем использовать служебные классы Apache Commons — и, как обычно, мы будем использовать класс StringUtils
Это позволяет нам преобразовывать строки в байты и обратно, используя различные кодировки, требуемые спецификацией Java. Этот класс является нулевым и потокобезопасным, поэтому у нас есть дополнительный уровень защиты при работе со строками.
Чтобы закодировать String в UTF-8 с StringUtils класса StringUtils Apache Common, мы можем использовать метод getBytesUtf8() , который работает так же, как метод getBytes() с указанным Charset :
Или вы можете использовать обычный класс StringUtils из зависимости commons-lang3
Если вы используете Gradle:
И теперь мы можем использовать тот же подход, что и с обычными строками:
Хотя этот подход является потокобезопасным и нулевым:
Заключение
В этом руководстве мы рассмотрели, как кодировать строку Java в UTF-8 . Мы рассмотрели несколько подходов — создание String вручную с помощью getBytes() и управление ими, StandardCharsets а также Apache Commons.
Работа со строками Java
Тип данных может содержать последовательность (строку) символов. После создания строки вы можете искать внутри нее, создавать из нее подстроки, новые строки на основе первой, но с заменой некоторых частей, а также многое другое.
Представление
Строка Java (до Java 9) представлена внутри Java VM с использованием байтов, закодированных как UTF-16. UTF-16 использует 2 байта для представления одного символа. Таким образом, символы строки представляются с использованием массива char.
UTF – это кодировка символов, которая может представлять символы из разных языков (алфавитов). Вот почему необходимо использовать 2 байта на символ – чтобы иметь возможность представлять все эти разные символы в одной строке.
Компактные строки
Начиная с Java 9 и выше, Java VM может оптимизировать строки с помощью новой функции, называемой компактными строками. Она позволяет виртуальной машине определять, содержит ли строка только символы ISO-8859-1 / Latin-1. Если это так, она будет использовать только 1 байт на символ внутри. Таким образом, символы компактной строки могут быть представлены байтовым массивом вместо массива char.
Может ли String быть представлена в виде компактной строки или нет, определяется при создании строки. Однажды созданная строка является неизменной, поэтому это безопасно.
Создание строки
Строки являются объектами. Поэтому нужно использовать оператор new для создания нового объекта Java String:
Текст внутри кавычек – это текст, который будет содержать объект String.
Строковые литералы
Есть более короткий способ создания новой строки:
Вместо того, чтобы передавать текст «Hello World» в качестве параметра конструктору String, вы можете просто написать сам текст внутри символов двойной кавычки. Это называется строковым литералом. При компиляции Java кода самостоятельно определяется, как будет создана новая строка, представляющая данный текст.
Escape-символы
Литералы Java Strings принимают набор из которых переводятся в специальные символы в созданной строке. Пример создания с использованием escape-символов:
Этот строковый литерал приведет к строке, которая начинается с символа табуляции и заканчивается переводом каретки и символом новой строки.
Константы
Если вы используете ту же строку (например, «Hello World») в других объявлениях переменных String, виртуальная машина Java может создать в памяти только один экземпляр String. Таким образом, строковый литерал становится де-факто константой или синглтоном. Различные переменные, инициализированные одной и той же константной строкой, будут указывать на один и тот же экземпляр String в памяти.
В этом случае виртуальная машина заставит myString1 и myString2 указывать на один и тот же объект String.
Точнее говоря, объекты, представляющие литералы Java String, получены из пула констант String, который виртуальная машина Java хранит внутри. Это означает, что даже классы из разных проектов, скомпилированные отдельно, но используемые в одном приложении, могут совместно использовать объекты String. Обмен происходит во время выполнения. Это не функция времени компиляции.
Если вы хотите быть уверены, что две строковые переменные указывают на отдельные строковые объекты, используйте оператор new следующим образом:
Даже если значение (текст) двух созданных строк Java одинаково, виртуальная машина Java создаст в памяти два разных объекта для их представления.
Конкатенация строк
Конкатенация строк означает добавление одной строки к другой. Строки являются неизменными, то есть они не могут быть изменены после создания. Поэтому при объединении двух объектов Java String друг с другом результат фактически помещается в третий объект String.
Содержимое строки, на которую ссылается переменная три, будет Hello World. Два других объекта Strings нетронуты.
Производительность конкатенации
При объединении строк вам следует остерегаться возможных проблем с производительностью. Конкатенация двух строк будет преобразована компилятором Java в нечто вроде этого:
Создается новый StringBuilder, который передает первую строку в свой конструктор, а вторую – в свой метод append(), прежде чем вызвать метод toString(). Этот код фактически создает два объекта: экземпляр StringBuilder и новый экземпляр String, возвращенный методом toString().
При выполнении самих себя в виде одного оператора эти дополнительные затраты на создание объекта незначительны. Однако когда выполняется внутри цикла, это другая история.
Вот цикл, содержащий вышеуказанный тип конкатенации строк:
Этот код будет скомпилирован в нечто похожее на это:
Теперь для каждой итерации в этом цикле создается новый StringBuilder. Кроме того, объект String создается методом toString(). Это приводит к небольшим расходам на создание экземпляров за одну итерацию: один объект StringBuilder и один объект String. Само по себе не является настоящим убийцей производительности, хотя.
Каждый раз, когда выполняется новый код StringBuilder(result), конструктор StringBuilder копирует все символы из результирующего String в StringBuilder. Чем больше итераций цикла, тем больше будет результат String. Чем больше растет результат String, тем больше времени требуется для копирования символов из него в новый StringBuilder и повторного копирования символов из StringBuilder во временную строку, созданную методом toString(). Другими словами, чем больше итераций, тем медленнее становится каждая итерация.
Самый быстрый способ объединения строк – создать StringBuilder один раз и повторно использовать один и тот же экземпляр внутри цикла. Вот как это выглядит:
Этот код избегает как экземпляров объектов StringBuilder и String внутри цикла, так и, следовательно, позволяет избежать двухкратного копирования символов, сначала в StringBuilder, а затем снова в String.
Длина строки
Длина строки – это количество символов, которое содержит строка, а не количество байтов, используемых для представления строки. Получить ее можно, используя метод length():
Подстроки
Вы можете извлечь часть строки – подстроку с помощью метода substring() класса String:
После выполнения этого кода переменная substring будет содержать строку Hello.
Метод substring() принимает два параметра. Первый – это индекс символа первого символа, который будет включен в подстроку. Второй – это индекс последнего символа для включения в подстроку. Параметры означают «от – в том числе до -».
Первый символ в строке имеет индекс 0, второй символ имеет индекс 1 и т. д. Последний символ в строке имеет индекс String.length() – 1.
Поиск с помощью indexOf()
Вы можете искать подстроки в Strings, используя метод indexOf():
Индексная переменная будет содержать значение 6 после выполнения этого кода. Метод indexOf() возвращает индекс, в котором находится первый символ в первой соответствующей подстроке. В этом случае W совпадающей подстроки World была найдена по индексу 6. Если подстрока не найдена в строке, метод возвращает -1.
Существует версия метода indexOf(), которая берет индекс, с которого начинается поиск. Таким образом, вы можете искать в строке, чтобы найти более одного вхождения подстроки:
Этот код просматривает строку «это хорошо или это плохо?» для вхождений подстроки “is”. Для этого используется метод indexOf(substring, index). Параметр index указывает, с какого индекса символа в строке следует начать поиск. В этом примере поиск начинается с 1 символа после индекса, в котором было найдено предыдущее вхождение.
Подстрока “is” находится в четырех местах. Два раза в словах «есть» и два раза внутри слова «этот».
Класс Java String также имеет метод lastIndexOf(), который находит последнее вхождение подстроки:
Выход – 21, который является индексом последнего вхождения подстроки “is”.
Сопоставление строки с регулярным выражением с помощью match()
Метод Java String match() принимает регулярное выражение в качестве параметра и возвращает true, если регулярное выражение соответствует строке, и false, если нет:
Сравнение
Строки также имеют набор методов, используемых для сравнения строк:
- equals();
- equalsIgnoreCase();
- StartWith();
- EndsWith();
- compareTo().
equals()
Метод equals() проверяет, точно ли две строки равны друг другу. Если они есть, возвращается true. Если нет, false:
Две строки одна и три равны, но одна не равна двум или четырем. Регистр символов также должен совпадать, поэтому строчные буквы не равны прописным.
Вывод, напечатанный из кода выше, будет:
equalsIgnoreCase()
Класс String также имеет метод equalsIgnoreCase(), который сравнивает две строки, но игнорирует регистр символов. Таким образом, заглавные буквы считаются равными их строчным эквивалентам.
StartWith() и EndWith()
Методы StartWith() и EndWith() проверяют, начинается ли String с определенной подстроки:
В этом примере создается строка и проверяется, начинается ли она и заканчивается ли она различными подстроками.
- Первая строка (после объявления String) проверяет, начинается ли String с подстроки «This». Поскольку это происходит, метод startWith() возвращает true.
- Вторая строка проверяет, начинается ли строка с подстроки «This» при запуске сравнения с символа с индексом 5. Результат равен false, поскольку символ с индексом 5 равен «i».
- Третья строка проверяет, заканчивается ли String подстрокой «code». Поскольку это происходит, метод endWith() возвращает true.
- Четвертая строка проверяет, заканчивается ли String подстрокой “shower”. Так как это не так, метод endWith() возвращает false.
compareTo()
Метод compareTo() сравнивает строку с другой и возвращает int, сообщающий, меньше ли эта строка, равна или больше другой.
- Если строка в порядке сортировки раньше, чем другая, возвращается отрицательное число.
- совпадает с другой, возвращается 0.
- Если находится после другой в порядке сортировки, выводит положительное число.
В этом примере сравнивается одна строка с двумя другими. Вывод:
Числа отрицательны, потому что одна строка находится в порядке сортировки раньше, чем две другие.
Метод compareTo() фактически принадлежит интерфейсу Comparable.
Вы должны знать, что метод compareTo() может работать некорректно для строк на языках, отличных от английского. Чтобы правильно отсортировать строки на определенном языке, используйте Collator.
Обрезка посредством trim()
Класс Java String содержит метод trim(), который может обрезать строковый объект. Предназначен для удаления в начале и конце строки пробелов, табуляцию и переход на новую строку:
После выполнения этого кода усеченная переменная будет указывать на экземпляр String со значением
Пробельные символы в начале и конце объекта String были удалены. Символ пробела внутри строки не был затронут. Имеется в виду между первым и последним символом, не являющимся пробелом.
Метод trim() не изменяет экземпляр String. Вместо этого он возвращает новый объект Java String, который равен объекту String, из которого он был создан, но с удаленным пробелом в начале и конце строки.
Метод trim() может быть очень полезен для обрезки текста, введенного пользователем в поля ввода. Например, пользователь может ввести свое имя и случайно поставить дополнительный пробел после последнего слова или перед первым словом. Метод trim() – это простой способ удалить такие лишние пробелы.
Замена символов replace()
Класс Java String содержит метод replace(), который может заменять символы в строке. Он фактически не заменяет символы в существующей строке. Скорее, возвращает новый экземпляр String. Он равен экземпляру String, из которого он был создан, но с заменой указанных символов. Пример:
После выполнения этого кода замененная переменная будет указывать на строку с текстом:
Метод replace() заменит все символы, соответствующие символу, переданному методу в качестве первого параметра, вторым символом, переданным в качестве параметра.
replaceFirst()
Метод Java String replaceFirst() возвращает новую строку с первым совпадением регулярного выражения, переданного в качестве первого параметра, со строковым значением второго параметра:
Возвращается строка «один пять три два один».
replaceAll()
Метод Java String replaceAll() возвращает новую строку со всеми совпадениями регулярного выражения, переданного в качестве первого параметра, со строковым значением второго параметра:
Возвращается строка «один пять три пять один».
Разделение
Класс Java String содержит метод split(), который можно использовать для разделения String на массив объектов String:
После выполнения этого кода Java массив вхождений будет содержать экземпляры String:
Исходная строка была разделена на символы a. Возвращенные строки не содержат символов a. Символы a считаются разделителями для деления строки, а разделители не возвращаются в результирующий массив строк.
Параметр, передаваемый методу split(), на самом деле является регулярным выражением Java, которые могут быть довольно сложными. Приведенное выше соответствует всем символам, даже буквам нижнего регистра.
Метод String split() существует в версии, которая принимает ограничение в качестве второго параметра – limit:
Параметр limit устанавливает максимальное количество элементов, которое может быть в возвращаемом массиве. Если в строке больше совпадений с регулярным выражением, чем заданный лимит, то массив будет содержать совпадения с лимитом – 1, а последним элементом будет остаток строки из последнего среза – 1 совпадением. Итак, в приведенном выше примере возвращаемый массив будет содержать эти две строки:
Первая строка соответствует регулярному выражению. Вторая – это остальная часть строки после первого куска.
Выполнение примера с ограничением 3 вместо 2 приведет к тому, что эти строки будут возвращены в результирующий массив String:
Обратите внимание, что последняя строка по-прежнему содержит символ в середине. Это потому, что эта строка представляет остаток строки после последнего совпадения (a после ‘n водил с’).
Выполнение приведенного выше примера с пределом 4 или выше приведет к тому, что будут возвращены только строки Split, поскольку в String есть только 4 совпадения с регулярным выражением a.
Преобразование чисел в строку с помощью valueOf()
Класс содержит набор перегруженных статических методов с именем valueOf(), которые можно использовать для преобразования числа в строку:
Преобразование объектов в строки
Класс Object содержит метод с именем toString(). Поскольку все классы Java расширяют (наследуют) класс Object, все объекты имеют метод toString(). Он может использоваться для создания строкового представления данного объекта:
Примечание. Чтобы метод toString() возвращал нормальное String представление заданного объекта, класс объекта должен переопределить метод toString(). Если нет, то будет вызван метод toString() по умолчанию (унаследованный от класса Object), которые не предоставляет столько полезной информации.
Получение символов и байтов
Можно получить символ по определенному индексу в строке, используя метод charAt():
Этот код распечатает:
Так как это символы, расположенные в индексах 0 и 3 в строке.
Вы также можете получить байтовое представление метода String, используя метод getBytes():
Первый вызов getBytes() возвращает байтовое представление строки, используя кодировку набора символов по умолчанию на машине. Набор символов по умолчанию зависит от компьютера, на котором выполняется код. Поэтому обычно лучше явно указать набор символов, который будет использоваться для создания представления байтов (как в следующей строке).
Второй вызов getBytes() возвращает UTF-8-байтовое представление String.
Преобразование в верхний и нижний регистр
Вы можете конвертировать строки в верхний и нижний регистр, используя методы toUpperCase() и toLowerCase():
В какой кодировке хранятся строки в java
Со строками можно производить операцию сцепления строк (concatenation), обозначаемую знаком плюс +. Эта операция создает новую строку, просто составленную из состыкованных первой и второй строк, как показано в начале данной главы. Ее можно применять и к константам, и к переменным. Например:
String attention = «Внимание: «;
String s = attention + «неизвестный символ»;
Вторая операция — присваивание += — применяется к переменным в левой части:
attention += s;
Поскольку операция + перегружена со сложения чисел на сцепление строк, встает вопрос о приоритете этих операций. У сцепления строк приоритет выше, чем у сложения, поэтому, записав «2» + 2 + 2 , получим строку » 222 «. Но, записав 2 + 2 + «2» , получим строку «42», поскольку действия выполняются слева направо. Если же запишем «2» + (2 + 2) , то получим «24» .
- ссылка dst = null ;
- индекс begin отрицателен;
- индекс begin больше индекса end ;
- индекс end больше длины строки;
- индекс ind отрицателен;
- ind + (end — begin) > dst.length.
Метод substring(int begin, int end) выделяет подстроку от символа с индексом begin включительно до символа с индексом end исключительно. Длина подстроки будет равна end — begin .
Метод substring (int begin) выделяет подстроку от индекса begin включительно до конца строки.
Если индексы отрицательны, индекс end больше длины строки или begin больше чем end , то возникает исключительная ситуация.
Например, после выполнения
String s = «Write onсe, run anywhere.»;
String sub1 = s.substring(6, 10);
String sub2 = s.substring(16);
получим в строке sub1 значение » once «, а в sub2 — значение » anywhere «.
- Сравниваются символы данной строки this и строки str с одинаковым индексом, пока не встретятся различные символы с индексом, допустим k , или пока одна из строк не закончится.
- В первом случае возвращается значение this.charAt(k) — str.charAt(k), т. е. разность кодировок Unicode первйх несовпадающих символов.
- Во втором случае возвращается значение this.length() — str.length() , т. е. разность длин строк.
- Если строки совпадают, возвращается 0.
- хотя бы один из индексов ind1 или ind2 отрицателен;
- хотя бы одно из ind1 + len или ind2 + len больше длины соответствующей строки;
- хотя бы одна пара символов не совпадает.
Поиск всегда ведется с учетом регистра букв.
Первое появление символа ch в данной строке this можно отследить методом indexOf(int ch) , возвращающим индекс этого символа в строке или -1 , если символа ch в строке this нет.
Например, «Молоко», indexOf(‘о’) выдаст в результате 1 .
Конечно, этот метод выполняет в цикле последовательные сравнения this.charAt(k++> == ch , пока не получит значение true .
Второе и следующие появления символа ch в данной строке this можно отследить методом indexOf(int ch, int ind) .
Этот метод начинает поиск символа ch с индекса ind . Если ind < о, то поиск идет с начала строки, если ind больше длины строки, то символ не ищется, т. е. возвращается -1.
Например, «молоко».indexof(‘о’, indexof (‘о’) + 1) даст в результате 3. .
Последнее появление символа ch в данной строке this отслеживает метод lastIndexof (int ch). Он просматривает строку в обратном порядке. Если символ ch не найден, возвращается.-1.
Например, «Молоко».lastindexof(‘о’) даст в результате 5.
Предпоследнее и предыдущие появления символа ch в данной строке this можно отследить методом lastIndexof (int ch, int ind) , который просматривает строку в обратном порядке, начиная с индекса ind .
Если ind больше длины строки, то поиск идёт от конца строки, если ind < о, то возвращается-1.
Поиск всегда ведется с учетом регистра букв.
Первое вхождение подстроки sub в данную строку this отыскивает метод indexof (String sub). Он возвращает индекс первого символа первого вхождения подстроки sub в строку или -1, если подстрока sub не входит в строку this . Например, » Раскраска «.indexof («рас») даст в результате 4.
Если вы хотите начать поиск не с начала строки, ас какого-то индекса ind , используйте метод indexOf (String sub, int ind). если i nd < 0 , то поиск идет с начала строки, если ind больше .длины строки, то символ не ищется, т. е. возвращается -1.
Последнее вхождение подстроки sub в данную строку this можно отыскать методом lastindexof ( string sub ), возвращающим индекс первого символа последнего вхождения подстроки sub в строку this или (-1), если подстрока sub не входит в строку this .
Последнее вхождение подстроки sub не во всю строку this , а только в ее начало до индекса ind можно отыскать методом l astIndexof(String stf, int ind ). Если ind больше длины строки, то .поиск идет от конца строки, если ind < о , то возвращается -1.
Для того чтобы проверить, не начинается ли данная строка this с подстроки sub , используйте логический метод startsWith(string sub) , возвращающий true , если данная строка this начинается с подстроки sub , или совпадает с ней, или подстрока sub пуста.
Можно проверить и появление подстроки sub в данной строке this , начиная с некоторого индекса ind логическим методом s tartsWith(String sub),int ind). Если индекс ind отрицателен или больше длины строки, возвращается false .
Для того чтобы проверить, не заканчивается ли данная строка this подстрокой sub , используйте логический метод endsWitht(String sub) . Учтите, что он возвращает true , если подстрока sub совпадает со всей строкой или подстрока sub пуста.
Например, if (fileName.endsWith(«. Java»)) отследит имена файлов с исходными текстами Java.
Перечисленные выше методы создают исключительную ситуацию, если
sub == null.
Если вы хотите осуществить поиск, не учитывающий регистр букв, измените предварительно регистр всех символов строки.
Метод toLowerCase () возвращает новую строку, в которой все буквы переведены в нижний регистр, т. е. сделаны строчными.
Метод toUpperCase () возвращает новую строку, в которой все буквы переведены в верхний регистр, т. е. сделаны прописными.
При этом используется локальная кодовая таблица по умолчанию. Если нужна другая локаль, то применяются методы toLowerCase(Locale l oc ) и toUpperCase(Locale loc).
Метод replace (int old, int new) возвращает новую строку, в которой все вхождения символа old заменены символом new . Если символа old в строке нет, то возвращается ссылка на исходную строку.
Например, после выполнения » Рука в руку сует хлеб» , replace (‘у’, ‘е’) получим строку » Река в реке сеет хлеб».
Регистр букв при замене учитывается.
Количество символов в строке можно узнать, как и для объекта класса String , методом length () , а емкость — методом capacity ().
Создать объект класса stringBuf fer можно только конструкторами.
В классе stringBuffer три конструктора:
stringBuffer () — создает пустой объект с емкостью 16 символов;
stringBuffer .(int capacity) — создает пустой объект заданной емкости capacity ;
StringBuffer (String str) — создает объект емкостью str . length () + 16, содержащий строку str .
В классе stringBuffer есть десять методов append (), добавляющих подстроку в конец строки. Они не создают новый экземпляр строки, а возвращают ссылку на ту же самую, но измененную строку.
Основной метод append (string str) присоединяет строку str в конец данной строки. Если ссылка str == null, то добавляется строка «null».
Шесть методов append (type elem) добавляют примитивные типы boolean, char, int, long, float, double, преобразованные в строку.
Два метода присоединяют к строке массив str и подмассив sub символов,
преобразованные в строку: append (char [] str) И append (char [.] , sub, int offset, int len).
Десятый метод добавляет просто объект append (Object obj). Перед этим объект obj преобразуется в строку своим методом tostring ().
Десять методов insert () предназначены для вставки строки, указанной параметром метода, в данную строку. Место вставки задается первым параметром метода ind . Это индекс элемента строки, перед которым будет сделана вставка. Он должен быть неотрицательным и меньше длины строки, иначе возникнет исключительная ситуация. Строка раздвигается, емкость буфера при необходимости увеличивается. Методы возвращают ссылку ни ту же преобразованную строку.
Основной метод insert (int ind, string str) вставляет строку str в данную строку перед ее символом с индексом and . Если ссылка s tr == null вставляется строка «null».
Например, после выполнения
String s = new StringBuffer(«Это большая строка»). insert(4, «не»).toString();
ПОЛУЧИМ s == «Это небольшая строка».
Метод sb.insert(sb.length о, «xxx») будет работать так же, как метод
sb.append(«xxx») .
Шесть методов insert (int ind, type elem) вставляют примитивные типы boolean, char, int, long, float, double, преобразованные в строку.
Два метода вставляют массив str и подмассив sub символов, преобразованные в строку:
i nsert(int ind, chart] str)
insert(int ind, char[] sub, int offset, int len)
Десятый метод вставляет просто объект :
insert(int ind, Object obj)
Объект obj перед добавлением преобразуется в строку своим методом
toString ().
Метод delete tint begin, int end) удаляет из строки символы, начиная с индекса begin включительно до индекса end исключительно, если end больше длины строки, то до конца строки.
Например, после выполнения
String s = new StringBuffer(«Это небольшая строка»).
delete(4, 6).toString();
получим s == «Это большая строка».
Если begin отрицательно, больше длины строки или больше end , возникает исключительная ситуация.
Если begin == end, удаление не происходит.
Метод deieteCharAt (int ind) удаляет символ с указанным индексом ind . Длина строки уменьшается на единицу.
Если индекс ind отрицателен или больше длины строки, возникает исключительная ситуация.
Метод replace (int begin, int end. String str ) удаляет символы из строки, начиная с индекса begin включительно до индекса end исключительно, если end больше длины строки, то до конца строки, и вставляет вместо них строку str .
Если begin отрицательно, больше длины строки или больше end , возникает исключительная ситуация.
Разумеется, метод replace () — это последовательное выполнение методов
delete () и insert ().
Метод reverse о меняет порядок расположения символов в строке на обратный порядок.
Например, после выполнения
String s = new StringBuffer(«Это небольшая строка»),
reverse().toString();
получим s == «акортс яашьлобен отЭ».