Что означает string в java
Перейти к содержимому

Что означает string в java

  • автор:

Класс 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 не используется, если строка создается с помощью конструктора. В этом случае гарантированно создается новый объект:

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()); >>

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

Строки в Java, методы класса String

Для работы со строками в Java существует класс String. И для объявления новой строки можно использовать один из способов:

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 – это кол-во символов. То есть, строка str4 содержит строку «come».

Важной особенностью строк в Java является их неизменяемость. Это значит, что в строке нельзя попросту изменить какой-либо символ и получить другую строку. Все строки создаются и существуют в неизменном виде, пока не будут уничтожены (как правило, автоматически сборщиком мусора). А переменные str1, str2, str3 и str4 следует воспринимать лишь как ссылки на эти строки. То есть, в любой момент в программе можно записать такую конструкцию:

str1 = str3;

что означает изменение ссылки str1 на строку «hello», на которую указывает ссылка str3. Соответственно, если на первую строку «Java» не будет указывать никакая ссылка, то она автоматически уничтожается.

У класса String есть несколько полезных методов:

Разберем работу часто используемых методов класса String. Первый метод, как написано, возвращает длину строки. Например, если нам дана вот такая строка

String str1 = "Java";

то метод length() вернет значение 4

System.out.println(str1.length()); // 4

Далее, если к строке str2

String str2 = "Hello World!";

применить метод toCharArray():

char[] helloArray = str1.toCharArray();

то получим массив символов с содержимым этой строки. Следующий пример. У нас есть пустая строка

тогда мы можем определить это, например, так:

if(s.length() == 0) System.out.println("String is empty");
if(s isEmpty()) System.out.println("String is empty");

Но, если строка задана вот так:

String s = null;

то это означает, что ссылка s не указывает ни на какой класс String и, соответственно, мы не можем вызывать методы этого класса. В этом случае проверку следует делать так:

if(s != null && s.length() == 0) System.out.println("String is empty");

мы здесь сначала проверяем: указывает ли ссылка s на объект класса и если это так, то только потом будет идти обращение к методу length().

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

Для соединения строк можно использовать операцию сложения ("+"):

String str1 = "Java"; String str2 = "Hello"; String str3 = str1 + " " + str2; System.out.println(str3); // Hello Java

При этом если в операции сложения строк используется не строковый объект, например, число, то этот объект преобразуется к строке:

String str4 = "Год " + 2015;

Еще один метод объединения - метод join() позволяет объединить строки с учетом разделителя. Например, две строки

String str1 = "Java"; String str2 = "Hello";

будут сливаться в одно слово "HelloJava", если их объединить с помощью оператора +:

String str3 = str1 + str2;

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

String str3 = String.join(" ", str2, str1); // Hello Java

В общем случае вместо пробела здесь можно ставить любой разделитель в виде строки.

Обратите внимание, что каждый раз при объединении строк мы получали новую строку как результат объединения.

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

Для извлечения символов по индексу в классе String определен метод

char charAt(int index)

Он принимает индекс, по которому надо получить символов, и возвращает извлеченный символ:

String str = "Java"; char c = str.charAt(2); System.out.println(c); // v

(здесь как и в массивах первый индекс равен 0).

Если надо извлечь сразу группу символов или подстроку, то можно использовать метод

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

  • srcBegin: индекс строки, с которого начинается извлечение символов;
  • srcEnd: индекс строки, до которого идет извлечение символов;
  • dst: массив символов, в который будут извлекаться символы;
  • dstBegin: индекс массива dst, с которого надо добавлять извлеченные из строки символы.
String str = "Hello world!"; int start = 6; int end = 11; char[] dst=new char[end - start]; str.getChars(start, end, dst, 0); System.out.println(dst); // world

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

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

String str1 = "Hello"; String str2 = "hello"; System.out.println(str1.equals(str2)); // false System.out.println(str1.equalsIgnoreCase(str2)); // true

Обратите внимание, что в отличие сравнения числовых и других данных примитивных типов для сравнения строк не рекомендуется использовать оператор ==. То есть, записывать вот такое сравнение лучше не использовать:

if(str1 == str2) System.out.println("Сроки равны");

(хотя, оно тоже будет работать). Вместо этого следует использовать метод equals() класса String. Другая пара методов: int compareTo(String str) и int compareToIgnoreCase(String str) также сравнивают строки между собой, но в отличие от equals() они еще позволяют узнать больше ли одна строка другой или нет. Если возвращаемое значение этих методов больше 0, то первая строка больше второй, если меньше нуля, то, наоборот, вторая больше первой. Если строки равны, то возвращается 0. Для определения больше или меньше одна строка, чем другая, используется лексикографический порядок. То есть, например, строка "A" меньше, чем строка "B", так как символ 'A' в алфавите стоит перед символом 'B'. Если первые символы строк равны, то в расчет берутся следующие символы. Например:

String str1 = "hello"; String str2 = "world"; String str3 = "hell"; System.out.println(str1.compareTo(str2)); // -15 - str1 меньше чем str2 System.out.println(str1.compareTo(str3)); // 1 - str1 больше чем str3 System.out.println(str1.compareTo(str1)); // 0 - str1 равна str1
  • ignoreCase: надо ли игнорировать регистр символов при сравнении (если значение true, то регистр игнорируется);
  • toffset: начальный индекс в вызывающей строке, с которого начнется сравнение;
  • other: строка, с которой сравнивается вызывающая;
  • oofset: начальный индекс в сравниваемой строке, с которого начнется сравнение;
  • len: количество сравниваемых символов в обеих строках.
String str1 = "Hello world"; String str2 = "I work"; boolean result = str1.regionMatches(6, str2, 2, 3); System.out.println(result); // true

Поиск в строке

Метод indexOf() находит индекс первого вхождения подстроки в строку, а метод lastIndexOf() - индекс последнего вхождения. Если подстрока не будет найдена, то оба метода возвращают -1:

String str = "Hello world"; int index1 = str.indexOf('l'); // 2 int index2 = str.indexOf("wo"); //6 int index3 = str.lastIndexOf('l'); //9 System.out.println(index1+" "+index2+" "+index3);

Метод startsWith() позволяют определить начинается ли строка с определенной подстроки, а метод endsWith() позволяет определить заканчивается строка на определенную подстроку:

String str = "myfile.exe"; boolean start = str.startsWith("my"); //true boolean end = str.endsWith("exe"); //true System.out.println(start+" "+end);

Замена в строке

Метод replace() позволяет заменить в строке одну последовательность символов на другую:

String str = "Hello world"; String replStr1 = str.replace('l', 'd'); // Heddo wordd String replStr2 = str.replace("Hello", "Bye"); // Bye world System.out.println(replStr1); System.out.println(replStr2);

Обрезка строк

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

String str = " hello world "; str = str.trim(); // hello world System.out.println(str);

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

String str = "Hello world"; String substr1 = str.substring(6); // world String substr2 = str.substring(3,5); //lo System.out.println(substr1); System.out.println(substr2);

Изменение регистра

Метод toLowerCase() переводит все символы строки в нижний регистр, а метод toUpperCase() - в верхний:

String str = "Hello World"; System.out.println(str.toLowerCase()); // hello world System.out.println(str.toUpperCase()); // HELLO WORLD

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

Метод split() позволяет разбить строку на подстроки по определенному разделителю. Разделитель – это какой-нибудь символ или набор символов (передается в качестве параметра). Например, разобьем текст на отдельные слова (учитывая, что слова разделены пробелом):

String text = "Я люблю язык Java!"; String[] words = text.split(" "); for(String word : words) System.out.println(word);

Строки в Java (class java.lang.String)

Java-университет

Путь программиста – сложный и долгий процесс. И в большинстве случаев начинается он с программы, которая выводит Hello World на экран. Java не исключение (см. Lesson: The "Hello World!" Application). Как мы видим, вывод сообщения осуществляется при помощи System.out.println("Hello World!"); Если посмотреть в Java API, то метод System.out.println принимает входным параметром String. Про этот тип данных и пойдёт речь.

String как последовательность символов

Собственно, String в переводе с английского – строка. Так и есть, тип String представляет текстовую строку. А чем же является текстовая строка? Текстовая строка - это какая-то упорядоченная последовательность символов, которые идут друг за другом. Символ – char. Последовательность – sequence. Так что да, абсолютно правильно, String является реализацией java.lang.CharSequence . А если заглянуть внутрь самого класса String, то внутри него ничто иное как массив char’ов: private final char value[]; У java.lang.CharSequence довольно простой контракт:

Строки в Java (class java.lang.String) - 1

У нас есть метод получения количества элементов, получения конкретного элемента и получения набора элементов + непосредственно сам метод toString, который вернёт this) Интереснее разобраться в методах, которые пришли к нам в Java 8, а это: chars() и codePoints() Вспоминаем по Tutorial от Oracle «Primitive Data Types», что char - это single 16-bit Unicode character .То есть по сути char это просто тип размером в половину типа int (32 бита), который представляет числа от 0 до 65535 (см. decimal значения в ASCII Table). То есть при желании мы можем char представить в виде int. И в Java 8 этим воспользовались. Начиная с 8 версии Java у нас появляется IntStream - стрим для работы с примитивными int'ами. Поэтому в charSequence есть возможность получить IntStream, представляющий или char’ы или codePoint’ы. Прежде чем перейдём к ним, увидим пример, чтобы показать всё удобство этого подхода. Воспользуемся Tutorialspoint online java compiler’ом и выполним код:

 public static void main(String []args)

Теперь таким незамысловатым способом можно получить кол-во уникальных символов.

CodePoints

Итак, про chars мы увидели. Теперь непонятно, что за code points такие. Понятие codePoint появилось потому, что когда Java появилась, то хватало 16 бит (половина int) чтобы закодировть символ. Поэтому char в java представлен в UTF-16 формате ("Unicode 88" specification). Позже повяился Unicode 2.0, концепция которого заключалась в представлении символа в виде сурогатной пары (2 чаров). Это позволило расширить диапазон возможных значений до значения int. Подробнее см. на stackoverflow: "Comparing a char to a code-point?". Про UTF-16 так же указано и в JavaDoc к Character . Там же, в JavaDoc, сказано, что: In this representation, supplementary characters are represented as a pair of char values, the first from the high-surrogates range, (\uD800-\uDBFF), the second from the low-surrogates range (\uDC00-\uDFFF). На стандартных алфавитах довольно трудно (а может даже нельзя) воспроизвести это. Но символы буквами и цифрами не заканчиваются. В японии придумали такую сложную для кодировок штуку, как emoji - язык идеограмм и смайликов. Есть про это интересная статья на википедии: «Эмодзи». Найдём пример emoji, например такой: «Emoji Ghost». Как мы видим, там даже указан тот самый codePoint (значение = U+1F47B). Указан он в шестнадцатеричном формате. Если перевести в десятичное число, то получим 128123. Это больше, чем позволяет 16 бит (т.е. больше чем 65535). Скопируем его:

Строки в Java (class java.lang.String) - 2

К сожалению, платформа JavaRush не поддерживает такие символы в тексте. Поэтому, в пример ниже нужно будет в String вставить значение. Поэтому, теперь нам будет понятен простой тест:

 public static void main(String []args) < String emojiString = "Вставте сюда эмоджи через ctrl+v"; //На один emojiString приходится 2 чара (т.к. не влезает в 16 бит) System.out.println(emojiString.codePoints().count()); //1 System.out.println(emojiString.chars().count()); //2 >

Как видно, в данном случае 1 codePoint идёт за 2 char’а. Вот такая вот магия.

Character

Как мы увидели выше, String’и в Java состоят из char. Примитивный тип позволяет хранить значение, а вот обёртка java.lang.Character над примитивным типом позволяет сделать много полезного с этим символом. Например, мы можем перевести строку в верхний регистр:

 public static void main(String[] args) < String line = "организация объединённых наций"; char[] chars = line.toCharArray(); for (int i = 0; i < chars.length; i++) < if (i == 0 || chars[i - 1] == ' ') < chars[i] = Character.toUpperCase(chars[i]); >> System.out.println(new String(chars)); > 

Ну и разные интересности: isAlphabetic() , isLetter() , isSpaceChar() , isDigit() , isUpperCase() , isMirrored() (например, скобки. '(' имеет зеркальное отражение ')').

String Pool

Строки в Java неизменяемы, то есть константны. В том числе об этом указано в самом JavaDoc класса java.lang.String. Второе и тоже очень важное – строки могут задаваться литералами:

 String literalString = "Hello, World!"; String literalString = "Hello, World!"; 
  • Не будут создаваться однотипные объекты
  • Сравнение по ссылке быстрее, чем посимвольное сравнение через equals
 public static void main(String[] args)

Как видите, строки одинаковые, но результат будет false. А всё потому, что == сравнивает не по значению, а по ссылке. А вот так работает:

 public static void main(String[] args)

Только заметим, что new String всё равно мы сделаем. То есть intern нам вернёт String из кэша, а вот изначальный String, по которому мы искали в кэше, будет выброшен на очистку, т.к. никто больше про него не знает. На лицо лишнее потребление ресурсов =( Поэтому, сравнивать строки нужно всегда через equals, чтобы уйти по возможности от внезапных и трудно определяемых ошибок.

 public static void main(String[] args)

Equals выполняет посимвольное сравнивание строк.

Конкатенация

Как мы помним, строки можно складывать. И как мы помним строки у нас неизменяемы. Так как же тогда это работает? Всё верно, создаётся новая строка, которая состоит из символов складываемых объектов. Существует миллион версий о том, как работает конкатенация через плюс. Кто-то считает что будет каждый раз новый объект, кто-то считает что будет ещё что-то. Но прав может быть кто-то один. И этот кто-то – компилятор javac. Воспользуемся сервисом онлайн компилятора и выполним:

 public class HelloWorld < public static void main(String[] args) < String helloMessage = "Hello, "; String target = "World"; System.out.println(helloMessage + target); >> 

Теперь сохраним это как zip архив, извлечём в каталог и выполним: javap –c HelloWorld И тут мы всё узнаем:

Строки в Java (class java.lang.String) - 3

В цикле, конечно, лучше делать конкатенацию через StringBuilder самим. И не потому что какая-то магия, а чтобы StringBuilder создавался до цикла, а в самом цикле происходил только append. Кстати, тут есть ещё одна интересность. Есть отличная статья: «Обработка строк в Java. Часть I: String, StringBuffer, StringBuilder». Много полезного в комментариях. Например, указано, что при конкатенации вида new StringBuilder().append(). toString() действует intrinsic оптимизация, регулируемая опцией -XX:+OptimizeStringConcat, которая по умолчанию включена. intrinsic - переводится как "внутренний". Такие вещи JVM обрабатывает особенным образом, обрабатывая их как Native, только без дополнительных затрат на JNI. Подробнее: "Intrinsic Methods in HotSpot VM".

StringBuilder и StringBuffer

Как мы выше видели, StringBuilder очень полезный инструмент. Строки являются immutable, т.е. неизменяемыми. А складывать хочется. Поэтому, нам в помощь даны 2 класса: StringBuilder и StringBuffer. Основное отличие между ними в том, что StringBuffer появился в JDK1.0, в то время как StringBuilder пришёл в java 1.5 как не синхронизированная версия StringBuffer, чтобы снять повышенные затраты на ненужную синхронизацию методов. Оба эти классы являются реализацией абстрактного класса AbstractStringBuilder - A mutable sequence of characters. Внутри хранится массив чаров, который расширяется по правилу: value.length * 2 + 2. По умолчанию размер (capacity) у StringBuilder'а равен 16.

Comparable

Строки являются comparable, т.е. реализуют метод compareTo. Выполняется это при помощи посимвольного сравнения. Интересно, что из двух строк выбирается минимальная длинна и по ней выполняется цикл. Поэтому, compareTo вернёт или разницу между int значениями первых несовпавших символов в пределе наименьшей из длинн строк, либо вернёт разницу между длиннами строк, если в пределах минимальной длинны строки все символы совпадают. Такое сравнение называется «лексикографическим».

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

String имеет множество полезных методов:

Строки в Java (class java.lang.String) - 4

На работу со строками сущесвует множество задач. Например, на Coding Bat. Так же есть курс на coursera: "Algorithms on Strings".

Заключение

Даже небольшой обзор данного класса занимает внушительное место. А это ещё не всё. Настоятельно рекомендую к просмотру доклад с JPoint 2015 года: Алексей Шипилёв — Катехизис java.lang.String

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *