Строки: Основные операции

Строка (String) в Java — это последовательность символов. Класс String является неизменяемым (immutable), что означает, что после создания объекта строка не может быть изменена. Любые операции, изменяющие строку, создают новый объект.

Создание строк

Строки могут быть созданы несколькими способами:

Литералы строк:

String str1 = "Hello, World!";

Конструктор класса String:

String str2 = new String("Hello, World!");

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

Конкатенация строк:
Конкатенация — это процесс объединения двух или более строк.

С оператором +:

String str1 = "Hello, ";
String str2 = "World!";
String result = str1 + str2; // "Hello, World!"

С методом concat:

String str1 = "Hello, ";
String str2 = "World!";
String result = str1.concat(str2); // "Hello, World!"

Длина строки:

Метод length() возвращает количество символов в строке.

String str = "Hello, World!";
int length = str.length(); // 13

Извлечение символов:

Метод charAt(int index) возвращает символ по указанному индексу (индексация начинается с нуля).

String str = "Hello, World!";
char ch = str.charAt(0); // 'H'

Извлечение подстроки:

Метод substring(int beginIndex) возвращает подстроку, начиная с указанного индекса до конца строки. Метод substring(int beginIndex, int endIndex) возвращает подстроку от beginIndex до endIndex (не включая endIndex).

String str = "Hello, World!";
String subStr1 = str.substring(7); // "World!"
String subStr2 = str.substring(7, 12); // "World"

Сравнение строк:

С методом equals:

String str1 = "Hello";
String str2 = "Hello";
boolean isEqual = str1.equals(str2); // true

С методом equalsIgnoreCase:

String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equalsIgnoreCase(str2); // true

С методом compareTo:

String str1 = "Hello";
String str2 = "World";
int result = str1.compareTo(str2); // Отрицательное значение, так как "Hello" меньше "World"

Преобразование регистра:

В верхний регистр:

String str = "Hello, World!";
String upperStr = str.toUpperCase(); // "HELLO, WORLD!"

В нижний регистр:

String str = "Hello, World!";
String lowerStr = str.toLowerCase(); // "hello, world!"

Замена символов и подстрок:

Замена символа:

String str = "Hello, World!";
String replacedStr = str.replace('o', 'a'); // "Hella, Warld!"

Замена подстроки:

String str = "Hello, World!";
String replacedStr = str.replace("World", "Java"); // "Hello, Java!"

Удаление пробелов:

Метод trim удаляет начальные и конечные пробелы:

String str = "   Hello, World!   ";
String trimmedStr = str.trim(); // "Hello, World!"

#Java #Training #String

Класс String и его методы

Класс String в Java является частью пакета java.lang и предоставляет множество методов для работы со строками. Строки в Java неизменяемы, что означает, что каждый метод, изменяющий строку, возвращает новый объект строки.

Основные методы класса String

Создание строки

Конструкторы класса String:

String str1 = new String();
String str2 = new String("Hello");
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str3 = new String(charArray);
byte[] byteArray = {72, 101, 108, 108, 111};
String str4 = new String(byteArray);

Получение символа по индексу

Метод charAt(int index):

String str = "Hello, World!";
char ch = str.charAt(0); // 'H'

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

Метод compareTo(String anotherString) и compareToIgnoreCase(String str):

String str1 = "Hello";
String str2 = "World";
int result = str1.compareTo(str2); // Отрицательное значение
int resultIgnoreCase = str1.compareToIgnoreCase(str2); // Отрицательное значение

Проверка наличия подстроки

Метод contains(CharSequence s):

String str = "Hello, World!";
boolean containsWorld = str.contains("World"); // true

Проверка начала и конца строки

Методы startsWith(String prefix) и endsWith(String suffix):

String str = "Hello, World!";
boolean startsWithHello = str.startsWith("Hello"); // true
boolean endsWithWorld = str.endsWith("World!"); // true

Разделение строки

Метод split(String regex):

String str = "Hello, World!";
String[] words = str.split(", "); // ["Hello", "World!"]

Соединение массива строк

Метод join(CharSequence delimiter, CharSequence... elements):

String[] words = {"Hello", "World"};
String joinedString = String.join(", ", words); // "Hello, World"

#Java #Training #String

StringBuilder и StringBuffer

StringBuilder и StringBuffer — это классы, предоставляющие изменяемые строки. Они позволяют изменять содержимое строки без создания новых объектов, что делает их более эффективными для частых операций изменения строк.

StringBuilder

Класс StringBuilder был введен в Java 5 и предназначен для создания и изменения строк в однопоточных приложениях. Он не синхронизирован, что делает его быстрее, но не безопасным для использования в многопоточной среде.

Основные методы StringBuilder

Создание объекта StringBuilder:

StringBuilder sb = new StringBuilder(); // Создает пустой StringBuilder
StringBuilder sbWithCapacity = new StringBuilder(50); // Создает StringBuilder с начальной емкостью 50 символов
StringBuilder sbWithString = new StringBuilder("Hello"); // Создает StringBuilder с начальной строкой "Hello"

Добавление текста (метод append):

StringBuilder sb = new StringBuilder("Hello");
sb.append(", World!"); // sb теперь содержит "Hello, World!"

Вставка текста (метод insert):

StringBuilder sb = new StringBuilder("Hello, !");
sb.insert(7, "World"); // sb теперь содержит "Hello, World!"

Замена текста (метод replace):

StringBuilder sb = new StringBuilder("Hello, World!");
sb.replace(7, 12, "Java"); // sb теперь содержит "Hello, Java!"

Удаление текста (метод delete):

StringBuilder sb = new StringBuilder("Hello, World!");
sb.delete(5, 7); // sb теперь содержит "HelloWorld!"

Реверс строки (метод reverse):

StringBuilder sb = new StringBuilder("Hello");
sb.reverse(); // sb теперь содержит "olleH"

Получение длины и емкости:

StringBuilder sb = new StringBuilder("Hello");
int length = sb.length(); // 5
int capacity = sb.capacity(); // Емкость по умолчанию + длина строки "Hello"

Получение подстроки (метод substring):

StringBuilder sb = new StringBuilder("Hello, World!");
String subStr = sb.substring(7, 12); // "World"

StringBuffer

Класс StringBuffer аналогичен StringBuilder, но синхронизирован, что делает его безопасным для использования в многопоточных средах. Из-за синхронизации StringBuffer несколько медленнее, чем StringBuilder.

Основные методы StringBuffer

Методы класса StringBuffer аналогичны методам класса StringBuilder, поэтому приведем лишь их примеры:

Создание объекта StringBuffer:

StringBuffer sb = new StringBuffer(); // Создает пустой StringBuffer
StringBuffer sbWithCapacity = new StringBuffer(50); // Создает StringBuffer с начальной емкостью 50 символов
StringBuffer sbWithString = new StringBuffer("Hello"); // Создает StringBuffer с начальной строкой "Hello"

Добавление текста (метод append):

StringBuffer sb = new StringBuffer("Hello");
sb.append(", World!"); // sb теперь содержит "Hello, World!"

Вставка текста (метод insert):

StringBuffer sb = new StringBuffer("Hello, !");
sb.insert(7, "World"); // sb теперь содержит "Hello, World!"

Замена текста (метод replace):

StringBuffer sb = new StringBuffer("Hello, World!");
sb.replace(7, 12, "Java"); // sb теперь содержит "Hello, Java!"

Удаление текста (метод delete):

StringBuffer sb = new StringBuffer("Hello, World!");
sb.delete(5, 7); // sb теперь содержит "HelloWorld!"

Реверс строки (метод reverse):

StringBuffer sb = new StringBuffer("Hello");
sb.reverse(); // sb теперь содержит "olleH"

Получение длины и емкости:

StringBuffer sb = new StringBuffer("Hello");
int length = sb.length(); // 5
int capacity = sb.capacity(); // Емкость по умолчанию + длина строки "Hello"

Получение подстроки (метод substring):

StringBuffer sb = new StringBuffer("Hello, World!");
String subStr = sb.substring(7, 12); // "World"

#Java #Training #String

Разница между String, StringBuilder и StringBuffer

Строки (String)

Неизменяемость: Объекты класса String неизменяемы. После создания строки, её содержимое не может быть изменено.
Потокобезопасность: String является потокобезопасным из-за своей неизменяемости. Разные потоки могут безопасно использовать один и тот же объект строки.
Использование памяти: Каждое изменение строки создает новый объект, что может привести к большому количеству временных объектов и нагрузке на сборщик мусора.

Пример использования:

String str = "Hello";
str = str + ", World!"; // Создается новый объект строки

StringBuilder

Изменяемость: Объекты класса StringBuilder изменяемы. Можно изменять содержимое объекта без создания новых объектов.
Потокобезопасность: StringBuilder не является потокобезопасным. Он не синхронизирован, что делает его быстрым, но небезопасным для использования в многопоточных средах.
Использование памяти: StringBuilder более эффективен с точки зрения использования памяти при частых изменениях строк, так как не создает множество временных объектов.

Пример использования:

StringBuilder sb = new StringBuilder("Hello");
sb.append(", World!"); // Изменяется текущий объект sb

StringBuffer

Изменяемость: Объекты класса StringBuffer изменяемы, как и StringBuilder.
Потокобезопасность: StringBuffer является потокобезопасным. Он синхронизирован, что делает его безопасным для использования в многопоточных средах, но более медленным по сравнению с StringBuilder.
Использование памяти: StringBuffer эффективен с точки зрения использования памяти при частых изменениях строк в многопоточных приложениях.

Пример использования:

StringBuffer sb = new StringBuffer("Hello");
sb.append(", World!"); // Изменяется текущий объект sb

Сравнение производительности

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

Когда использовать каждый из классов?

String: Используйте String, когда строки неизменяемы или изменения редки. Подходит для констант и неизменяемых текстовых данных.
StringBuilder: Используйте StringBuilder, когда строки часто изменяются и безопасность потоков не является проблемой. Подходит для однопоточных приложений.
StringBuffer: Используйте StringBuffer, когда строки часто изменяются и требуется безопасность потоков. Подходит для многопоточных приложений.

Примеры использования:

String:

String str = "Hello";
str = str + ", World!"; // Создание нового объекта

StringBuilder:

StringBuilder sb = new StringBuilder("Hello");
sb.append(", World!"); // Изменение текущего объекта

StringBuffer:

StringBuffer sb = new StringBuffer("Hello");
sb.append(", World!"); // Изменение текущего объекта

#Java #Training #String

Ссылочные типы в Java — строки (String)

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


Создание строк

В Java строки можно создавать несколькими способами:

String s1 = "Hello";
String s2 = new String("Hello");

В первом случае строка создаётся в пуле строк — специальной области памяти, где хранятся уникальные строковые литералы.
Во втором случае используется оператор new, что приводит к созданию нового объекта строки в куче, независимо от содержимого.

Также строки можно строить из массивов символов или байтов:

char[] chars = {'J', 'a', 'v', 'a'};
String s3 = new String(chars);

Ключевые особенности:
Строки в Java являются объектами класса java.lang.String.
Объекты String неизменяемы: после создания их содержимое нельзя изменить.
Неизменяемость позволяет безопасно использовать строки в многопоточном окружении и в качестве ключей в Map.


Существование и удаление строк

Как и любые объекты, строки существуют до тех пор, пока на них имеются активные ссылки. Когда все ссылки теряются, строка становится кандидатом на сборку мусора.
Однако строки, созданные как литералы (например, "Hello"), хранятся в строковом пуле, и удаление таких строк происходит только при завершении работы JVM или при агрессивной сборке мусора в редких случаях.

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true — обе ссылаются на одну строку из пула

В случае создания строки через new, строки не участвуют в пуле по умолчанию:

String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2); // false

Метод intern() позволяет вручную добавить строку в пул:

String s1 = new String("abc").intern();
String s2 = "abc";
System.out.println(s1 == s2); // true

Использование строк

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

Java предоставляет множество удобных методов для работы со строками:

String s = "Hello, World!";
int length = s.length();
char ch = s.charAt(0);
String lower = s.toLowerCase();
boolean contains = s.contains("World");

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

String original = "Java";
String modified = original.replace("J", "K");
System.out.println(original); // Java
System.out.println(modified); // Kava

Сравнение строк:

String a = "hello";
String b = new String("hello");

System.out.println(a == b);          // false — разные объекты
System.out.println(a.equals(b));     // true — одинаковое содержимое
Оператор == сравнивает ссылки, а метод equals() — содержимое.

#Java #для_новичков #beginner #reference_types #String

Трудности и подводные камни

1. Неизменяемость
Изменение строки всегда приводит к созданию нового объекта. Это важно учитывать при работе в циклах:

String result = "";
for (int i = 0; i < 1000; i++) {
    result += "a"; // создается 1000 новых строк
}

Лучше использовать StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("a");
}
String result = sb.toString();

2. Сравнение с null

Обращение к методам строки без проверки может привести к NullPointerException:

String name = null;
if (name.equals("admin")) { // ошибка
}

Правильнее писать:

if ("admin".equals(name)) { // безопасно
}

3. Пул строк и производительность
Пул строк позволяет уменьшить использование памяти, но злоупотребление вручную созданными строками через new String(...) может привести к увеличению нагрузки на сборщик мусора.

4. Конкатенация и производительность
Строки, объединённые с помощью + в цикле, могут ухудшать производительность. Лучше использовать StringBuilder или StringBuffer (если требуется потокобезопасность).

5. Использование в Map и Set

Поскольку строки неизменяемы, их можно безопасно использовать в качестве ключей в HashMap, HashSet и других коллекциях. Однако важно корректно переопределять equals() и hashCode() для классов, в которых строки используются в качестве полей для сравнения.


Дополнительные нюансы

1. String vs StringBuilder vs StringBuffer
String — неизменяемый, потокобезопасный.
StringBuilder — изменяемый, не потокобезопасный, но самый быстрый.
StringBuffer — изменяемый, потокобезопасный, но медленнее.

2. Методы класса String

Строки обладают большим набором методов:
substring()
trim()
split()
replace()
matches() (регулярные выражения)
format() и другие

3. Регулярные выражения

Методы matches(), replaceAll() и split() поддерживают регулярные выражения, что делает String мощным инструментом для разбора и обработки текста.

4. Юникод и кодировка

Java строки используют UTF-16, где каждый символ — это один или два 16-битных элемента. Это важно при работе с Unicode-символами, особенно при подсчёте длины строки или извлечении символов.

5. Объекты String в коллекциях

Если строка используется как ключ в Map, важно помнить, что разные ссылки на строки с одинаковым содержимым будут считаться одинаковыми, если equals() и hashCode() совпадают — что работает корректно для String.

#Java #для_новичков #beginner #reference_types #String