Что такое string java

Работа со строками

Строка представляет собой последовательность символов. Для работы со строками в Java определен класс String, который предоставляет ряд методов для манипуляции строками. Физически объект String представляет собой ссылку на область в памяти, в которой размещены символы.

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

public static void main(String[] args) < String str1 = "Java"; String str2 = new String(); // пустая строка String str3 = new String(new char[] ); String str4 = new String(new char[], 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[] ); 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.isEmpty()) 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() : соединяет строки с учетом разделителя
• сompareTo() : сравнивает две строки
• charAt() : возвращает символ строки по индексу
• getChars() : возвращает группу символов
• equals() : сравнивает строки с учетом регистра
• equalsIgnoreCase() : сравнивает строки без учета регистра
• regionMatches() : сравнивает подстроки в строках
• indexOf() : находит индекс первого вхождения подстроки в строку
• lastIndexOf() : находит индекс последнего вхождения подстроки в строку
• startsWith() : определяет, начинается ли строка с подстроки
• endsWith() : определяет, заканчивается ли строка на определенную подстроку
• replace() : заменяет в строке одну подстроку на другую
• trim() : удаляет начальные и конечные пробелы
• substring() : возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса
• toLowerCase() : переводит все символы строки в нижний регистр
• toUpperCase() : переводит все символы строки в верхний регистр

Разберем работу этих методов.

15. Java – Строки и методы класса String

Строки – представляют собой последовательность символов. Строки в Java широко используются и являются объектами.

Платформа Java предоставляет класс строк (class String) для создания и работы со строками.

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

Наиболее простой способ создать строку:

String greeting = "Здравствуй, мир!"; 

После каждого раза, когда компилятор встречает строковый литерал в коде, он создает строковый объект (String) со значение, в данном случае «Здравствуй, мир!».

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

Пример

public class Test < public static void main(String args[])< char[] helloArray = < 'П', 'р', 'и', 'в', 'е', 'т', '.'>; String helloString = new String(helloArray); System.out.println(helloString); > > 

Получим следующий результат:

Привет. 

Примечание: Класс строк является неизменяемым, так что как только он будет создан, строковый объект не может быть изменен. Если есть необходимость сделать много изменений в строке символов, следует использовать классы строки буфера (String Buffer) и построитель строки (String Builder Classes).

Длина строки

Методы, используемые для получения информации об объекте, известны как методы доступа. Один из методов доступа, который можно использовать со строками является метод length(), он возвращает количество символов, содержащихся в строковом объекте.

Ниже представлен пример метода length(), который поможет определить длину строки.

Пример

public class Test < public static void main(String args[]) < String s = "Я стану отличным программистом!"; int len = s.length(); System.out.println( "Длина строки: " + len + " символ."); >> 

Получим следующий результат:

Длина строки: 31 символ. 

Объединение строк в Java

Класс строк включает метод для объединения двух строк:

string1.concat(string2); 

Возвращает новую строку string1, с добавленной строкой string2 в конце. Вы также можете использовать метод concat() со строковыми литералами:

"Меня зовут ".concat("Олег"); 

Чаще строки объединяют оператором +:

"Здравствуй," + " мир" + "!" 

Здравствуй мир! 

Давайте посмотрим на следующем примере.

Пример

public class Test < public static void main(String args[]) < String string1 = "отличным "; System.out.println("Я стану " + string1 + "программистом!"); >> 

Получим следующий результат:

Я стану отличным программистом! 

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

Мы уже изучали методы printf() и format() для вывода на печать с отформатированными числами. Класс строк в Java обладает эквивалентным методом format(), который возвращает строковый объект, а не потоковый объект (PrintStream).

Использование строкового статического метода format() позволяет создавать строку нужного формата, который можно использовать повторно, в отличие от одноразовых операторов print. Например вместо:

System.out.printf("Значение переменной float = " + "%f, пока значение integer " + "переменная = %d, и string " + "= %s", floatVar, intVar, stringVar); 

Вы также можете написать:

String fs; fs = String.format("Значение переменной float = " + "%f, пока значение integer " + "переменная = %d, и string " + "= %s", floatVar, intVar, stringVar); System.out.println(fs); 

Методы класса строк

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

№	Методы с описанием
1	char charAt(int index) Возвращает символ по указанному индексу.
2	int compareTo(Object o) Сравнивает данную строку с другим объектом.
3	int compareTo(String anotherString) Сравнивает две строки лексически.
4	int compareToIgnoreCase(String str) Сравнивает две строки лексически, игнорируя регистр букв.
5	String concat(String str) Объединяет указанную строку с данной строкой, путем добавления ее в конце.
6	boolean contentEquals(StringBuffer sb) Возвращает значение true только в том случае, если эта строка представляет собой ту же последовательность символов как указанно в буфере строки (StringBuffer).
7	static String copyValueOf(char[] data) Возвращает строку, которая представляет собой последовательность символов, в указанный массив.
8	static String copyValueOf(char[] data, int offset, int count) Возвращает строку, которая представляет собой последовательность символов, в указанный массив.
9	boolean endsWith(String suffix) Проверяет заканчивается ли эта строка указанным окончанием.
10	boolean equals(Object anObject) Сравнивает данную строку с указанным объектом.
11	boolean equalsIgnoreCase(String anotherString) Сравнивает данную строку с другой строкой, игнорируя регистр букв.
12	byte getBytes() Кодирует эту строку в последовательность байтов с помощью платформы charset, сохраняя результат в новый массив байтов.
13	byte[] getBytes(String charsetName Кодирует эту строку в последовательность байтов с помощью платформы charset, сохраняя результат в новый массив байтов.
14	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) Копирует символы из этой строки в массив символов назначения.
15	int hashCode() Возвращает хэш-код для этой строки.
16	int indexOf(int ch) Возвращает индекс первого вхождения указанного символа в данной строке.
17	int indexOf(int ch, int fromIndex) Возвращает индекс первого вхождения указанного символа в данной строке, начиная поиск с указанного индекса.
18	int indexOf(String str) Возвращает индекс первого вхождения указанной подстроки в данной строке.
19	int indexOf(String str, int fromIndex) Возвращает индекс первого вхождения указанной подстроки в данной строке, начиная с указанного индекса.
20	String intern() Возвращает каноническое представление для строкового объекта.
21	int lastIndexOf(int ch) Возвращает индекс последнего вхождения указанного символа в этой строке.
22	int lastIndexOf(int ch, int fromIndex) Возвращает индекс последнего вхождения указанного символа в этой строке, начиная обратный поиск с указанного индекса.
23	int lastIndexOf(String str) Возвращает индекс последнего вхождения указанной подстроки в данной строке.
24	int lastIndexOf(String str, int fromIndex) Возвращает индекс последнего вхождения указанной подстроки в этой строке, начиная обратный поиск с указанного индекса.
25	int length() Возвращает длину строки.
26	boolean matches(String regex) Сообщает, соответствует ли или нет эта строка заданному регулярному выражению.
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) Проверяет равны ли две области строки.
28	boolean regionMatches(int toffset, String other, int ooffset, int len) Проверяет равны ли две области строки.
29	String replace(char oldChar, char newChar) Возвращает новую строку, в результате, заменив все вхождения oldChar в этой строке на newChar.
30	String replaceAll(String regex, String replacement) Заменяет каждую подстроку строки, соответствующей заданному регулярному выражению с данной заменой.
31	String replaceFirst(String regex, String replacement) Заменяет первые подстроки данной строки, которая соответствует заданному регулярному выражению с данной заменой.
32	String[] split(String regex) Разделяет эту строку, окружая данным регулярным выражением.
33	String[] split(String regex, int limit) Разделяет эту строку, окружая данным регулярным выражением.
34	boolean startsWith(String prefix) Проверяет, начинается ли эта строка с заданного префикса.
35	boolean startsWith(String prefix, int toffset) Проверяет, начинается ли эта строка с указанного префикса, начиная с указанного индекса.
36	CharSequence subSequence(int beginIndex, int endIndex) Возвращает новую последовательность символов, которая является подпоследовательностью этой последовательности.
37	String substring(int beginIndex) Возвращает новую строку, которая является подстрокой данной строки.
38	String substring(int beginIndex, int endIndex) Возвращает новую строку, которая является подстрокой данной строки.
39	char[] toCharArray() Преобразует эту строку в новый массив символов.
40	String toLowerCase() Преобразует все символы в данной строке в нижний регистр, используя правила данного языкового стандарта.
41	String toLowerCase(Locale locale) Преобразует все знаки в данной строке в нижний регистр, используя правила данного языкового стандарта.
42	String toString() Этот объект (который уже является строкой!) возвращает себя.
43	String toUpperCase() Преобразует все символы в строке в верхний регистр, используя правила данного языкового стандарта.
44	String toUpperCase(Locale locale) Преобразует все символы в строке в верхний регистр, используя правила данного языкового стандарта.
45	String trim() Возвращает копию строки с пропущенными начальными и конечными пробелами.
46	static String valueOf(primitive data type x) Возвращает строковое представление переданного типа данных аргумента.

Оглавление

• 1. Java – Самоучитель для начинающих
• 2. Java – Обзор языка
• 3. Java – Установка и настройка
• 4. Java – Синтаксис
• 5. Java – Классы и объекты
• 6. Java – Конструкторы
• 7. Java – Типы данных и литералы
• 8. Java – Типы переменных
• 9. Java – Модификаторы
• 10. Java – Операторы
• 11. Java – Циклы и операторы цикла
• 11.1. Java – Цикл while
• 11.2. Java – Цикл for
• 11.3. Java – Улучшенный цикл for
• 11.4. Java – Цикл do..while
• 11.5. Java – Оператор break
• 11.6. Java – Оператор continue
• 12. Java – Операторы принятия решений
• 12.1. Java – Оператор if
• 12.2. Java – Оператор if..else
• 12.3. Java – Вложенный оператор if
• 12.4. Java – Оператор switch..case
• 12.5. Java – Условный оператор (? 🙂
• 13. Java – Числа
• 13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
• 13.2. Java – Метод compareTo()
• 13.3. Java – Метод equals()
• 13.4. Java – Метод valueOf()
• 13.5. Java – Метод toString()
• 13.6. Java – Метод parseInt()
• 13.7. Java – Метод Math.abs()
• 13.8. Java – Метод Math.ceil()
• 13.9. Java – Метод Math.floor()
• 13.10. Java – Метод Math.rint()
• 13.11. Java – Метод Math.round()
• 13.12. Java – Метод Math.min()
• 13.13. Java – Метод Math.max()
• 13.14. Java – Метод Math.exp()
• 13.15. Java – Метод Math.log()
• 13.16. Java – Метод Math.pow()
• 13.17. Java – Метод Math.sqrt()
• 13.18. Java – Метод Math.sin()
• 13.19. Java – Метод Math.cos()
• 13.20. Java – Метод Math.tan()
• 13.21. Java – Метод Math.asin()
• 13.22. Java – Метод Math.acos()
• 13.23. Java – Метод Math.atan()
• 13.24. Java – Метод Math.atan2()
• 13.25. Java – Метод Math.toDegrees()
• 13.26. Java – Метод Math.toRadians()
• 13.27. Java – Метод Math.random()
• 14. Java – Символы
• 14.1. Java – Метод Character.isLetter()
• 14.2. Java – Метод Character.isDigit()
• 14.3. Java – Метод Character.isWhitespace()
• 14.4. Java – Метод Character.isUpperCase()
• 14.5. Java – Метод Character.isLowerCase()
• 14.6. Java – Метод Character.toUpperCase()
• 14.7. Java – Метод Character.toLowerCase()
• 14.8. Java – Метод Character.toString()
• 15. Java – Строки
• 15.1. Java – Метод charAt()
• 15.2. Java – Метод compareTo()
• 15.3. Java – Метод compareToIgnoreCase()
• 15.4. Java – Метод concat()
• 15.5. Java – Метод contentEquals()
• 15.6. Java – Метод copyValueOf()
• 15.7. Java – Метод endsWith()
• 15.8. Java – Метод equals()
• 15.9. Java – Метод equalsIgnoreCase()
• 15.10. Java – Метод getBytes()
• 15.11. Java – Метод getChars()
• 15.12. Java – Метод hashCode()
• 15.13. Java – Метод indexOf()
• 15.14. Java – Метод intern()
• 15.15. Java – Метод lastIndexOf()
• 15.16. Java – Метод length()
• 15.17. Java – Метод matches()
• 15.18. Java – Метод regionMatches()
• 15.19. Java – Метод replace()
• 15.20. Java – Метод replaceAll()
• 15.21. Java – Метод replaceFirst()
• 15.22. Java – Метод split()
• 15.23. Java – Метод startsWith()
• 15.24. Java – Метод subSequence()
• 15.25. Java – Метод substring()
• 15.26. Java – Метод toCharArray()
• 15.27. Java – Метод toLowerCase()
• 15.28. Java – Метод toString()
• 15.29. Java – Метод toUpperCase()
• 15.30. Java – Метод trim()
• 15.31. Java – Метод valueOf()
• 15.32. Java – Классы StringBuilder и StringBuffer
• 15.32.1. Java – Метод append()
• 15.32.2. Java – Метод reverse()
• 15.32.3. Java – Метод delete()
• 15.32.4. Java – Метод insert()
• 15.32.5. Java – Метод replace()
• 16. Java – Массивы
• 17. Java – Дата и время
• 18. Java – Регулярные выражения
• 19. Java – Методы
• 20. Java – Потоки ввода/вывода, файлы и каталоги
• 20.1. Java – Класс ByteArrayInputStream
• 20.2. Java – Класс DataInputStream
• 20.3. Java – Класс ByteArrayOutputStream
• 20.4. Java – Класс DataOutputStream
• 20.5. Java – Класс File
• 20.6. Java – Класс FileReader
• 20.7. Java – Класс FileWriter
• 21. Java – Исключения
• 21.1. Java – Встроенные исключения
• 22. Java – Вложенные и внутренние классы
• 23. Java – Наследование
• 24. Java – Переопределение
• 25. Java – Полиморфизм
• 26. Java – Абстракция
• 27. Java – Инкапсуляция
• 28. Java – Интерфейсы
• 29. Java – Пакеты
• 30. Java – Структуры данных
• 30.1. Java – Интерфейс Enumeration
• 30.2. Java – Класс BitSet
• 30.3. Java – Класс Vector
• 30.4. Java – Класс Stack
• 30.5. Java – Класс Dictionary
• 30.6. Java – Класс Hashtable
• 30.7. Java – Класс Properties
• 31. Java – Коллекции
• 31.1. Java – Интерфейс Collection
• 31.2. Java – Интерфейс List
• 31.3. Java – Интерфейс Set
• 31.4. Java – Интерфейс SortedSet
• 31.5. Java – Интерфейс Map
• 31.6. Java – Интерфейс Map.Entry
• 31.7. Java – Интерфейс SortedMap
• 31.8. Java – Класс LinkedList
• 31.9. Java – Класс ArrayList
• 31.10. Java – Класс HashSet
• 31.11. Java – Класс LinkedHashSet
• 31.12. Java – Класс TreeSet
• 31.13. Java – Класс HashMap
• 31.14. Java – Класс TreeMap
• 31.15. Java – Класс WeakHashMap
• 31.16. Java – Класс LinkedHashMap
• 31.17. Java – Класс IdentityHashMap
• 31.18. Java – Алгоритмы Collection
• 31.19. Java – Iterator и ListIterator
• 31.20. Java – Comparator
• 32. Java – Дженерики
• 33. Java – Сериализация
• 34. Java – Сеть
• 34.1. Java – Обработка URL
• 35. Java – Отправка Email
• 36. Java – Многопоточность
• 36.1. Java – Синхронизация потоков
• 36.2. Java – Межпоточная связь
• 36.3. Java – Взаимная блокировка потоков
• 36.4. Java – Управление потоками
• 37. Java – Основы работы с апплетами
• 38. Java – Javadoc

Класс String

Класс String поддерживает несколько конструкторов, например:

• String(),
• String(String str),
• String(byte[] asciichar),
• String(char[] unicodechar),
• String(StringBuffer sbuf),
• String(StringBuilder sbuild) и др.

Для нахождения длины строки используется метод length() .

Рассмотрим разные варианты создания строк:

public class StringDemo1 < public static void main(String[] args) < String str1 = new String(); System.out.println("str1:[" + str1 + "]"); char[] chars1 = ; String str2 = new String(chars1); System.out.println("str2:" + str2); char[] chars2 = ; String str3 = new String(chars2, 2, 3); System.out.println("str3:" + str3); String str4 = "abc"; System.out.println("str4:" + str4); System.out.println("str4.length:" + str4.length()); System.out.println("abc.length:" + "abc".length()); String str5 = new String(str4); System.out.println("str5:" + str5); > >

В следующем примере показано, как создавать строки из массива типа byte :

public class StringDemo2 < public static void main(String[] args) < byte[] bytes = ; String s1 = new String(bytes); System.out.println(s1); String s2 = new String(bytes, 2, 3); System.out.println(s2); > >

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

Для сравнения строк используются методы equals() и equalsIgnoreCase() , который не учитывает регистр символов:

public class EqualsDemo < public static void main(String[] args) < String s1 = "Hello"; String s2 = "Hello"; String s3 = "Good-bye"; String s4 = "HELLO"; System.out.println(s1 + " equals " + s2 + " ->" + s1.equals(s2)); System.out.println(s1 + " equals " + s3 + " -> " + s1.equals(s3)); System.out.println(s1 + " equals " + s4 + " -> " + s1.equals(s4)); System.out.println(s1 + " equalsIgnoreCase " + s4 + " -> " + s1.equalsIgnoreCase(s4)); > >

В Java существует так называемый String Pool, в котором хранятся созданные строки. При создании очередной строки, JVM сначала ищет такую строку в String Pool. Если такая строка уже есть, то она возвращается вместо создания новой.

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

Следующий пример демонстрирует сравнение строк с помощью == и метода equals() :

public class EqualStrings < public static void main(String[] args) < String s1 = "Java"; String s2 = "Java"; String s3 = new String("Java"); String s4 = new String(s1); System.out.println("s1==s2 : " + (s1 == s2)); System.out.println("s3==s4 : " + (s3 == s4)); System.out.println("s1==s3 : " + (s1 == s3)); System.out.println("s1 equals s2 : " + s1.equals(s2)); System.out.println("s1 equals s3 : " + s1.equals(s3)); >>

3. Сравнение подстрок

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

• Метод regionMatches() используется для сравнения подстроки в исходной строке с подстрокой в строке параметре.
• Метод startsWith() проверяет, начинается ли данная подстрока фрагментом, переданным методу в качестве параметра.
• Метод endsWith() проверяет, совпадает ли с параметром конец строки.
• Метод contains() проверяет, входит ли подстрока в строку.

public class StringDemo5 < public static void main(String[] args) < System.out.println("Foobar".endsWith("bar")); System.out.println("Foobar".startsWith("Foo")); System.out.println("Foobar".contains("oo")); System.out.println("Hello world. ".regionMatches(6, "world", 0, 3)); >>

4. Метод compareTo()

Зачастую бывает недостаточно просто знать, являются ли две строки идентичными. Для приложений, в которых требуется сортировка, нужно знать, какая из двух строк меньше другой. Для ответа на этот вопрос нужно воспользоваться методом compareTo(str) класса String .

Если результат метода меньше нуля — вызывающая строка меньше str . Больше нуля — вызывающая строка больше str . Ноль — две строки эквивалентны.

Следующий пример показывает сортировку строкового массива с помощью пузырька:

public class SortString < private static String[] array = < "Для", "работы", "со", "строками", "в", "языке", "Java", "используются", "классы", "String", "StringBuilder", "StringBuffer" >; public static void main(String[] args) < for (int j = 0; j < array.length; j++) < for (int i = j + 1; i < array.length; i++) < if (array[i].compareTo(array[j]) < 0) < String t = array[j]; array[j] = array[i]; array[i] = t; >> > System.out.println(Arrays.toString(array)); > >

5. Извлечение символов – метод charAt()

Извлечение символов осуществляется с помощью метода charAt() класса String :

public class StringDemo3 < public static void main(String[] args) < char ch = "аbс".charAt(1); System.out.println(ch); >>

6. Поиск подстроки или символа в строке в Java

В класс String включена поддержка поиска определенного символа или подстроки, для этого в нем имеются два метода — indexOf() и lastIndexOf() .

indexOf() — ищет первое вхождение символа или подстроки.

lastlndexOf() — ищет последнее вхождение символа или подстроки.

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

Чтобы найти первое или последнее вхождение символа, применяйте:

int indexOf(char ch) int lastlndexOf(char ch) 

Здесь ch символ, который нужно искать. Чтобы найти первое или последнее вхождение подстроки, применяйте:

int indexOf(String str) int lastlndexOf(String str)

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

int indexOf(int ch, int startIndex) int lastlndexOf(int ch, int startIndex) int indexOf(String str, int startIndex) int lastlndexOf(String str, int startIndex)

Рассмотрим применение этих методов на следующем примере:

public class IndexOfDemo < public static void main(String[] args) < String s = "Для работы со строками в языке Java используются " + "классы String, StringBuilder, StringBuffer."; System.out.println(s); System.out.println("indexOf(S) = " + s.indexOf('S')); System.out.println("lastIndexOf(r) = " + s.lastIndexOf('r')); System.out.println("indexOf(String) = " + s.indexOf("String")); System.out.println("lastIndexOf(String) = " + s.lastIndexOf("String")); System.out.println("indexOf(S, 60) = " + s.indexOf('S', 60)); System.out.println("lastIndexOf(S, 70) header7">7. Методы concat(), replace(), toLowerCase(), toUpperCase(), trim() 
Метод concat() используется для объединения двух строк.
 
Метод replace() заменяет один символ на другой.
 
Методы toLowerCase() и toUpperCase() приводят строку к верхнему или нижнему регистру.
 
public class ModifyStringDemo < public static void main(String[] args) < System.out.println("Hello".concat(" World")); System.out.println("Hello".replace('l', 'w')); System.out.println("Hello".toLowerCase()); System.out.println("Hello".toUpperCase()); System.out.println(" Hello World ".trim()); >>
8. Преобразование данных с помощью valueOf()
Если Вы имеете дело с каким-либо типом данных и хотите вывести значение этого типа в удобочитаемом виде, сначала придется преобразовать это значение в текстовую строку. Для этого существует метод valueOf() .
Такой статический метод определен для любого существующего в Java типа данных. Благодаря этому не составляет труда преобразовать в строку значение любого типа.
static String valueOf(double num) static String valueOf(long num) static String valueOf(Object оb) static String valueOf(char[] chars)
9. Метод substring()
Метод substring() вырезает подстроку из строки, используя указанные позиции. Существует два варианта этого метода. Первый вариант вырезает от указанной позиции и до конца. Второй - от первой позиции до второй. Символ, находящийся в первой позиции, будет включен в результирующую строку. А последний - нет.
public class SubstringDemo < public static void main(String[] args) < System.out.println("Welcome to Kharkiv. ".substring(10)); System.out.println("Welcome to Kharkiv. ".substring(10, 18)); >>
10. Соединение символьных строк
В версию JDK 8 в класс String был внедрен новый метод join(), предназначенный для соединения двух и более символьных строк, разграничиваемых указанным разделителем, например, пробелом или запятой:
public class StringJoinDemo < public static void main(String[] args) < String result = String.join(":", "foobar", "foo", "bar"); System.out.println(result); >>
11. Методы isEmpty(), isBlank()
Метод isEmpty() проверяет пустая ли строка. Возвращает true , только если длина строки равна 0.
Метод isBlank() возвращает true , если строка пуста или содержит только пробелы (Java 11).
public class StringEmpty < public static void main(String[] args) < System.out.println("".isEmpty()); System.out.println(" ".isEmpty()); System.out.println(" ".isBlank()); >>
Обработка строк в Java. Часть I: String, StringBuffer, StringBuilder
Что вы знаете о обработке строк в Java? Как много этих знаний и насколько они углублены и актуальны? Давайте попробуем вместе со мной разобрать все вопросы, связанные с этой важной, фундаментальной и часто используемой частью языка. Наш маленький гайд будет разбит на две публикации:

String, StringBuffer, StringBuilder (реализация строк)
Pattern, Matcher (регулярные выражения)

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

использование строк в многопоточных средах (String является потокобезопасным (thread-safe) )
использование String Pool (это коллекция ссылок на String объекты, используется для оптимизации памяти)
использование строк в качестве ключей в HashMap (ключ рекомендуется делать неизменяемым)

Создание
Мы можем создать объект класса String несколькими способами:
1. Используя строковые литералы:
String habr = "habrahabr"; 
Строковый литерал — последовательность символов заключенных в двойные кавычки. Важно понимать, что всегда когда вы используете строковой литерал компилятор создает объект со значением этого литерала:
System.out.print("habrahabr"); // создали объект и вывели его значение 
2. С помощью конструкторов:
String habr = "habrahabr"; char[] habrAsArrayOfChars = ; byte[] habrAsArrayOfBytes = ; String first = new String(); String second = new String(habr); 
Если копия строки не требуется явно, использование этих конструкторов нежелательно и в них нет необходимости, так как строки являются неизменными. Постоянное строительство новых объектов таким способом может привести к снижению производительности. Их лучше заменить на аналогичные инициализации с помощью строковых литералов.
String third = new String(habrAsArrayOfChars); // "habrahabr" String fourth = new String(habrAsArrayOfChars, 0, 4); // "habr" 
Конструкторы могут формировать объект строки с помощью массива символов. Происходит копирование массива, для этого используются статические методы copyOf и copyOfRange (копирование всего массива и его части (если указаны 2-й и 3-й параметр конструктора) соответственно) класса Arrays, которые в свою очередь используют платформо-зависимую реализацию System.arraycopy.
String fifth = new String(habrAsArrayOfBytes, Charset.forName("UTF-16BE")); // кодировка нам явно не подходит "桡扲慨慢�" 
Можно также создать объект строки с помощью массива байтов. Дополнительно можно передать параметр класса Charset, что будет отвечать за кодировку. Происходит декодирование массива с помощью указанной кодировки (если не указано — используется Charset.defaultCharset(), который зависит от кодировки операционной системы) и, далее, полученный массив символов копируется в значение объекта.
String sixth = new String(new StringBuffer(habr)); String seventh = new String(new StringBuilder(habr)); 
Ну и наконец-то конструкторы использующие объекты StringBuffer и StringBuilder, их значения (getValue()) и длину (length()) для создания объекта строки. С этими классами мы познакомимся чуть позже.
Приведены примеры наиболее часто используемых конструкторов класса String, на самом деле их пятнадцать (два из которых помечены как deprecated).
Длина
Важной частью каждой строки есть ее длина. Узнать ее можно обратившись к объекту String с помощью метода доступа (accessor method) length(), который возвращает количество символов в строке, например:
public static void main(String[] args) < String habr = "habrahabr"; // получить длину строки int length = habr.length(); // теперь можно узнать есть ли символ символ 'h' в "habrahabr" char searchChar = 'h'; boolean isFound = false; for (int i = 0; i < length; ++i) < if (habr.charAt(i) == searchChar) < isFound = true; break; // первое вхождение >> System.out.println(message(isFound)); // Your char had been found! // ой, забыл, есть же метод indexOf System.out.println(message(habr.indexOf(searchChar) != -1)); // Your char had been found! > private static String message(boolean b)
Конкатенация
Конкатенация — операция объединения строк, что возвращает новую строку, что есть результатом объединения второй строки с окончанием первой. Операция для объекта String может быть выполнена двумя способами:
1. Метод concat
String javaHub = "habrhabr".concat(".ru").concat("/hub").concat("/java"); System.out.println(javaHub); // получим "habrhabr.ru/hub/java" // перепишем наш метод используя concat private static String message(boolean b)
Важно понимать, что метод concat не изменяет строку, а лишь создает новую как результат слияния текущей и переданной в качестве параметра. Да, метод возвращает новый объект String, поэтому возможны такие длинные «цепочки».
2. Перегруженные операторы "+" и "+="
String habr = "habra" + "habr"; // "habrahabr" habr += ".ru"; // "habrahabr.ru" 
Это одни с немногих перегруженных операторов в Java — язык не позволяет перегружать операции для объектов пользовательских классов. Оператор "+" не использует метод concat, тут используется следующий механизм:
String habra = "habra"; String habr = "habr"; // все просто и красиво String habrahabr = habra + habr; // а на самом деле String habrahabr = new StringBuilder()).append(habra).append(habr).toString(); // может быть использован StringBuffer 
Используйте метод concat, если слияние нужно провести только один раз, для остальных случаев рекомендовано использовать или оператор "+" или StringBuffer / StringBuilder. Также стоит отметить, что получить NPE (NullPointerException), если один с операндов равен null, невозможно с помощью оператора "+" или "+=", чего не скажешь о методе concat, например:
String string = null; string += " habrahabr"; // null преобразуется в "null", в результате "null habrahabr" string = null; string.concat("s"); // логично что NullPointerException 
Форматирование
Класс String предоставляет возможность создания форматированных строк. За это отвечает статический метод format, например:
String formatString = "We are printing double variable (%f), string ('%s') and integer variable (%d)."; System.out.println(String.format(formatString, 2.3, "habr", 10)); // We are printing double variable (2.300000), string ('habr') and integer variable (10). 
Методы
Благодаря множеству методов предоставляется возможность манипулирования строкой и ее символами. Описывать их здесь нет смысла, потому что Oracle имеет хорошие статьи о манипулировании и сравнении строк. Также у вас под рукой всегда есть их документация. Хотелось отметить новый статический метод join, который появился в Java 8. Теперь мы можем удобно объединять несколько строк в одну используя разделитель (был добавлен класс java.lang.StringJoiner, что за него отвечает), например:
String hello = "Hello"; String habr = "habrahabr"; String delimiter = ", "; System.out.println(String.join(delimiter, hello, habr)); // или так System.out.println(String.join(delimiter, new ArrayList(Arrays.asList(hello, habr)))); // в обоих случаях "Hello, habrahabr" 
Это не единственное изменение класса в Java 8. Oracle сообщает о улучшении производительности в конструкторе String(byte[], *) и методе getBytes().
Преобразование
1. Число в строку
int integerVariable = 10; String first = integerVariable + ""; // конкатенация с пустой строкой String second = String.valueOf(integerVariable); // вызов статического метода valueOf класса String String third = Integer.toString(integerVariable); // вызов метода toString класса-обертки 
2. Строку в число
String string = "10"; int first = Integer.parseInt(string); /* получаем примитивный тип (primitive type) используя метод parseXхх нужного класса-обертки, где Xxx - имя примитива с заглавной буквы (например parseInt) */ int second = Integer.valueOf(string); // получаем объект wrapper класса и автоматически распаковываем 
StringBuffer
Строки являются неизменными, поэтому частая их модификация приводит к созданию новых объектов, что в свою очередь расходует драгоценную память. Для решения этой проблемы был создан класс java.lang.StringBuffer, который позволяет более эффективно работать над модификацией строки. Класс является mutable, то есть изменяемым — используйте его, если Вы хотите изменять содержимое строки. StringBuffer может быть использован в многопоточных средах, так как все необходимые методы являются синхронизированными.
Создание
Существует четыре способа создания объекта класса StringBuffer. Каждый объект имеет свою вместимость (capacity), что отвечает за длину внутреннего буфера. Если длина строки, что хранится в внутреннем буфере, не превышает размер этого буфера (capacity), то нет необходимости выделять новый массив буфера. Если же буфер переполняется — он автоматически становиться больше.
StringBuffer firstBuffer = new StringBuffer(); // capacity = 16 StringBuffer secondBuffer = new StringBuffer("habrahabr"); // capacity = str.length() + 16 StringBuffer thirdBuffer = new StringBuffer(secondBuffer); // параметр - любой класс, что реализует CharSequence StringBuffer fourthBuffer = new StringBuffer(50); // передаем capacity 
Модификация
В большинстве случаев мы используем StringBuffer для многократного выполнения операций добавления (append), вставки (insert) и удаления (delete) подстрок. Тут все очень просто, например:
String domain = ".ru"; // создадим буфер с помощью String объекта StringBuffer buffer = new StringBuffer("habrahabr"); // "habrahabr" // вставим домен в конец buffer.append(domain); // "habrahabr.ru" // удалим домен buffer.delete(buffer.length() - domain.length(), buffer.length()); // "habrahabr" // вставим домен в конец на этот раз используя insert buffer.insert(buffer.length(), domain); // "habrahabr.ru" 
Все остальные методы для работы с StringBuffer можно посмотреть в документации.
StringBuilder
StringBuilder — класс, что представляет изменяемую последовательность символов. Класс был введен в Java 5 и имеет полностью идентичный API с StringBuffer. Единственное отличие — StringBuilder не синхронизирован. Это означает, что его использование в многопоточных средах есть нежелательным. Следовательно, если вы работаете с многопоточностью, Вам идеально подходит StringBuffer, иначе используйте StringBuilder, который работает намного быстрее в большинстве реализаций. Напишем небольшой тест для сравнения скорости работы этих двух классов:
public class Test < public static void main(String[] args) < try < test(new StringBuffer("")); // StringBuffer: 35117ms. test(new StringBuilder("")); // StringBuilder: 3358ms. >catch (java.io.IOException e) < System.err.println(e.getMessage()); >> private static void test(Appendable obj) throws java.io.IOException < // узнаем текущее время до теста long before = System.currentTimeMillis(); for (int i = 0; i++ < 1e9; ) < obj.append(""); >// узнаем текущее время после теста long after = System.currentTimeMillis(); // выводим результат System.out.println(obj.getClass().getSimpleName() + ": " + (after - before) + "ms."); > > 
Спасибо за внимание. Надеюсь статья поможет узнать что-то новое и натолкнет на удаление всех пробелов в этих вопросах. Все дополнения, уточнения и критика приветствуются.