Класс StringBuffer

public StringBuffer()

Создаёт буфер строк без символов и начальной ёмкостью в 16 символов.

public StringBuffer(int capacity)

Создаёт буфер строк без символов и заданной начальной ёмкостью.

public StringBuffer(String str)

Создаёт буфер строк, инициализированный содержимым указанной строки. Начальная ёмкость буфера строк равна 16 плюс длина аргумента строки.

public StringBuffer(CharSequence seq)

Создаёт буфер строк, содержащий те же символы, что и указанный CharSequence. Начальная ёмкость буфера строк равна 16 плюс длина аргумента CharSequence.

public int compareTo(StringBuffer another)

Сравнивает два экземпляра StringBuffer лексикографически. Этот метод следует тем же правилам лексикографического сравнения, что и в методе CharSequence.compare(this, another).

Для более тонкого, чувствительного к региону сравнения строк обратитесь к Collator.

public int length()

Возвращает длину (количество символов).

public int capacity()

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

public void ensureCapacity(int minimumCapacity)

Обеспечивает, чтобы ёмкость была по крайней мере равна заданному минимуму. Если текущая ёмкость меньше аргумента, то новый внутренний массив выделяется с большей ёмкостью. Новая ёмкость — это большее из:

• Аргумент minimumCapacity.
• Удвоенной старой ёмкости плюс 2.

Если аргумент minimumCapacity не положителен, этот метод не выполняет никаких действий и просто возвращается. Обратите внимание, что последующие операции с этим объектом могут уменьшить фактическую ёмкость ниже запрошенной здесь.

public void trimToSize()

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

public void setLength(int newLength)

Устанавливает длину последовательности символов. Последовательность изменяется на новую последовательность символов, длина которой задаётся аргументом. Для каждого неотрицательного индекса k, меньшего newLength, символ с индексом k в новой последовательности символов такой же, как символ с индексом k в старой последовательности, если k меньше длины старой последовательности символов; в противном случае это нулевой символ '\u0000'. Другими словами, если аргумент newLength меньше текущей длины, длина изменяется на указанную длину.

Если аргумент newLength больше или равен текущей длине, добавляется достаточно нулевых символов ('\u0000'), чтобы длина стала равной аргументу newLength.

Аргумент newLength должен быть больше или равен 0.

public char charAt(int index)

Возвращает значение char в этой последовательности по указанному индексу. Первый char расположен по индексу 0, следующий — по индексу 1 и так далее, как и при индексировании массивов.

Аргумент индекса должен быть больше или равен 0 и меньше длины этой последовательности.

Если значение char, указанное индексом, является суррогатом, возвращается значение суррогата.

public int codePointAt(int index)

Возвращает символ (код точки Юникода) по указанному индексу. Индекс относится к значениям char (единицам Юникода) и изменяется от 0 до CharSequence.length() - 1.

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

public int codePointBefore(int index)

Возвращает символ (код точки Юникода) перед указанным индексом. Индекс относится к значениям char (единицам Юникода) и изменяется от 1 до CharSequence.length().

Если значение char по (index - 1) находится в диапазоне низких суррогатов, (index - 2) не отрицательно, и значение char по (index - 2) находится в диапазоне высоких суррогатов, возвращается значение дополнительной кодовой точки пары суррогатов. Если значение char по index - 1 является непарным низким суррогатом или высоким суррогатом, возвращается значение суррогата.

public int codePointCount(int beginIndex, int endIndex)

Возвращает количество точек кода Юникода в заданном текстовом диапазоне этой последовательности. Текстовый диапазон начинается по указанному beginIndex и продолжается до char по индексу endIndex - 1. Таким образом, длина (в char) текстового диапазона равна endIndex-beginIndex. Непарные суррогаты в этой последовательности считаются по одной кодовой точке каждый.

public int offsetByCodePoints(int index, int codePointOffset)

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

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Символы копируются из этой последовательности в массив символов назначения dst. Первый копируемый символ находится по индексу srcBegin; последний копируемый символ находится по индексу srcEnd-1. Общее количество копируемых символов равно srcEnd-srcBegin. Символы копируются в подмассив dst, начиная с индекса dstBegin и заканчивая индексом:

 dstbegin + (srcEnd-srcBegin) - 1
 

public void setCharAt(int index, char ch)

Символ по указанному индексу устанавливается в значение ch. Эта последовательность изменяется, чтобы представить новую последовательность символов, идентичную старой последовательности, за исключением того, что она содержит символ ch в позиции index.

Аргумент индекса должен быть больше или равен 0 и меньше длины этой последовательности.

public StringBuffer append(Object obj)

Добавляет строковое представление аргумента Object.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(Object), а символы этой строки затем были добавлены appended к этой последовательности символов.

public StringBuffer append(String str)

Добавляет указанную строку к этой последовательности символов.

Символы аргумента String добавляются в порядке возрастания, увеличивая длину этой последовательности на длину аргумента. Если str равно null, то добавляются четыре символа "null".

Пусть n — длина этой последовательности символов непосредственно перед выполнением метода append. Тогда символ с индексом k в новой последовательности символов равен символу с индексом k в старой последовательности символов, если k меньше n; в противном случае он равен символу с индексом k-n в аргументе str.

public StringBuffer append(StringBuffer sb)

Добавляет указанный StringBuffer к этой последовательности.

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

Пусть n — длина старой последовательности символов, содержащейся в StringBuffer непосредственно перед выполнением метода append. Тогда символ с индексом k в новой последовательности символов равен символу с индексом k в старой последовательности символов, если k меньше n; в противном случае он равен символу с индексом k-n в аргументе sb.

Этот метод выполняет синхронизацию по this, объекту назначения, но не выполняет синхронизацию по источнику (sb).

public StringBuffer append(CharSequence s)

Добавляет указанный CharSequence к этой последовательности.

Символы аргумента CharSequence добавляются в порядке возрастания, увеличивая длину этой последовательности на длину аргумента.

Результат этого метода точно такой же, как если бы это было вызов этого.append(s, 0, s.length());

Этот метод выполняет синхронизацию по this, объекту назначения, но не выполняет синхронизацию по источнику (s).

Если s равно null, то добавляются четыре символа "null".

public StringBuffer append(CharSequence s, int start, int end)

Добавляет подпоследовательность указанного CharSequence к этой последовательности.

Символы аргумента s, начиная с индекса start, добавляются в порядке возрастания к содержимому этой последовательности до (исключительно) индекса end. Длина этой последовательности увеличивается на значение end - start.

Пусть n — длина этой последовательности символов непосредственно перед выполнением метода append. Тогда символ с индексом k в этой последовательности символов становится равным символу с индексом k в этой последовательности, если k меньше n; в противном случае он равен символу с индексом k+start-n в аргументе s.

Если s равно null, то этот метод добавляет символы так, как если бы параметр s был последовательностью, содержащей четыре символа "null".

public StringBuffer append(char[] str)

Добавляет строковое представление аргумента-массива char к этой последовательности.

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

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(char[]), а символы этой строки затем были добавлены appended к этой последовательности символов.

public StringBuffer append(char[] str, int offset, int len)

Добавляет строковое представление подмассива аргумента char массива в эту последовательность.

Символы из массива char str, начиная с индекса offset, добавляются в порядке следования к содержимому этой последовательности. Длина этой последовательности увеличивается на значение len.

Общий эффект точно такой же, как если бы аргументы были преобразованы в строку методом String.valueOf(char[],int,int), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer append(boolean b)

Добавляет строковое представление аргумента boolean в последовательность.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(boolean), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer append(char c)

Добавляет строковое представление аргумента char в эту последовательность.

Аргумент добавляется в содержимое этой последовательности. Длина этой последовательности увеличивается на 1.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(char), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer append(int i)

Добавляет строковое представление аргумента int в эту последовательность.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(int), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer appendCodePoint(int codePoint)

Добавляет строковое представление аргумента codePoint в эту последовательность.

Аргумент добавляется в содержимое этой последовательности. Длина этой последовательности увеличивается на Character.charCount(codePoint).

Общий эффект точно такой же, как если бы аргумент был преобразован в массив символов методом Character.toChars(int), а затем символы в этом массиве были appended в эту последовательность символов.

public StringBuffer append(long lng)

Добавляет строковое представление аргумента long в эту последовательность.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(long), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer append(float f)

Добавляет строковое представление аргумента float в эту последовательность.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(float), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer append(double d)

Добавляет строковое представление аргумента double в эту последовательность.

Общий эффект точно такой же, как если бы аргумент был преобразован в строку методом String.valueOf(double), а затем символы этой строки были appended в эту последовательность символов.

public StringBuffer delete(int start, int end)

Удаляет символы в подстроке этой последовательности. Подстрока начинается с указанного start и заканчивается символом с индексом end - 1 или концом последовательности, если такого символа не существует. Если start равно end, никаких изменений не производится.

public StringBuffer deleteCharAt(int index)

Удаляет char по указанной позиции в этой последовательности. Длина этой последовательности уменьшается на один char.

Примечание: если символ по данному индексу является дополнительным символом, этот метод не удаляет весь символ. Если требуется правильная обработка дополнительных символов, определите количество char для удаления, вызвав Character.charCount(thisSequence.codePointAt(index)), где thisSequence - эта последовательность.

public StringBuffer replace(int start, int end, String str)

Заменяет символы в подстроке этой последовательности символами в указанной String. Подстрока начинается с указанного start и заканчивается символом с индексом end - 1 или концом последовательности, если такого символа не существует. Сначала символы в подстроке удаляются, а затем указанная String вставляется по позиции start. (Если необходимо, длина этой последовательности увеличивается для размещения указанной строки.)

public String substring(int start)

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

public CharSequence subSequence(int start, int end)

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

Вызов этого метода в формате

 sb.subSequence(begin, end)

ведет себя точно так же, как вызов

 sb.substring(begin, end)

Этот метод предоставляется для реализации этого класса интерфейса CharSequence.

public String substring(int start, int end)

Возвращает новую String, содержащую подпоследовательность символов, в настоящее время содержащихся в этой последовательности. Подстрока начинается со специфицированного start и продолжается до символа с индексом end - 1.

public StringBuffer insert(int index, char[] str, int offset, int len)

Вставляет строковое представление подмассива аргумента массива str в эту последовательность. Подмассив начинается со специфицированного offset и продолжается до len char. Символы подмассива вставляются в эту последовательность в позиции, указанной index. Длина этой последовательности увеличивается на len char.

public StringBuffer insert(int offset, Object obj)

Вставляет строковое представление аргумента Object в эту последовательность символов.

Общий эффект точно такой же, как если бы второй аргумент был преобразован в строку методом String.valueOf(Object), а символы этой строки были затем inserted в эту последовательность символов в указанном смещении.

Аргумент offset должен быть больше или равен 0 и меньше или равен длине длины этой последовательности.

public StringBuffer insert(int offset, String str)

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

Символы аргумента String вставляются в порядке в эту последовательность в указанном смещении, передвигая любые символы, первоначально расположенные выше этой позиции, и увеличивая длину этой последовательности на длину аргумента. Если str равно null, тогда четыре символа "null" вставляются в эту последовательность.

Символ с индексом k в новой последовательности символов равен:

• символу с индексом k в старой последовательности символов, если k меньше offset
• символу с индексом k-offset в аргументе str, если k не меньше offset, но меньше offset+str.length()
• символу с индексом k-str.length() в старой последовательности символов, если k не меньше offset+str.length()

Аргумент offset должен быть больше или равен 0, и меньше или равен длине длины этой последовательности.

public StringBuffer insert(int offset, char[] str)

Вставляет строковое представление аргумента массива char в эту последовательность.

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

Общий эффект точно такой же, как если бы второй аргумент был преобразован в строку методом String.valueOf(char[]), а символы этой строки были затем inserted в эту последовательность символов в указанном смещении.

Аргумент offset должен быть больше или равен 0, и меньше или равен длине длины этой последовательности.

public StringBuffer insert(int dstOffset, CharSequence s)

Вставляет указанную CharSequence в эту последовательность.

Символы аргумента CharSequence вставляются в порядке в эту последовательность в указанном смещении, передвигая любые символы, первоначально расположенные выше этой позиции, и увеличивая длину этой последовательности на длину аргумента s.

Результат этого метода точно такой же, как если бы это была вызов метода insert(dstOffset, s, 0, s.length()) этого объекта.

Если s равно null, тогда четыре символа "null" вставляются в эту последовательность.

public StringBuffer insert(int dstOffset, CharSequence s, int start, int end)

Вставляет подпоследовательность указанной CharSequence в эту последовательность.

Подпоследовательность аргумента s, заданная start и end, вставляется в порядке в эту последовательность в указанном смещении назначения, передвигая любые символы, первоначально расположенные выше этой позиции. Длина этой последовательности увеличивается на end - start.

Символ с индексом k в этой последовательности становится равным:

• символу с индексом k в этой последовательности, если k меньше dstOffset
• символу с индексом k+start-dstOffset в аргументе s, если k больше или равно dstOffset, но меньше dstOffset+end-start
• символу с индексом k-(end-start) в этой последовательности, если k больше или равно dstOffset+end-start

Аргумент dstOffset должен быть больше или равен 0, и меньше или равен длине длины этой последовательности.

Аргумент start должен быть неотрицательным и не больше end.

Аргумент end должен быть больше или равен start, и меньше или равен длине s.

Если s равно null, этот метод вставляет символы так, как будто параметр s был последовательностью, содержащей четыре символа "null".

public StringBuffer insert(int offset, boolean b)

Вставляет строковое представление аргумента boolean в эту последовательность.

Общий эффект точно такой же, как если бы второй аргумент был преобразован в строку методом String.valueOf(boolean), а символы этой строки были затем inserted в эту последовательность символов в указанном смещении.

Аргумент offset должен быть больше или равен 0, и меньше или равен длине длины этой последовательности.

public StringBuffer insert(int offset, char c)

Вставляет строковое представление аргумента char в эту последовательность.

Общий эффект эквивалентен тому, как бы второй аргумент был преобразован в строку методом String.valueOf(char), а затем символы этой строки были inserted в эту последовательность символов по указанному смещению.

Аргумент offset должен быть больше или равен 0 и меньше или равен длине этой последовательности.

public StringBuffer insert(int offset, int i)

Вставляет строковое представление второго аргумента int в эту последовательность.

Общий эффект эквивалентен тому, как бы второй аргумент был преобразован в строку методом String.valueOf(int), а затем символы этой строки были inserted в эту последовательность символов по указанному смещению.

Аргумент offset должен быть больше или равен 0 и меньше или равен длине этой последовательности.

public StringBuffer insert(int offset, long l)

Вставляет строковое представление аргумента long в эту последовательность.

Общий эффект эквивалентен тому, как бы второй аргумент был преобразован в строку методом String.valueOf(long), а затем символы этой строки были inserted в эту последовательность символов по указанному смещению.

Аргумент offset должен быть больше или равен 0 и меньше или равен длине этой последовательности.

public StringBuffer insert(int offset, float f)

Вставляет строковое представление аргумента float в эту последовательность.

Общий эффект эквивалентен тому, как бы второй аргумент был преобразован в строку методом String.valueOf(float), а затем символы этой строки были inserted в эту последовательность символов по указанному смещению.

Аргумент offset должен быть больше или равен 0 и меньше или равен длине этой последовательности.

public StringBuffer insert(int offset, double d)

Вставляет строковое представление аргумента double в эту последовательность.

Общий эффект эквивалентен тому, как бы второй аргумент был преобразован в строку методом String.valueOf(double), а затем символы этой строки были inserted в эту последовательность символов по указанному смещению.

Аргумент offset должен быть больше или равен 0 и меньше или равен длине этой последовательности.

public int indexOf(String str)

Возвращает индекс первого вхождения указанной подстроки в этой строке.

Возвращаемый индекс - наименьшее значение k, для которого:

 this.toString().startsWith(str, k)
 

Если такого значения k нет, то возвращается -1.

public int indexOf(String str, int fromIndex)

Возвращает индекс первого вхождения указанной подстроки в этой строке, начиная с указанного индекса.

Возвращаемый индекс - наименьшее значение k, для которого:

     k >= Math.min(fromIndex, this.length()) &&
                   this.toString().startsWith(str, k)
 

Если такого значения k нет, то возвращается -1.

public int lastIndexOf(String str)

Возвращает индекс последнего вхождения указанной подстроки в этой строке. Последнее вхождение пустой строки "" считается имеющим индекс this.length().

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

 this.toString().startsWith(str, k)
 

Если такого значения k нет, то возвращается -1.

public int lastIndexOf(String str, int fromIndex)

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

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

     k <= Math.min(fromIndex, this.length()) &&
                   this.toString().startsWith(str, k)
 

Если такого значения k нет, то возвращается -1.

public StringBuffer reverse()

Заменяет эту последовательность символов на обратную последовательность. Если в последовательности есть пары суррогатных символов, они обрабатываются как отдельные символы для операции обращения. Таким образом, порядок высоко- и низкоуровневых суррогатов никогда не меняется. Пусть n — длина последовательности символов (не длина в char значениях) непосредственно перед выполнением метода reverse. Тогда символ с индексом k в новой последовательности символов равен символу с индексом n-k-1 в старой последовательности символов.

Обратите внимание, что операция обращения может привести к созданию пар суррогатов, которые были неспаренными низкоуровневыми и высокоуровневыми суррогатами до операции. Например, обращение "\uDC00\uD800" дает "\uD800\uDC00", что является допустимой парой суррогатов.

public String toString()

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

public IntStream chars()

Возвращает поток int, расширяющий char значения из этой последовательности. Любой символ, который отображается в коде точки кодирования суррогата, передаётся без интерпретации.

Поток связывается с этой последовательностью в момент начала терминальной операции потока (точнее, для изменяемых последовательностей итератор потока является позднесвязываемым). Если последовательность изменяется во время этой операции, результат неопределён.

public IntStream codePoints()

Возвращает поток значений кодовых точек из этой последовательности. Любые пары суррогатов, встреченные в последовательности, объединяются так, как если бы это было выполнено Character.toCodePoint, а результат передается в поток. Любые другие код-единицы, включая обычные символы BMP, непарные суррогаты и неопределённые код-единицы, дополняются нулями до int значений, которые затем передаются в поток.

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