Java string
Содержание:
- Введение в строки. Класс String
- Дата и Время
- compareTo()
- Поиск с помощью indexOf()
- 1 Сравнение строк
- Метод сравнения String compareTo()
- Структура программы
- 2 Класс Double
- Concatenating Strings
- Класс Object и его методы
- Классы StringBuilder и StringBuffer
- Подсписок списка
- Methods of Java String
- 1 Конкатенация — склеивание строк
- Возведение в степень
- Creating Strings
- java.lang.StringBuilder
Введение в строки. Класс String
Последнее обновление: 31.10.2018
Строка представляет собой последовательность символов. Для работы со строками в Java определен класс String, который предоставляет ряд методов для манипуляции строками.
Физически объект String представляет собой ссылку на область в памяти, в которой размещены символы.
Для создания новой строки мы можем использовать один из конструкторов класса String, либо напрямую присвоить строку в двойных кавычках:
public static void main(String[] args) {
String str1 = "Java";
String str2 = new String(); // пустая строка
String str3 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
String str4 = new String(new char[]{'w', 'e', 'l', 'c', 'o', 'm', 'e'}, 3, 4);//3 -начальный индекс, 4 -кол-во символов
System.out.println(str1); // Java
System.out.println(str2); //
System.out.println(str3); // hello
System.out.println(str4); // come
}
При работе со строками важно понимать, что объект String является неизменяемым (immutable). То есть при любых операциях
над строкой, которые изменяют эту строку, фактически будет создаваться новая строка
Поскольку строка рассматривается как набор символов, то мы можем применить метод length() для нахождения длины строки или длины набора символов:
String str1 = "Java"; System.out.println(str1.length()); // 4
А с помощью метода toCharArray() можно обратно преобразовать строку в массив символов:
String str1 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
char[] helloArray = str1.toCharArray();
Строка может быть пустой. Для этого ей можно присвоить пустые кавычки или удалить из стоки все символы:
String s = ""; // строка не указывает на объект
if(s.length() == 0) System.out.println("String is empty");
В этом случае длина строки, возвращаемая методом length(), равна 0.
Класс String имеет специальный метод, который позволяет проверить строку на пустоту — isEmpty(). Если строка пуста, он возвращает true:
String s = ""; // строка не указывает на объект
if(s.length() == 0) System.out.println("String is empty");
Переменная String может не указывать на какой-либо объект и иметь значение null:
String s = null; // строка не указывает на объект
if(s == null) System.out.println("String is null");
Значение null не эквивалентно пустой строке. Например, в следующем случае мы столкнемся с ошибкой выполнения:
String s = null; // строка не указывает на объект
if(s.length()==0) System.out.println("String is empty"); // ! Ошибка
Так как переменная не указывает ни на какой объект String, то соответственно мы не можем обращаться к методам объекта String.
Чтобы избежать подобных ошибок, можно предварительно проверять строку на null:
String s = null; // строка не указывает на объект
if(s!=null && s.length()==0) System.out.println("String is empty");
Основные методы класса String
Основные операции со строками раскрывается через методы класса String, среди которых можно выделить следующие:
-
concat(): объединяет строки
-
valueOf(): преобразует объект в строковый вид
-
join(): соединяет строки с учетом разделителя
-
сompare(): сравнивает две строки
-
charAt(): возвращает символ строки по индексу
-
getChars(): возвращает группу символов
-
equals(): сравнивает строки с учетом регистра
-
equalsIgnoreCase(): сравнивает строки без учета регистра
-
regionMatches(): сравнивает подстроки в строках
-
indexOf(): находит индекс первого вхождения подстроки в строку
-
lastIndexOf(): находит индекс последнего вхождения подстроки в строку
-
startsWith(): определяет, начинается ли строка с подстроки
-
endsWith(): определяет, заканчивается ли строка на определенную подстроку
-
replace(): заменяет в строке одну подстроку на другую
-
trim(): удаляет начальные и конечные пробелы
-
substring(): возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса
-
toLowerCase(): переводит все символы строки в нижний регистр
-
toUpperCase(): переводит все символы строки в верхний регистр
Разберем работу этих методов.
НазадВперед
Дата и Время
System.currentTimeMillis или System.nanoTime?
В Java есть два стандартных способа проведения операций со временем, и не всегда ясно, какой из них следует выбрать.
Метод возвращает текущее количество миллисекунд с начала эры Unix в формате Long. Его точность составляет от 1 до 15 тысячных долей секунды в зависимости от системы.
Метод имеет точность до одной миллионной секунды (наносекунды) и возвращает текущее значение наиболее точного доступного системного таймера.
Таким образом, метод лучше применять для отображения и синхронизации абсолютного времени, а для измерения относительных интервалов времени.
Валидация Даты из строки
Если необходимо достать объект из обычной строки в Java, можете использовать небольшой утилитный класс, который приведен ниже. Он позаботится обо всех сложностях валидации и преобразовании строки в объект .
Пример его использования:
Результат:
compareTo()
Метод compareTo() сравнивает строку с другой и возвращает int, сообщающий, меньше ли эта строка, равна или больше другой.
- Если строка в порядке сортировки раньше, чем другая, возвращается отрицательное число.
- совпадает с другой, возвращается 0.
- Если находится после другой в порядке сортировки, выводит положительное число.
Вот пример:
String one = "abc"; String two = "def"; String three = "abd"; System.out.println( one.compareTo(two) ); System.out.println( one.compareTo(three) );
В этом примере сравнивается одна строка с двумя другими. Вывод:
-3 -1
Числа отрицательны, потому что одна строка находится в порядке сортировки раньше, чем две другие.
Метод compareTo() фактически принадлежит интерфейсу Comparable.
Поиск с помощью indexOf()
Вы можете искать подстроки в Strings, используя метод indexOf():
String string1 = "Hello World";
int index = string1.indexOf("World");
Индексная переменная будет содержать значение 6 после выполнения этого кода. Метод indexOf() возвращает индекс, в котором находится первый символ в первой соответствующей подстроке. В этом случае W совпадающей подстроки World была найдена по индексу 6. Если подстрока не найдена в строке, метод возвращает -1.
Существует версия метода indexOf(), которая берет индекс, с которого начинается поиск. Таким образом, вы можете искать в строке, чтобы найти более одного вхождения подстроки:
String theString = "is this good or is this bad?";
String substring = "is";
int index = theString.indexOf(substring);
while(index != -1) {
System.out.println(index);
index = theString.indexOf(substring, index + 1);
}
Этот код просматривает строку «это хорошо или это плохо?» для вхождений подстроки «is». Для этого используется метод indexOf(substring, index). Параметр index указывает, с какого индекса символа в строке следует начать поиск. В этом примере поиск начинается с 1 символа после индекса, в котором было найдено предыдущее вхождение.
Вывод:
0 5 16 21
Подстрока «is» находится в четырех местах. Два раза в словах «есть» и два раза внутри слова «этот».
Класс Java String также имеет метод lastIndexOf(), который находит последнее вхождение подстроки:
String theString = "is this good or is this bad?"; String substring = "is"; int index = theString.lastIndexOf(substring); System.out.println(index);
Выход — 21, который является индексом последнего вхождения подстроки «is».
1 Сравнение строк
Сравнение — одна из самых частых вещей, которая делается со строками. У класса String более десяти различных методов, которые используются для сравнения строк со строками. Ниже мы рассмотрим 8 основных.
| Методы | Описание |
|---|---|
| Строки считаются равными, если все их символы совпадают. | |
| Сравнивает строки, игнорируя регистр (размер) букв | |
| Сравнивает строки, возвращает количество одинаковых символов от начала строки. | |
| Возвращает количество одинаковых символов от начала строки, игнорирует регистр | |
| Сравнивает части строк | |
| Проверяет, что текущая строка начинается со строки | |
| Проверят, что текущая строка заканчивается на строку |
Допустим, вы хотите написать программу, которая просит пользователя ввести путь к файлу и проверяет, что это за файл по его расширению. Тогда код такой программы мог бы выглядеть примерно так:
| Код | Примечания |
|---|---|
| Создание объекта Чтение строки с консоли Проверяем, что строка оканчивается на заданную строку |
Метод сравнения String compareTo()
Метод сравнения compareTo() применяется, если надо определить лексикографический порядок строк. Он выполняет сравнение значения char, действуя аналогично equals(). Когда 2 строки совпадают, compareTo() вернёт значение «ноль» (результат = 0). Сравнивая 2 строки, он вернёт положительное целое число (результат > 0), если 1-й объект String следует за 2-й строкой. Соответственно, метод вернёт отрицательный результат (результат < 0), когда 1-й объект String будет предшествовать 2-й строке:
result1 == result2 возвращается ;
result1 > result2 возвращается положительное значение;
result1 < result2 возвращается отрицательное значение.
Приведём пример:
class TestClass{
public static void main (String[] args) {
String str1 = "Java";
String str2 = "Java";
String str3 = "ASP";
int val = ;
val = str1.compareTo(str2);
System.out.println(val);
val = str1.compareTo(str3);
System.out.println(val);
val = str3.compareTo(str1);
System.out.println(val);
}
}
Итог:
9 -9
На этом всё, очень надеемся, что этот материал будет вам полезен при сравнении строк в «Джава».
При подготовке статьи использовалась публикация «String Comparison in Java».
Хотите знать больше? Приходите на курс!
.
Структура программы
Последнее обновление: 12.04.2018
Основным строительным блоком программы на языке Java являются инструкции (statement).
Каждая инструкция выполняет некоторое действие, например, вызовы методов, объявление переменных и присвоение им значений. После завершения инструкции в Java ставится точка с запятой (;). Данный знак указывает компилятору на
конец инструкции. Например:
System.out.println("Hello Java!");
Данная строка представляет вызов метода , который выводит на консоль строку «Hello Java!». В данном случае вызов
метода является инструкцией и поэтому завершается точкой с запятой.
Кроме отдельных инструкций распространенной конструкцией является блок кода. Блок кода содержит набор инструкций, он заключается в фигурные скобки, а инструкции помещаются между открывающей и закрывающей фигурными скобками:
{
System.out.println("Hello!");
System.out.println("Welcome to Java!");
}
В этом блоке кода две инструкции, которые выводят на консоль определенную строку.
Выполнение программы. Метод main
Java является объектно-ориентированным языком, поэтому всю программу можно представить как набор взаимодействующих между собой классов и объектов.
В первой главе при создании первого приложения программа была определена следующим образом:
public class Program{
public static void main (String args[]){
System.out.println("Hello Java!");
}
}
То есть основу нашей программы составляет класс Program. При определении класса вначале идет модификатор доступа public,
который указывает, что данный класс будет доступен всем, то есть мы сможем его запустить из командной строки. Далее идет ключевое слово class,
а затем название класса. После названия класса идет блок кода, в котором расположено содержимое класса.
Входной точкой в программу на языке Java является метод main, который определен в классе Program. Именно с него начинается
выполнение программы. Он обязательно должен присутствовать в программе. При этом его заголовок может быть только таким:
public static void main (String args[])
При запуске приложения виртуальная машина Java ищет в главном классе программы метод main с подобным заголовком, и после его обнаружения запускает его.
Вначале заголовка метода идет модификатор , который указывает, что метод будет доступен извне. Слово указывает, что метод
main — статический, а слово — что он не возвращает никакого значения. Далее в скобках у нас идут параметры метода — —
это массив args, который хранит значения типа String, то есть строки. При запуске программы через этот массив мы можем передать в программу различные данные.
После заголовка метода идет его блок, который содержит набор выполняемых инструкций.
Комментарии
Код программы может содержать комментарии. Комментарии позволяют понять смысл программы, что делают те или иные ее части. При компиляции комментарии
игнорируются и не оказывают никакого влияния на работу приложения и на его размер.
В Java есть два типа комментариев: однострочный и многострочный. Однострочный комментарий размещается на одной строке после двойного слеша //.
А многострочный комментарий заключается между символами /* текст комментария */. Он может размещаться на нескольких строках.
Например:
/*
многострочный комментарий
Объявление нового класса,
который содержит код программы
*/
public class Program{ // начало объявления класса Program
// определение метода main
public static void main (String args[]){ // объявление нового метода
System.out.println("Hello Java!"); // вывод строки на консоль
} // конец объявления нового метода
} // конец объявления класса Program
НазадВперед
2 Класс Double
Класс , в общем-то, аналогичен классу , только является оберткой не для типа , а для типа . У него тоже есть интересные нам поля и методы, рассмотрим некоторые из них:
Интересных полей у класса шесть:
| Поле | Описание |
|---|---|
| Минус бесконечность | |
| Плюс бесконечность | |
| Минимальное значение экспоненты (2x) | |
| Максимальное значение экспоненты (2x) | |
| Минимальное значение типа | |
| Максимальное значение типа |
Бесконечность
Если вы разделите на , получите отрицательную бесконечность, если на — положительную бесконечность. Тип может не только делить на ноль, но и хранить такие значения.
Экспонента числа
С экспонентой тоже все просто. Число double внутри состоит из мантисы и экспоненты. Только вот значение экспоненты — это не , а . Если экспонента вырастет на , итоговое значение числа станет больше в два раза.
, в итоге получаем примерно равно
Также у класса есть интересные методы:
| Методы | Описание |
|---|---|
| Возвращает строку — шестнадцатеричное представление числа | |
| Проверяет, является ли переданное число бесконечностью. | |
| Проверяет, является ли переданное число | |
| Оборачивает переданный в | |
| Возвращает число, полученное из строки |
Из интересного можно отметить наличие метода , который возвращает , если переданное в него число было плюс или минус бесконечность.
Аналогично работает и метод — проверяет, является ли переданное в него число : специальная константа, обозначающая неопределенность (Not a Number, Не число).
Concatenating Strings
The String class includes a method for concatenating two strings −
string1.concat(string2);
This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in −
"My name is ".concat("Zara");
Strings are more commonly concatenated with the + operator, as in −
"Hello," + " world" + "!"
which results in −
"Hello, world!"
Let us look at the following example −
Example
public class StringDemo {
public static void main(String args[]) {
String string1 = "saw I was ";
System.out.println("Dot " + string1 + "Tod");
}
}
This will produce the following result −
Класс Object и его методы
Последнее обновление: 21.04.2018
Хотя мы можем создать обычный класс, который не является наследником, но фактически все классы наследуются от класса Object.
Все остальные классы, даже те, которые мы добавляем в свой проект, являются неявно производными от класса Object.
Поэтому все типы и классы могут реализовать те методы, которые определены в классе Object. Рассмотрим эти методы.
toString
Метод служит для получения представления данного объекта в виде строки. При попытке вывести строковое представления
какого-нибудь объекта, как правило, будет выводиться полное имя класса. Например:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
System.out.println(tom.toString()); // Будет выводить что-то наподобие Person@7960847b
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
}
Полученное мной значение (в данном случае ) вряд ли может служить хорошим строковым описанием объекта.
Поэтому метод нередко переопределяют. Например:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
System.out.println(tom.toString()); // Person Tom
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public String toString(){
return "Person " + name;
}
}
Метод hashCode
Метод hashCode позволяет задать некоторое числовое значение, которое будет соответствовать данному объекту или его хэш-код.
По данному числу, например, можно сравнивать объекты.
Например, выведем представление вышеопределенного объекта:
Person tom = new Person("Tom");
System.out.println(tom.hashCode()); // 2036368507
Но мы можем задать свой алгоритм определения хэш-кода объекта:
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public int hashCode(){
return 10 * name.hashCode() + 20456;
}
}
Получение типа объекта и метод getClass
Метод позволяет получить тип данного объекта:
Person tom = new Person("Tom");
System.out.println(tom.getClass()); // class Person
Метод equals
Метод equals сравнивает два объекта на равенство:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
Person bob = new Person("Bob");
System.out.println(tom.equals(bob)); // false
Person tom2 = new Person("Tom");
System.out.println(tom.equals(tom2)); // true
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public boolean equals(Object obj){
if (!(obj instanceof Person)) return false;
Person p = (Person)obj;
return this.name.equals(p.name);
}
}
Метод equals принимает в качестве параметра объект любого типа, который мы затем приводим к текущему, если они являются объектами
одного класса.
Оператор instanceof позволяет выяснить, является ли переданный в качестве параметра объект объектом определенного класса,
в данном случае класса Person. Если объекты принадлежат к разным классам, то их сравнение не имеет смысла, и возвращается значение false.
Затем сравниваем по именам. Если они совпадают, возвращаем true, что будет говорить, что объекты равны.
НазадВперед
Классы StringBuilder и StringBuffer
Давайте теперь разберемся со StringBuilder и StringBuffer классами. По сути дела, это почти одинаковые классы. Единственное различие между ними: StringBuffer работает медленнее, но он потокобезопасный. Его использование целесообразно при написании программ на многопоточность.
Если Вы посмотрите на код выше, то последний метод, который я написал была конкатенация строк. То есть простое объединение строк в одну. Когда Вы работаете с классом String, результатом такой операции будет новый объект. Если программа конкатенирует много строк это может существенно потребить ресурсы памяти. В отличие от String классы StringBuilder, StringBuffer конкатенируют строки не создавая новый объект. У них есть метод append().
- StringBuilder string = new StringBuilder(«Hello world»);
- String str = «!!!»;
- System.out.println(string.append(str));//Hello world!!!
Все остальные методы которые есть у класса String есть у данных классов.
Теперь Вы знаете больше о строках в Java. Предлагаю закрепить наши знания и написать небольшую программу для проверки логина и пароля. Пользователь вводит логин и пароль; если пароль совпадает, то вывести в консоль приветствие.
Вот что у меня получилось:
- package com.string;
- import java.util.Scanner;
- public class StringVariables {
- private final static String PASSWORD = «pass43_4L»;
- private final static String LOGIN = «user»;
- public static void main(String args) {
- System.out.println(«Введите логин»);
- Scanner in = new Scanner(System.in);
- String login = in.nextLine();
- System.out.println(«Введите пароль»);
- String password = in.nextLine();
- if (LOGIN.equalsIgnoreCase(login)){
- if (PASSWORD.equals(password)){
- System.out.println(«Приветствую » + login);
- }
- else {
- System.out.println(«Неверный пароль»);
- }
- }
- else
- System.out.println(«Неверный логин»);
- }
- }
Подсписок списка
Метод subList () может создавать новый List с подмножеством элементов из исходного List.
Метод subList () принимает 2 параметра: начальный индекс и конечный индекс. Начальный индекс — это индекс первого элемента из исходного списка для включения в подсписок.
Конечный индекс является последним индексом подсписка, но элемент в последнем индексе не включается в подсписок. Это похоже на то, как работает метод подстроки Java String.
List list = new ArrayList();
list.add("element 1");
list.add("element 2");
list.add("element 3");
list.add("element 4");
List sublist = list.subList(1, 3);
После выполнения list.subList (1,3) подсписок будет содержать элементы с индексами 1 и 2.
Преобразовать list в set
Вы можете преобразовать список Java в набор(set), создав новый набор и добавив в него все элементы из списка. Набор удалит все дубликаты.
Таким образом, результирующий набор будет содержать все элементы списка, но только один раз.
List list = new ArrayList();
list.add("element 1");
list.add("element 2");
list.add("element 3");
list.add("element 3");
Set set = new HashSet();
set.addAll(list);
Обратите внимание, что список содержит элемент String 3 два раза. Набор будет содержать эту строку только один раз
Таким образом, результирующий набор будет содержать строки: , and .
Общие списки
По умолчанию вы можете поместить любой объект в список, но Java позволяет ограничить типы объектов, которые вы можете вставить в список.
List<MyObject> list = new ArrayList<MyObject>();
Этот список теперь может содержать только экземпляры MyObject. Затем вы можете получить доступ к итерации его элементов без их приведения.
MyObject myObject = list.get(0);
for(MyObject anObject : list){
//do someting to anObject...
}
Methods of Java String
Besides those mentioned above, there are various string methods present in Java. Here are some of those methods:
| Methods | Description |
|---|---|
| substring() | returns the substring of the string |
| replace() | replaces the specified old character with the specified new character |
| charAt() | returns the character present in the specified location |
| getBytes() | converts the string to an array of bytes |
| indexOf() | returns the position of the specified character in the string |
| compareTo() | compares two strings in the dictionary order |
| trim() | removes any leading and trailing whitespaces |
| format() | returns a formatted string |
| split() | breaks the string into an array of strings |
| toLowerCase() | converts the string to lowercase |
| toUpperCase() | converts the string to uppercase |
| valueOf() | returns the string representation of the specified argument |
| toCharArray() | converts the string to a array |
1 Конкатенация — склеивание строк
Есть очень интересная и простая вещь, которую можно делать со строками в Java — их можно склеивать. Такая операция называется конкатенация. Ну или чтобы легче запомнилось — Кон-Котэ-Нация. Хотя часто ее называют «склеивание строк» или даже просто «сложение строк».
Чтобы склеить две строки, нужно использовать знак . Это очень просто:
Конкатенация двух строк
Примеры:
| Команда | Примечание |
|---|---|
| содержит строку | |
| содержит строку | |
| содержит строку |
Ну и, конечно, одновременно можно складывать много строк, а также складывать строки и переменные.
Примеры:
| Команда | Примечание |
|---|---|
| содержит строку содержит строку содержит строку |
В последнем примере видно, что текст в переменной плохо читается, т.к. в нем не хватает пробелов. Чтобы задать один пробел или несколько, нужно просто написать их в коде и обернуть в двойные кавычки. Это проще, чем кажется:
Строка, содержащая один пробел
Кстати, если между кавычками совсем не оставить места (написать две двойные кавычки подряд), получится так называемая «пустая строка»:
Пустая строка
С одной стороны, она вроде бы и есть, а с другой, при ее выводе на экран ничего не выводится. И при склейке с другими строками ничего не происходит. Эдакий аналог нуля, только для строк.
Возведение в степень
Возвести число в степень можно двумя способами:
- простое умножение;
- используя метод (двойное основание, двойной показатель степени).
Использование библиотечной функции рекомендуется только в случае крайней необходимости, например, в случае дробной или отрицательной степени.
Простое умножение в Java работает в 300-600 раз эффективнее, кроме того, его можно дополнительно оптимизировать:
JIT оптимизация
Код Java обрабатывается с использованием JIT-компиляции: сначала он транслируется в платформенно-независимый байт-код, а затем в машинный код. При этом оптимизируется все возможное, и разработчик может помочь компилятору создать максимально эффективную программу.
В качестве примера рассмотрим две простые операции:
Давайте измерим время выполнения каждого из них:
Запустив этот код несколько раз, мы получим примерно следующее:
Схема очевидна: группировка переменных в круглые скобки ускоряет работу программы. Это связано с генерацией более эффективного байт-кода при умножении одинаковых значений.
Вы можете узнать больше об этом эксперименте здесь. Или можете провести свой собственный тест, используя онлайн-компилятор Java.
Creating Strings
The most direct way to create a string is to write −
String greeting = "Hello world!";
Whenever it encounters a string literal in your code, the compiler creates a String object with its value in this case, «Hello world!’.
As with any other object, you can create String objects by using the new keyword and a constructor. The String class has 11 constructors that allow you to provide the initial value of the string using different sources, such as an array of characters.
Example
public class StringDemo {
public static void main(String args[]) {
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
String helloString = new String(helloArray);
System.out.println( helloString );
}
}
This will produce the following result −
Output
hello.
Note − The String class is immutable, so that once it is created a String object cannot be changed. If there is a necessity to make a lot of modifications to Strings of characters, then you should use String Buffer & String Builder Classes.
java.lang.StringBuilder
В отличие от String класс StringBuilder позволяет менять содержимое своих экземпляров. В большинстве случаев нужно использовать
String , использование же
StringBuilder целесообразно в случаях, когда вам нужно соединить большое количество строковых переменных, например перебирая элементы массива или коллекции в цикле.
Так же как и у
String у
StringBuilder есть метод
length() , позволяющий узнать его длину в
char -ах.
В отличие от
String у
StringBuilder кроме длины есть ещё вместимость/ёмкость (capacity). Вместительность можно узнать с помощью метода
capacity() , она всегда больше или равна длине.
| Конструктор | Описание |
|---|---|
| Создаёт пустой StringBuilder вместительностью 16 (16 пустых элементов). |
|
| Создаёт StringBuilder , содержащий символы из последовательности и 16 дополнительных пустых элементов. |
|
| Создаёт пустой StringBuilder с начальной вместительностью в initCapacity элементов. |
|
| Создаёт StringBuilder , который содержит указанную строку и 16 дополнительных пустых элементов. |
StringBuilder содержит пару дополнительных методов, связанных с длиной, которых нет в
String :
| Метод | Описание |
|---|---|
| Устанавливает длину последовательности символов. Если newLength меньше length() , то последние символы обрезаются. Если newLength больше length() , то в конец последовательности добавляются нулевые символы. |
|
| Обеспечивает, что вместительность будет как минимум равной minCapacity . |
Некоторые методы могут увеличить длину последовательности символов в
StringBuilder . Если после выполнения подобного метода длина результирующей последовательности окажется больше вместительности, то вместительность автоматически увеличится.
| Метод | Описание |
|---|---|
| Добавляет аргумент, преобразованный в строку, в конец StringBuilder-а. | |
| Первый метод удаляет подпоследовательность с start до end-1 включительно. Второй метод удаляет символ по индексу. |
|
| Вставляет второй аргумент, конвертированный в строку, в позицию index . |
|
| Заменяет указанный символ/ы. | |
| Меняет порядок символов в StringBuilder на обратный. Первый символ становится последним и так далее. |
|
| Возвращает строку, содержащую последовательность символов из StringBuilder . |
Пример использования StringBuilder:
Java
String andStr = » and Petya»;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(«Vasya»);
stringBuilder.append(andStr);
stringBuilder.append(» go to school.»);
System.out.println(stringBuilder);
|
1 |
StringandStr=» and Petya»; StringBuilder stringBuilder=newStringBuilder(); stringBuilder.append(«Vasya»); stringBuilder.append(andStr); stringBuilder.append(» go to school.»); System.out.println(stringBuilder); |
Цикл статей «Учебник Java 8».
Следующая статья — «Java 8 автоупаковка и распаковка».
Предыдущая статья — «Java 8 числа».
