Язык программирования (стр. 10 )

Решить, какая ситуация является предсказуемой, а какая — нет, порой бывает нелегко. Главное — не злоупотреблять исключениями для сообщений о предсказуемых ситуациях.

Упражнение 7.2

Как, по вашему мнению, программа должна сообщать программисту о следующих ситуациях:

Программа пытается присвоить отрицательное значение вместимости машины в объекте PassengerVehicle. В файле конфигурации, используемом для задания начального состояния объекта, обнаружена синтаксическая ошибка. Метод, который ищет в строковом массиве указанное программистом слово, не может найти ни одного экземпляра такого слова. Файл, передаваемый методу open, не существует. Файл, передаваемый методу open, существует, но система безопасности не разрешает пользователю работать с ним. При попытке установить сетевое соединение с удаленным процессом-сервером не удается связаться с удаленным компьютером. Во время взаимодействия с удаленным процессом-сервером прерывается сетевое соединение.

Глава 8
СТРОКИ

Что толку в хорошей цитате, если ее нельзя изменить?
Доктор Who, The Two Doctors

Строки в Java являются стандартными объектами со встроенной языковой поддержкой. Нам уже встречалось множество примеров того, как строковые объекты создаются на основе литералов; кроме того, мы видели, как операторы + и += применяются для конкатенации и создания новых строк. Тем не менее функции класса String этим не ограничиваются. Объекты String доступны только для чтения, поэтому в Java также имеется класс StringBuffer для изменяемых строк. В этой главе описаны классы String и StringBuffer, а также преобразование строк в другие типы — например, целый или логический.

8.1. Основные операции со строками

Класс String позволяет работать со строками, доступными только для чтения, и поддерживает операции с ними. Строки могут создаваться неявным образом при помощи заключенной в кавычки последовательности символов (например, “GrцЯe”) или за счет выполнения оператора + или += над двумя объектами String.

Кроме того, допускается и явное построение объектов String оператором new. В классе String предусмотрены следующие конструкторы:

public String()

Конструирует новый объект String, значение которого равно “”.

public String(String value)

Конструирует новый объект String, являющийся копией заданного.

При работе с объектами String используются два базовых метода — length и charAt. Метод length возвращает количество символов в строке, а метод charAt — символ в заданной позиции. Приведенный ниже цикл подсчитывает количество вхождений каждого из символов в строку:

for (int i = 0; i << str. length(); i++)

counts[str. charAt(i)]++;

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

Кроме того, имеются простые методы для поиска в строке первого или последнего вхождения конкретного символа или подстроки. Следующий метод возвращает количество символов между первым и последним вхождением заданного символа в строке:

static int countBetween(String str, char ch) {

int begPos = str. indexOf(ch);

if (begPos << 0) // не входит

return -1;

int endPos = str. lastIndexOf(ch);

return endPos - begPos - 1;

}

Данный метод находит первую и последнюю позицию символа ch в строке str. Если символ входит в строку менее двух раз, метод возвращает –1. Разность между номерами позиций превышает на единицу количество символов между ними (количество символов между позициями 2 и 3 равно 0).

Существует несколько перегруженных вариантов метода indexOf для поиска в прямом направлении и метода lastIndexOf — для поиска в обратном направлении. Каждый из методов возвращает номер найденной позиции или –1, если поиск оказался безуспешным:

Метод	Возвращаемое значение
indexOf(char ch)	первая позиция ch
indexOf(char ch, int start)	первая позиция ch  start
indexOf(String str)	первая позиция str
indexOf(String str, int start)	первая позиция str  start
lastIndexOf(char ch)	последняя позиция ch
lastIndexOf(char ch, int start)	последняя позиция ch start
lastIndexOf(String str)	последняя позиция str
lastIndexOf(String str, int start)	последняя позиция str start

Упражнение 8.1

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

Упражнение 8.2

Напишите метод, который подсчитывает количество вхождений некоторой подстроки в данную строку.

8.2. Сравнение строк

В классе String имеется несколько методов для сравнения строк и их отдельных частей. Тем не менее, перед тем как переходить к конкретным методам, необходимо остановиться на некоторых аспектах, касающихся интернациональных и локализованных строк Unicode, которые не учитываются этими методами. Например, при сравнении двух строк и попытке определить, какая из них “больше”, происходит числовое сравнение символов в соответствии с их значениями в кодировке Unicode, а не их порядком в локализованном представлении. Для француза символы c и з — это одинаковые буквы, отличающиеся между собой лишь маленьким диакритическим значком. Упорядочивая набор строк, француз проигнорирует отличия между ними и поставит “aзa” перед “acz”. Однако с Unicode дело обстоит иначе — в наборе символов Unicode c (\u0063) идет перед з (\u00e7), так что при сортировке эти строки окажутся расположенными в обратном порядке.

Первая операция сравнения, equals, возвращает true, если ей передается ссылка на объект String с тем же содержимым, что и у текущего объекта, — то есть если строки имеют одинаковую длину и состоят в точности из одинаковых символов Unicode. Если другой объект не относится к типу String или же имеет другое содержимое, то String. equals возвращает false.

Чтобы сравнивать строки без учета регистра, используйте метод equals IgnoreCase. Под выражением “без учета регистра” мы имеем в виду, что символы Л и л считаются одинаковыми, но отличающимися от E и e. Символы, для которых понятие регистра не определено (например, знаки пунктуации) считаются равными только себе самим. В Unicode имеется много интересных аспектов, связанных с регистром символов, в том числе и понятие “заглавного регистра” (title case). Работа с регистром в классе String описывается в терминах регистровых методов класса Character в разделе 13.5.

Для проведения сортировки строк нужно иметь возможность сравнивать их между собой. Метод compareTo возвращает значение int, которое меньше, равно либо больше нуля, если строка, для которой он был вызван, соответственно меньше, равна или больше другой строки. При сравнении строк используется кодировка символов в Unicode.

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

private String[] table;

public int position(String key) {

int lo = 0;

int hi = table. length - 1;

while (lo <<= hi) {

int mid = lo + (hi - lo) / 2;

int cmp = pareTo(table[mid]);

if (cmp == 0) // нашли!

return mid;

else if (cmp << 0) // искать в нижней половине

hi = mid - 1;

else // искать в верхней половине

lo = mid + 1;

}

return -1; //

}

Так выглядит базовый алгоритм бинарного поиска. Сначала он проверяет среднюю точку исследуемого диапазона и сравнивает значение ключа поиска с элементом в данной позиции. Если значения совпадают, то нужный элемент найден, а поиск закончен. Если значение ключа меньше элемента в проверяемой позиции, то дальше поиск будет вестись в нижней половине диапазона; в противном случае элемент необходимо искать в верхней половине диапазона. В результате работы алгоритма либо будет найден нужный элемент, либо нижняя граница диапазона превысит верхнюю — это означает, что ключ отсутствует в списке.

Сравнивать можно не только целые строки, но и их отдельные части. Для этого применяется метод regionMatches в двух формах: в одной происходит точное сравнение символов, как в методе equals, а в другой — сравнение без учета регистра, как в методе equalsIgnoreCase:

public boolean regionMatches(int start, String other, int ostart, int len)

Возвращает true, если указанная подстрока данного объекта String совпадает с указанной подстрокой строки other. Проверка начинается с позиции start в данной строке, и с позиции ostart - в строке other. Сравниваются только первые len символов.

public boolean regionMatches(boolean ignoreCase, int start, String other, int ostart, int len)

Данная версия regionMatches ведет себя точно так же, как и предыдущая, за исключением того, что логическая переменная ignoreCase определяет, следует ли игнорировать регистр символов при сравнении.

Приведем пример:

class RegionMatch {

public static void main(String[] args) {

String str = "Look, look!";

boolean b1, b2, b3;

b1 = str. regionMatches(6, "Look," 0, 4);

b2 = str. regionMatches(true, 6, "Look," 0, 4);

b3 = str. regionMatches(true, 6, "Look," 0, 5);

System. out println("b1 = " + b1);

System. out println("b2 = " + b2);

System. out println("b3 = " + b3);

}

}

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

b1 = false

b2 = true

b3 = false

Результат первого сравнения равен false, потому что в позиции 6 главной строки находится символ ‘l’, а в позиции 0 второй строки — символ ‘L’. Второе сравнение дает true, поскольку регистр не учитывается. Наконец, результат третьего сравнения оказывается равным false, потому что длина сравниваемой подстроки равна 5, а на протяжение этих 5 символов строки отличаются даже без учета регистра.

Простая проверка на совпадение аргумента с началом или концом строки осуществляется с помощью методов startsWith и endsWith:

public boolean startsWith(String prefix, int toffset)

Возвращает true, если строка начинается с подстроки prefix (со смещением toffset).

public boolean startsWith(String prefix)

Сокращение для startsWith(prefix, 0).

public boolean endsWith(String suffix)

Возвращает true, если строка заканчивается подстрокой suffix.

Вообще говоря, строки не могут сравниваться с использованием оператора ==, как показано ниже:

if (str == “ВPeсa?”)

answer(str);

Такая запись не анализирует содержимое двух строк. Она сравнивает только ссылку на один объект (str) со ссылкой на другой объект (неявный строковый объект, представленный константой “ВPeсa?”). Даже если оба объекта-строки имеют одинаковое содержимое, ссылки на них могут различаться.

Тем не менее два любых строковых литерала с одинаковым содержимым будут указывать на один и тот же объект класса String. Например, в следующем фрагменте оператор ==, вероятно, сработает правильно:

String str = "?Pena?";

// ...

if (str == "?Pena?")

answer(str);

Из-за того, что str изначально был присвоен строковый литерал, сравнение этой переменной с другим строковым литералом равносильно проверке этих строк на одинаковое содержание. И все же необходимо соблюдать осторожность — этот трюк сработает лишь в том случае, если вы уверены в происхождении всех ссылок на строковые литералы. Если str изменится и будет указывать на производный объект String — например, на результат ввода пользователем чего-либо, — оператор == вернет значение false, даже если пользователь наберет строку ВPeсa?.

8.3. Вспомогательные методы

Класс String содержит два метода, которые оказываются полезными в специализированных приложениях. Один из них — hashCode, который возвращает хеш-код, основанный на содержимом строки. Любые две строки с одинаковым содержимым будут иметь одинаковое значение хеш-кода, хотя и две разные строки тоже могут иметь одинаковый хеш-код. Хеш-коды нужны для работы с хеш-таблицами, такими, например, как в классе Hashtable из java. util.

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

int putIn(String key) {

String uniqe = key. intern();

int i;

// проверить, имеется ли такой элемент в таблице

for ( i = 0; i << tableSize; i++)

if (table[i] == unique)

return i;

// если нет - добавить

table[i] = unique;

tableSize++;

return i;

}

Все строки, хранящиеся в массиве table, получены в результате вызова intern. Массив просматривается в поисках строки, содержимое которой совпадает с key. Если строка найдена, то поиск завершается. Если же такой строки нет, в конец массива добавляется строка, содержимое которой совпадает с содержимым key. При работе с результатами вызовов intern сравнение ссылок на объекты эквивалентно сравнению содержимого строк, однако происходит существенно быстрее.

8.4. Создание производных строк

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

public static String quotedString(

String from, char start, char end)

{

int startPos = from. indexOf(start);

int endPos = from. lastIndexOf(end);

if (startPos == -1) // начальный символ не найден

return null;

else if (endPos == -1) // конечный символ не найден

return from. substring(startPos);

else // найдены оба символа-ограничителя

return from. substring(startPos, endPos + 1);

}

Метод quotedString возвращает новый объект String, который содержит фрагмент строки from, начинающийся с символа start и заканчивающийся символом end. Если найден символ start, но не найден end, то метод возвращает новый объект String, содержащий все символы от начальной позиции до конца строки. В работе quotedString используются две перегруженные формы метода substring. Первая из них получает только начальную позицию в строке и возвращает новую строку, содержащую все символы с заданной позиции, и до конца строки. Вторая форма получает и начальную, и конечную позиции и возвращает новую строку, содержащую все символы между соответствующими позициями исходной строки; при этом начальный символ-ограничитель включается в подстроку, а конечный — нет. Именно из-за этого принципа “до конца, но не включая конец” мы и прибавляем единицу к endPos, чтобы в подстроку вошли оба символа-ограничителя. Например, вызов

quotedString(“Il a dit “Bonjour!””, ‘“’, ‘”’);

возвращает строку

“Bonjour!”

Ниже перечисляются остальные методы для создания производных строк:

public String replace(char oldChar, char newChar)

Возвращает новый объект String, в котором все вхождения символа old Char заменяются символом newChar.

public String toLowerCase()

Возвращает новый объект String, в котором каждый символ преобразуется в эквивалентный ему символ нижнего регистра (если он имеется).

public String toUpperCase()

Возвращает новый объект String, в котором каждый символ преобразуется в эквивалентный ему символ верхнего регистра (если он имеется).

public String trim()

Возвращает новый объект String, в котором удалены все пробелы в начале и конце строки.

Метод concat возвращает новую строку, которая эквивалентна применению оператора + к двум строкам. Следующие два оператора являются эквивалентными:

newStr = oldStr. concat(“ (not)”);

newStr = oldStr + “ (not)”;

Упражнение 8.3

Как показано выше, метод quotedString предполагает, что в исходной строке имеется всего один экземпляр подстроки с заданными символами - ограничителями. Напишите версию метода, которая извлекает все такие строки и возвращает массив.

8.5. Преобразование строк

Довольно часто возникает необходимость преобразовать строку в значение другого типа (скажем, целого или логического) или наоборот. Согласно конвенции, принятой в Java, тип, к которому преобразуется значение, должен содержать метод, выполняющий преобразование. Например, преобразование из типа String в Integer должно выполняться статическим методом класса Integer. Ниже приводится таблица всех конвертируемых типов, а также способы их преобразования в тип String и обратно:

Тип	В String	Из String
boolean	String. valueOf(boolean)	new Boolean(String).booleanValue()
int	String. valueOf(int)	Integer. ParseInt(String, int base)
long	String. valueOf(long)	Long. ParseLong(String, int base)
float	String. valueOf(float)	new Float(String).floatValue()
double	String. valueOf(double)	new Double(String).doubleValue()

Для логических значений, а также для значений с плавающей точкой сначала создается объект Float или Double, после чего определяется его численное значение. Для значений с плавающей точкой не существует эквивалента метода parseInt, который напрямую выделяет значение из строки.

Не существует методов, которые переводили бы символы из форм, распознаваемых языком Java (\b, \udddd и т. д.) в переменные типа char или наоборот. Вы можете вызвать метод String. valueOf для отдельного символа, чтобы получить строку, состоящую из одного данного символа.

Также не существует возможности создать или преобразовать числовые строки в формат языка Java, в котором начальный 0 означает восьмеричную запись, а 0x — шестнадцатеричную.

Преобразования в byte и short, а также обратные им производятся через тип int, поскольку соответствующие значения всегда лежат в диапазоне int; к тому же при использовании этих типов в вычисляемых выражениях они все равно преобразуются в int.

Новые классы также могут поддерживать строковые преобразования; для этого в них следует включить метод toString и конструктор, который создает новый объект по строковому описанию. Классы, включающие метод toString, могут использоваться в valueOf. В соответствии с определением метода valueOf(Object obj), он возвращает либо строку “null”, либо obj. to String. Если все классы в вашей программе содержат метод toString, то вы сможете преобразовать любой объект в тип String вызовом valueOf.

8.6. Строки и символьные массивы

Содержимое строки может отображаться на символьный массив и наоборот. Часто в программе бывает необходимо предварительно построить строку в массиве char, после чего создать объект String по содержимому этого массива. Если описанный ниже класс StringBuffer (допускающий запись в строки) в каком-то конкретном случае не подходит, существует несколько методов и конструкторов класса String, помогающих преобразовать строку в массив char или же массив char — в строку.

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

public static String squeezeOut(String from, char toss) {

char[] chars = from. toCharArray();

int len = chars. length;

for (int i = 0; i << len; i++) {

if (chars[i] == toss) {

--len;

System. arraycopy(chars, i + 1,

chars, i, len - i);

--i; // рассмотреть повторно

}

}

return new String (chars, 0, len);

}

Метод squeezeOut сначала преобразует свою входную строку from в символьный массив при помощи метода toCharArray. Затем он в цикле перебирает элементы массива в поисках символа toss. Когда такой символ находится, длина возвращаемой строки уменьшается на 1, а все следующие символы массива сдвигаются к началу. Значение i уменьшается, чтобы можно было проверить новый символ в позиции i и выяснить, не следует ли удалить и его. Когда метод завершает просмотр массива, он возвращает новый объект String, содержащий “выжатую” строку. Для этого применяется конструктор String, которому в качестве аргументов передается исходный массив, начальная позиция внутри массива и количество символов.

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

При желании вместо конструкторов можно воспользоваться двумя статическими методами String. copyValueOf. Например, метод squeezeOut мог бы заканчиваться следующей строкой:

return String. copyValueOf(chars, 0, len);

Вторая форма copyValueOf получает один аргумент и копирует весь массив. Для полноты было решено сделать два статических метода copy ValueOf эквивалентными двум конструкторам String.

Метод toCharArray прост и достаточен в большинстве случаев. Когда желательно иметь больше возможностей для контроля за процессом копирования фрагментов строки в символьный массив, можно воспользоваться методом getChars:

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

Копирует символы из строки в массив. Символы заданной подстроки копируются в массив начиная с dst[dstBegin]. Подстрока представляет собой фрагмент исходной строки, который начинается с позиции srcBegin и заканчивается на srcEnd (но не включает ее!). Любая попытка выхода за пределы строки или массива char приводит к возбуждению исключения IndexOutOfBoundsException.

8.7. Строки и массивы byte

Существуют методы, предназначенные для преобразования массивов 8-разрядных символов в объекты String в 16-разрядной кодировке Unicode и наоборот. Эти методы помогают создавать строки Unicode из символов ASCII или ISO-Latin-1, которые являются первыми 256 символами в наборе Unicode. Данные методы аналогичны своим прототипам, предназначенным для работы с символьными массивами:

public String(byte[] bytes, int hiByte, int offset, int count)

Конструктор создает новую строку, состоящую из символов заданного подмассива, входящего в массив bytes с позиции offset и состоящего из count символов. Старшие 8 бит каждого символа могут быть заданы в переменной hiByte, значение которой обычно равно 0, так как конструктор чаще всего используется для преобразования символов 8-разрядной кодировки ASCII или ISO-Latin-1 в 16-разрядные строки Unicode. Если значения аргументов offset и coun t заставляют конструктор обратиться к элементам, выходящим за границы массива, возбуждается исключение IndexOutOfBounds.

public String(byte[] bytes, int hiByte)

Сокращенная форма для String(bytesm hibyte, 0, bytes. length).

public void int  getBytes(int srcBegin, int srcEnd, byte[] dst, dstBegin)

Создает копию фрагмента строки в массиве dst, начиная с dst[dstBegin]. При этом теряются старшие 8 бит каждого символа. Копирование производится с позиции srcBegin и заканчивается в srcEnd (но не включает ее!). Любая попытка выхода за пределы строки или массива char приводит к возбуждению исключения IndexOutOfBoundsException.

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

8.8. Класс StringBuffer

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

public static String guillemete(String quote) {

return '"' + quote + '"';

}

Если бы компилятор ограничивался выражениями типа String, он действовал бы следующим образом:

quoted = String. valueOf('"').concat(quote)

.concat(String. valueOf('"'));

При каждом вызове valueOf и concat создается новый объект String; следовательно, в результате подобной операции появятся четыре объекта String, из которых в дальнейшем будет использован только один. Что касается остальных, то их создание, присвоение начальных значений и удаление будет сопряжено с непроизводительными расходами.

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

quoted = new StringBuffer().append('"').

.append(quote).append('"').toString();

В этом варианте создается всего один объект StringBuffer, который хранит строку, добавляет к ней новые фрагменты и пользуется методом toString для преобразования результатов своей работы в объект String.

Для построения и модификации строки можно воспользоваться классом StringBuffer. Класс StringBuffer содержит следующие конструкторы:

public StringBuffer()

Конструирует новый объект StringBuffer, начальное значение которого равно “”.

public StringBuffer(String str)

Конструирует новый объект StringBuffer, исходное значение которого совпадает с str.

Класс StringBuffer во многих отношениях напоминает класс String, а многие из содержащихся в нем методов имеют те же имена и контракты, что и методы String. Тем не менее StringBuffer не является расширением String, и наоборот. Оба этих класса являются независимыми расширениями класса Object.

8.8.1. Модификация буфера

Существует несколько возможностей изменить содержимое буфера объекта StringBuffer, в том числе добавить новые символы в его конец или вставить их в середину. Самый простой из таких методов называется setCharAt и служить для замены символа в конкретной позиции. Также имеется метод replace, который делает то же самое, что и String. replace, однако работает с объектом StringBuffer. Метод replace не нуждается в создании нового объекта для хранения результата, поэтому несколько последовательных вызовов replace могут выполняться с одним буфером:

public static void

replace(StringBuffer str, char from, char to)

{

for (int i = 0; i << str. length(); i++)

if (str. charAt(i) == from)

str. setCharAt(i, to);

}

Метод setLength обрезает или расширяет строку, хранящуюся в буфере. Если передать setLength величину, меньшую длины текущей строки, то строка будет обрезана до указанного значения. Если же передаваемая длина превышает текущую, то строка расширяется, а новые позиции заполняются нуль-символами (\u0000).

Кроме того, имеются методы append и insert, которые преобразуют данные любого типа в String, после чего присоединяют результат преобразования к концу строки либо вставляют его в середину. При выполнении метода insert существующие символы сдвигаются, чтобы освободить место для вставляемых новых символов. Методы append и insert преобразуют данные следующих типов:

Object String char[]

boolean char int int

long float double

Также существуют методы append и insert, которым в качестве аргумента передается часть массива char. Например, для создания объекта String Buffer с описанием квадратного корня из целого числа можно написать следующее:

String sqrtInt(int i) {

StringBuffer buf = new StringBuffer();

buf. append("sqrt(").append(i).append(')');

buf. append(" = ").append(Math. sqrt(i));

return buf. toString();

}

Методы append и insert возвращают исходный объект String, что в данном случае позволяет нам добавить новые символы к результату предыдущего действия.

Метод insert получает два параметра. Первый из них — позиция, начиная с которой в StringBuffer будут вставляться новые символы. Второй параметр — вставляемое значение, при необходимости преобразованное в String. Приведем метод, который вставляет добавляет дату в начало буфера:

public static StringBuffer addDate(StringBuffer buf) {

String now = new java. util. Date().toString();

buf. ensureCapacity(buf. length() + now. length() + 2);

buf. insert(0, now).insert(now. length(), ": ");

return buf;

}

Все начинается с создания строки, содержащей текущую дату. Для этой цели используется класс java. util. Date; его конструктор по умолчанию создает объект, представляющий текущее время на момент создания. Далее необходимо убедиться, что размеров буфера хватит для хранения всех добавляемых символов — увеличение буфера должно происходить только один раз, а не после каждого вызова insert. Затем в буфер вставляется строка с текущим временем, за которой следует простейшая строка-разделитель. Наконец, переданный буфер возвращается обратно, чтобы при вызове данного метода можно было осуществить что-нибудь наподобие той конкатенации, которая пригодилась при работе с собственными методами StringBuffer.

Метод reverse изменяет порядок следования символов в StringBuffer. Например, если буфер содержит строку “good”, то после выполнения reverse в нем окажется строка “doog”.

8.8.2. Извлечение данных

Чтобы создать объект String на основе объекта StringBuffer, следует вызвать метод toString.

В StringBuffer не существует методов, которые бы удаляли часть содержимого буфера — вам придется преобразовать буфер в символьный массив, удалить то, что нужно, и построить новый буфер по массиву с оставшимися символами. Вероятно, для этого следует воспользоваться методом getChars, который аналогичен методу String. getChars.

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

Копирует символы из заданной части буфера (определяемой позициями srcBegin и srcEnd) в массив dst начиная с dst[dstBegin]. Копирование ведется с позиции srcBegin до srcEnd (но не включает ее!). Позиция srcBegin должна представлять собой допустимый индекс для данного буфера, а позиция srcEnd не может превышать длины текущей строки в буфере (которая на единицу больше, чем последний индекс). Если какой-либо из индексов окажется недопустимым, возбуждается исключение Inde x OutOfBoundsException.

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

public static StringBuffer

remove(StringBuffer buf, int pos, int cnt)

{

if (pos << 0 || cnt << 0 || pos + cnt >> buf. length())

throw new IndexOutOfBoundsException();

int leftover = buf. length() - (pos + cnt);

if (leftover == 0) { // простое обрезание строки

buf. setlength(pos);

return buf;

}

char[] chrs = new char[leftover];

buf. getChars(pos + cnt, buf. Length(), chrs, 0);

buf. setLength(pos);

buf. append(chrs);

return buf;

}

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

8.8.3. Работа с емкостью буфера

Буфер объекта StringBuffer обладает определенной емкостью — так называется максимальная длина строки, которая может поместиться в нем перед тем, как придется выделять дополнительное место. Буфер может увеличиваться автоматически по мере добавления новых символов, однако для повышения эффективности желательно установить его размер один раз.

Исходный размер буфера объекта StringBuffer может быть задан с помощью конструктора, получающего всего один параметр типа int:

public StringBuffer(int capacity)

Конструирует новый объект StringBuffer с заданной исходной емкостью и начальным значением “”.

public synchronized void ensureCapacity(int minimum)

Позволяет убедиться в том, что буфер имеет емкость не менее заданного minimum.

public int capacity()

Возвращает текущую емкость буфера.

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

String sqrtIntFaster(int i) {

StringBuffer buf = new StringBuffer(50);

buf. append("sqrt(").append(i).append(')');

buf. append(" = ").append(Math. sqrt(i));

return buf. toString();

}

Единственное изменение заключается в том, что на этот раз используется конструктор, который создает достаточно большой объект StringBuffer, способный вместить строку с результатом. Значение 50 несколько превышает максимально необходимое; следовательно, буфер никогда не придется увеличивать заново.