Программирование на Java
Шрифт:
(s1.equals(s2)));
System.out.println(
"Strings are the same = " + (s1==s2));
}
}
В результате на консоль будет выведено:
String`s equally = true
Strings are the same = true
Теперь несколько модифицируем код:
public class Test {
public Test {
}
public static void main(String[] args) {
Test t = new Test;
String s1 = "Hello world !!!";
String s2 = new String("Hello world !!!");
System.out.println("String`s equally = " +
(s1.equals(s2)));
System.out.println(
"Strings are the same = " + (s1==s2));
}
}
В
String`s equally = true Strings are the same = false
Почему результат изменился? Дело в том, что создание нового объекта – это одна из самых трудоемких процедур в Java. Поэтому компилятор стремится уменьшить их количество, если это не приводит к непредсказуемому поведению программы.
В примере объявляются две переменные, которые инициализируются одинаковым значением. Поскольку класс String неизменяемый, их значения всегда будут одинаковыми. Это позволяет компилятору завести скрытую вспомогательную текстовую переменную, которая будет хранить такое значение, а все остальные переменные будут ссылаться на него же, а не порождать новые объекты. В результате в первом варианте программы создается лишь один объект String. Для большинства операций это несущественная разница. Исключение составляют действия, которые привязаны к конкретному объекту, а не к его значению. Это метод equals, методы wait/notify.
Во втором варианте указано динамическое обращение к конструктору. В этом случае компилятор уже не имеет возможности заниматься оптимизацией и JVM во время исполнения программы действительно создаст второй объект с точно таким же значением. Что мы и видим по результату выполнения примера.
В Java для строк определен оператор +. При использовании этого оператора производится конкатенация строк. В классе String также определен метод:
public String concat(String s);
Он возвращает новый объект-строку, дополненный справа строкой s.
Рассмотрим другой пример.
public class Test {
public static void main(String[] args) {
Test t = new Test;
String s = " prefix !";
System.out.println(s);
s = s.trim;
System.out.println(s);
s = s.concat(" suffix");
System.out.println(s);
}
}
prefix !
prefix !
prefix ! suffix
В данном случае может сложиться впечатление, что строку (объект String, на который ссылается переменная s ), можно изменять. В действительности это не так. В результате выполнения методов trim (отсечение пробелов в начале и конце строки) и concat создаются новые объекты-строки и ссылка s начинает указывать на новый объект-строку. Таким образом, меняется значение ссылки, объекты же неизменяемы.
Как уже отмечалось, строка состоит из двухбайтных Unicode-символов. Однако во многих случаях требуется работать со строкой как с набором байт (ввод/вывод, работа с базой данных и т.д.).
* byte[] getBytes – возвращает последовательность байтов в кодировке, принятой по умолчанию (как правило, зависит от настроек операционной системы);
* byte[] getBytes(String encoding) – возвращает последовательность байтов в указанной кодировке encoding.
Для выполнения обратной операции (преобразования байтов в строку) необходимо сконструировать новый объект-строку с помощью следующих методов:
* String(byte[] bytes) – создает строку из последовательности байтов в кодировке, принятой по умолчанию;
* String(byte[] bytes, String enc) – создает строку из последовательности байтов в указанной кодировке.
StringBuffer
Этот класс используется для создания и модификации строковых выражений, которые после можно превратить в String. Он реализован на основе массива char[], что позволяет, в отличие от String, модифицировать его значение после создания объекта.
Рассмотрим наиболее часто используемые конструкторы класса StringBuffer:
* StringBuffer – создает пустой StringBuffer ;
* StringBuffer(String s) – буфер заполняется указанным значением s ;
* StringBuffer(int capacity) – создает экземпляр класса StringBuffer с указанным размером (длина char[] ). Задание размера не означает, что нельзя будет оперировать строками с большей длиной, чем указано в конструкторе. На самом деле этим гарантируется, что при работе со строками меньшей длины дополнительное выделение памяти не потребуется.
Разница между String и StringBuffer может быть продемонстрирована на следующем примере:
public class Test {
public static void main(String[] args) {
Test t = new Test;
String s = new String("ssssss");
StringBuffer sb =
new StringBuffer("bbbbbb");
s.concat("-aaa");
sb.append("-aaa");
System.out.println(s);
System.out.println(sb);
}
}
В результате на экран будет выведено следующее:
ssssss
bbbbbb-aaa
В данном примере можно заметить, что объект String остался неизменным, а объект StringBuffer изменился.
Основные методы, используемые для модификации StringBuffer, это:
* public StringBuffer append(String str) – добавляет переданную строку str в буфер;
* public StringBuffer insert(int offset, String str) – вставка строки, начиная с позиции offset (пропустив offset символов).
Стоит обратить внимание, что оба метода имеют варианты, принимающие в качестве параметров различные примитивные типы Java вместо String. При использовании этих методов аргумент предварительно приводится к строке (с помощью String.valueOf ).