Как сделать пустую строку в java

Добавил пользователь Валентин П.
Обновлено: 04.10.2024

в чем разница между null и "" (пустая строка)?

Я написал простой код:

оба заявления возвратить false . Похоже, я не могу найти в чем собственно разница между ними.

"" является фактической строкой, хотя и пустой.

null, однако, означает, что переменная String указывает ни на что.

a==b возвращает false, потому что "" и null не занимают одно и то же пространство в памяти-другими словами, их переменные не указывают на одни и те же объекты.

a.equals(b) возвращает false, потому что "" не равно null, очевидно.

разница в том, что, поскольку "" является фактической строкой, вы все равно можете вызвать методы или функции на нем, как

если строка равна null, например b, Java бросит a NullPointerException если вы пытались ссылаться, сказал:

если разница, которую вы задаетесь вопросом о == по сравнению с равными, это так:

== сравнивает ссылки, как если бы я пошел

это выведет false, потому что я выделил два разные объекты, а a и b указывают на разные объекты.

имейте в виду, что Java имеет особый случай для строк.

вы могли бы подумать, что выход будет false , так как он должен выделять два разных Веревка. На самом деле, Java будет интерн литеральные строки (те, которые инициализируются как a и b в нашем примере). Поэтому будьте осторожны, потому что это может дать некоторые ложные срабатывания о том, как == работает.

вы также можете понять разницу между null и пустой строкой таким образом:

String является объектом и может быть null

null означает, что объект String не был создан

" "является фактическим значением строки экземпляра объекта, например "aaa"

то, что ваши утверждения говорят вам, это просто то, что "" не то же самое, что null - что верно. ""является пустой строкой; null означает, что значение не назначено.

было бы более поучительно попробовать:

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

существует довольно значительная разница между ними. Пустая строка "" - это " строка, в которой нет символов."Это фактическая строка, которая имеет четко определенную длину. Все стандартные строковые операции хорошо определены в пустой строке - вы можете преобразовать ее в нижний регистр, посмотреть индекс некоторого символа в ней и т. д. Нулевая строка null " нет строки вообще.- У него нет длины, потому что это вовсе не струна. Попытка применить любой стандарт операция string для нулевой строки вызовет NullPointerException во время выполнения.

здесь a is an Object но b(null) и не объект является нулевой ссылкой

здесь мой аналогичный ответ

null означает, что имя не ссылается на какой-либо экземпляр объекта. "" означает пустую строку.

здесь a ссылается на какой-то объект, который является пустой строкой. b не ссылается на какой-либо объект, поскольку он равен null.

в Java назначен ссылочный тип null и нет значения вообще. Строка, назначенная "" имеет значение: пустая строка, то есть строка без символов в нем. Когда переменная назначена null Это означает, что нет никакого базового объекта любого рода, строки или иным способом.

"" и null обе разные . первый означает, что как часть объявления строковой переменной строковая константа была создана в пуле строк, и для нее была назначена некоторая память.

но когда мы объявляем его с null тогда он только что был создан JVM, но для него не было выделено памяти. поэтому, если вы пытаетесь получить доступ к этому объекту, проверив его с помощью "" - пустой переменной , это не может предотвратить исключение nullpointerexception . Пожалуйста, найдите ниже один use-case.

ссылка на пустую строку "" указывает на объект в куче - так что вы можете вызывать методы на нем.

но ссылка, указывающая на null нет объекта в куче и, таким образом, вы получите NullPointerException .

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

из статьи Википедии о пустая строка.

строка может быть пустой или иметь null значение. Если строка null , Это не относится ни к чему в памяти. Попробуй!--2-->. Это связано с тем, что если строка пуста, она все равно возвращает длину 0. Поэтому, если вы ничего не вводите для того же самого, он все равно будет продолжать цикл, так как он не регистрирует строку как null . В то время как если вы проверите длину, то она выйдет из цикла.

эта концепция может быть лучше понято из математики. Вы когда-нибудь пробовали делить число (не ноль) на 0 с помощью калькулятора e.g 7/0? Вы получите результат, который выглядит примерно так: undefined , not a number , null etc. Это означает, что операция невозможна по каким-то причинам (оставим эти причины для обсуждения в другой день).

теперь выполните следующее: 0/7. Вы получите выход, 0. Это означает, что операция возможна и может быть выполнена, но вы ответ просто 0, потому что после деления ничего не остается. Существует допустимый выход, и этот выход равен нулю.

в первом примере не только вывод был недопустимым, операция была невозможна для выполнения. Это сродни null строка в java. Второй пример сродни empty строку.

перебирая накопленный материал по java.lang.String решил сделать небольшую подборку примеров из эффективного (и не очень) использования.

Любое преобразование строки порождает новую строку

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

Теперь этот код

В целом это поведение логично: зачем городить новую строку, если в исходной не произошло никаких изменений. Это же справедливо для прочих методов, меняющих строку лишь частично, например, String.trim() и String.strip() :

В данной связи иногда возникают разные нехорошие соблазны:

По-хорошему это нужно переписать с использованием всяких StringUtils , которые познаково перебирают строку и проверяют регистр (соответствующая проверка есть в "Сонаре"). Но зачем тащить лишнюю зависимость/импорт в проект/класс, если мы уже знаем, что name.toUpperCase() вернёт name , когда вся строка в верхнем регистре? Вместо этого мы можем написать

Однако, может получится так, что в следующей реализации String.toUpperCase() будет всегда возвращать новую строку и наш код поломается. Также этот код будет работать медленнее (иногда сильно, иногда не очень) чем o.a.c.l.StringUtils.isAllUpperCase() .

В общем же случае

Возможно, что уже скоро "Идея" научится предупреждать нас об этом, а пока это делает "Сонар".

Ещё про String.toLowerCase()

Вообще String.toLowerCase() / String.toUpperCase() довольно интересный метод, а его поведение может быть весьма неожиданным. Возьмём этот код:

он несколько искусственный, но имеет право на жизнь. Присмотревшись к нему становится понятно, что преобразование регистра избыточно для определения пустой/непустой строки. Если строка пуста, то мы получим её же на выходе и isEmpty() вернёт true . В противном случае вернётся false , т. к. для этого достаточно 1 знака в строке, а его регистр не важен.
Получается, что вместо кода выше можно написать:

и смысл выражения не изменится. Посмотрев же внутрь String.isEmpty() найдём там незамысловатую реализацию:

Держа в уме описанное ранее преобразование может возникнуть соблазн превратить

Не, ну а чё? Была у нас строка

Длина вроде не изменилась, а значит преобразование хорошее, годное. Но это только на первый взгляд. На второй — не очень. Дело в том, что методы toLowerCase() / toUpperCase() можно вызывать как с явным указанием локали, так и без оной. Во втором случае берётся локаль по умолчанию, с некоторыми из которых возможны нюансы. Например, вот этот тест проходит:

Когда запускаешь его впервые, то встаёт вопрос: "Это вообще как?" Была строка из 1 заглавной буквы, потом мы из неё сделали строчную букву и её размер утроился (в байтах — вырос вообще в 6 (!) раз). Но и это прописано в документации:

И реализовано в коде:

Так что утверждение о том, что длина строки зависит от регистра знаков не столь бредовое, каким кажется :)

Подстроки

В некоторых случаях взятие подстроки размером 1 — String.substring(n, n+1) — является бессмысленным, например, при сравнении с литералом, длина которого также равна 1. Иными словами код:

можно упростить до

Второй вариант не только короче и проще для понимания, но ещё и позволяет обойтись без создания лишнего объекта. Это же упрощение справедливо для склеивания:

можно превратить в

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

Ещё один интересный случай — это выделение подстроки фиксированной длины и сравнение её с постоянной:

Это выражение можно превратить в

тем самым упростив и сделав его более памятесберегающим. Этот шаблон уже распознаётся, в более сложных случаях нужно поработать руками (и головой):

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

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

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

Может показаться, что раз существует перегруженный метод String.indexOf(int ch, int fromIndex) , то можно превратить код выше в такой:

избавившись от выделения подстроки. На деле такое преобразование верно только тогда, когда '/' точно найден в строке и от индекса мы отняли 2, т. к. отсчёт теперь ведётся не с начала строки:

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

Закончим раздел небольшим улучшением в JDK. Дело в том, что

возвращает всегда пустую строку при условии, что n не выходит за границы допустимого:

При равных значениях beginIndex и endIndex переменная subLen будет равна 0, а метод StringLatin1.newString() вернёт пустую строку. Получается, что код можно переписать вот так:

Это позволит не выделять доппамять и одновременно упростить методы StringLatin1.stripLeading() / stripTrailing() и их двойников в StringUTF16 . Все изменения по ссылке.

С последними методами есть нюанс, а именно изменение поведения для пустого массива:

При value.length == 0 этот код вернёт пустую строку. Так как проверка left == value.length переезжает в newString , то теперь для описанного случая изменённый код

будет возвращать null ! Проследив исполнение до String.stripLeading() вроде как можно выдохнуть, ведь в этом случае вернётся this , что в нашем случае пустая строка. Повезло, пользователь не заметит разницы. Но пришла беда откуда не ждали:

Чёрт, неужели всё пропало?

From a compatibility point of view I think this should be fine, as
the identity of the returned empty string isn't specified.

Хорошо курочить стандартную библиотеку!

Проверяем, есть ли толк от изменений:

Что даёт следующие цифры:

Конечно, String.substring(n, n) будет выполнятся нечасто, но прирост есть и для такого копеечного изменения он неплох.

Когда нужно помнить про основное правило

Несмотря на то, что заметку я начал с развенчания мифа о строках, о цене их преобразования нужно помнить, особенно в циклах и особенно тогда, когда раз за разом воспроизводится одна и та же строка. Например, это код раньше жил в спринговом AnnotationMetadataReadingVisitor-е:

Выражение "class '" + getClassName() + "'" будет одним и тем же и нам совсем не хочется в двойном цикле создавать одну и ту же строку, поэтому её лучше создать 1 раз за пределами цикла. Раньше отлов таких примеров был делом случая: этот я нашел удачно провалившись внутрь исходников во время отладки своего приложения. Теперь благодаря IDEA-230889 это можно автоматизировать. Разумеется, далеко не всегда создание новой строки в цикле независимо от прохода, но даже в этих случаях можно выделить те, в которых есть некая выносимая постоянная часть:

Тут префикс beanName + GENERATED_BEAN_NAME_SEPARATOR всегда один и тот же, поэтому может быть вынесен наружу.

Создание строк. Разница между оператором присваивания (=) и new.

Теперь рассмотрим подробнее создание строк в Java. Как я говорил в предыдущей статье есть два способа создания строки (объекта класса String):

при помощи оператора присваивания (=)
при помощи оператора new

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

Для строк созданных при помощи оператора присваивания и строкового литерала в Java существует специальный механизм хранения в отдельной области памяти называемой общий строковый пул (string common pool). Если существует два или более одинаковых строковых литерала, то для них в этой области выделяется место только для одного (так как нет смысла хранить несколько одинаковых строк), но ссылки на этот объект могут быть присвоены любому количеству строковых переменных. Это позволяет уменьшить использование памяти виртуальной машины и в какой-то степени оптимизировать работу с часто используемыми строками (как вы помните строки в объектах класса String неизменяемые).

Когда же строка создается при помощи оператора new, то для каждой строки, даже если они одинаковые, выделяется своя область памяти в куче (heap), так как оператор new создает новый объект и выделяет место для него в памяти виртуальной машины.

Для того чтобы разобраться с этим получше рассмотрим простую программу:

Данная программа генерирует следующий вывод:

Статический метод iHash это просто обертка для System.identityHashCode. Я его создал только для того, чтобы код стал более наглядным. Этот метод возвращает хэш объекта, который не следует путать с хэшем строки хранящейся в объекте, возвращает который метод hashCode.

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

А вот s4 и s5 хотя и создают строку с одинаковым содержанием, но ссылаются на разные объекты в памяти, то есть оператор new породил два новых объекта в памяти.

s6 создан присвоением ссылки и поэтому указывает на тот же объект что и s5, то есть новый объект не был создан.

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

Важно понять, что оператор new порождает новые объекты в памяти в любом случае, есть там такая же строка или нет, в то время как оператор присваивания создает новый объект в string common pool, только в том случае если там нет такой же строки.

Далее присваиванием s3 = "world" ; мы создаем новый обект в string pool, что собственно видно по выводу программы.

Вызов метода intern() для s4 организует поиск соответствующего значению объекта литерала и при положительном результате возвращает ссылку на найденный литерал, а при отрицательном – заносит значение (строку) в пул и возвращает ссылку на него.

Ну и в конце у нас небольшой тест производительности создания большой строки расположенной в string pool и heap. Как видно string pool работает помедленней чем heap. Но вообще так, в цикле, делать конкатенацию строк категорически не рекомендуется, так как это порождает множество объектов в памяти, что очень не очень. Данный пример был приведен просто чтобы сравнить производительность.

Создание строк при помощи оператора new.

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

String() — создается объект с пустой строкой;
String(String str) — конструктор копирования: из одного объекта создается его точная копия, поэтому данный конструктор используется редко;
String(StringBuffer str) — преобразованная копия объекта класса StringBuffer;
String(StringBuilder str) — преобразованная копия объекта класса StringBuilder;
String(byte[] byteArray) — объект создается из массива байтов byteArray;
String(char[] charArray) — объект создается из массива charArray символов Unicode;
String(byte[] byteArray, int offset, int count) — объект создается из части массива байтов byteArray, начинающейся с индекса offset и содержащей count байтов;
String(char[] charArray, int offset, int count) — то же, но массив состоит из символов Unicode;
String(int[] intArray, int offset, int count) — то же, но массив состоит из символов Unicode, записанных в массив целого типа, что позволяет использовать символы Unicode, занимающие больше двух байтов;
String(byte[] byteArray, String encoding) — символы, записанные в массиве байтов, задаются в Unicode-строке с учетом кодировки encoding;
String(byte[] byteArray, int offset, int count, String encoding) — то же самое, но только для части массива;
String(byte[] byteArray, Charset charset) — символы, записанные в массиве байтов, задаются в Unicode-строке с учетом кодировки, заданной объектом charset;
String(byte[] byteArray, int offset, int count, Charset charset) — то же самое, но только для части массива.

При неправильном задании индексов offset, count или кодировки encoding возникает исключительная ситуация .

Конструкторы, использующие массив байтов byteArray, предназначены для создания Unicode-строки из массива байтовых ASCII-кодировок символов. Такая ситуация возникает при чтении ASCII-файлов, извлечении информации из базы данных или при передаче информации по сети.

В самом простом случае компилятор для получения двухбайтовых символов Unicode добавит к каждому байту старший нулевой байт . Получится диапазон ‘ \u0000’ — ‘ \u00FF’ кодировки Unicode, соответствующий кодам Latin1. Тексты, записанные кириллицей, будут выведены неправильно.

Если исходный массив с кириллическим ASCII-текстом был в кодировке CP1251, то строка Java будет создана правильно. Кириллица попадет в свой диапазон ‘ \u0400’ — ‘ \u04FF’ кодировки Unicode.

Но у кириллицы есть еще по меньшей мере четыре кодировки:

В этих случаях применяются последние четыре конструктора, в которых параметром encoding или charset указывается, какую кодовую таблицу использовать конструктору при создании строки.

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

Тип данных может содержать последовательность (строку) символов. После создания строки вы можете искать внутри нее, создавать из нее подстроки, новые строки на основе первой, но с заменой некоторых частей, а также многое другое.

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

Строка 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.

Строковые литералы

Есть более короткий способ создания новой строки:

Escape-символы

Литералы Java Strings принимают набор из которых переводятся в специальные символы в созданной строке. Пример создания с использованием escape-символов:

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

Константы

В этом случае виртуальная машина заставит 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.

Первый символ в строке имеет индекс 0, второй символ имеет индекс 1 и т. д. Последний символ в строке имеет индекс String.length() – 1.

Поиск с помощью indexOf()

Вы можете искать подстроки в Strings, используя метод indexOf():

Индексная переменная будет содержать значение 6 после выполнения этого кода. Метод indexOf() возвращает индекс, в котором находится первый символ в первой соответствующей подстроке. В этом случае W совпадающей подстроки World была найдена по индексу 6. Если подстрока не найдена в строке, метод возвращает -1.

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

Класс 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 с определенной подстроки:

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

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() возвращает байтовое представление строки, используя кодировку набора символов по умолчанию на машине. Набор символов по умолчанию зависит от компьютера, на котором выполняется код. Поэтому обычно лучше явно указать набор символов, который будет использоваться для создания представления байтов (как в следующей строке).

Преобразование в верхний и нижний регистр

Вы можете конвертировать строки в верхний и нижний регистр, используя методы toUpperCase() и toLowerCase():

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