Java

Введение в строки. Класс String

Последнее обновление: 31.10.2018

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

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


public static void main(String[] args) {
        
    String str1 = "Java";
    String str2 = new String(); // пустая строка
    String str3 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
    String str4 = new String(new char[]{'w', 'e', 'l', 'c', 'o', 'm', 'e'}, 3, 4);//3 -начальный индекс, 4 -кол-во символов
        
    System.out.println(str1); // Java
    System.out.println(str2); //
    System.out.println(str3); // hello
    System.out.println(str4); // come
}

При работе со строками важно понимать, что объект String является неизменяемым (immutable). То есть при любых операциях над строкой, которые изменяют эту строку, фактически будет создаваться новая строка

Поскольку строка рассматривается как набор символов, то мы можем применить метод length() для нахождения длины строки или длины набора символов:

String str1 = "Java";
System.out.println(str1.length()); // 4

А с помощью метода toCharArray() можно обратно преобразовать строку в массив символов:

String str1 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
char[] helloArray = str1.toCharArray();

Строка может быть пустой. Для этого ей можно присвоить пустые кавычки или удалить из стоки все символы:

String s = "";   // строка не указывает на объект
if(s.length() == 0) System.out.println("String is empty");

В этом случае длина строки, возвращаемая методом length(), равна 0.

Класс String имеет специальный метод, который позволяет проверить строку на пустоту — isEmpty(). Если строка пуста, он возвращает true:

String s = "";   // строка не указывает на объект
if(s.length() == 0) System.out.println("String is empty");

Переменная String может не указывать на какой-либо объект и иметь значение null:

String s = null;   // строка не указывает на объект
if(s == null) System.out.println("String is null");

Значение null не эквивалентно пустой строке. Например, в следующем случае мы столкнемся с ошибкой выполнения:

String s = null;   // строка не указывает на объект
if(s.length()==0) System.out.println("String is empty");	// ! Ошибка

Так как переменная не указывает ни на какой объект String, то соответственно мы не можем обращаться к методам объекта String. Чтобы избежать подобных ошибок, можно предварительно проверять строку на null:

String s = null;   // строка не указывает на объект
if(s!=null && s.length()==0) System.out.println("String is empty");

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

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

  • concat(): объединяет строки

  • valueOf(): преобразует объект в строковый вид

  • join(): соединяет строки с учетом разделителя

  • сompare(): сравнивает две строки

  • charAt(): возвращает символ строки по индексу

  • getChars(): возвращает группу символов

  • equals(): сравнивает строки с учетом регистра

  • equalsIgnoreCase(): сравнивает строки без учета регистра

  • regionMatches(): сравнивает подстроки в строках

  • indexOf(): находит индекс первого вхождения подстроки в строку

  • lastIndexOf(): находит индекс последнего вхождения подстроки в строку


  • startsWith(): определяет, начинается ли строка с подстроки

  • endsWith(): определяет, заканчивается ли строка на определенную подстроку

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

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

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

  • toLowerCase(): переводит все символы строки в нижний регистр

  • toUpperCase(): переводит все символы строки в верхний регистр

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

НазадВперед

Concatenating Strings

The String class includes a method for concatenating two strings −

string1.concat(string2);

This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in −

"My name is ".concat("Zara");

Strings are more commonly concatenated with the + operator, as in −

"Hello," + " world" + "!"

which results in −

"Hello, world!"

Let us look at the following example −

Example

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

This will produce the following result −

пример

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

Например, следующий фрагмент будет определять, равны ли два экземпляра для всех символов:

Этот пример будет сравнивать их, независимо от их случая:

Обратите внимание: не позволяет указать. Например, если вы сравниваете два слова и на английском языке, они равны; однако на турецком языке они разные (на турецком, нижний регистр — )

Для таких случаев преобразование обеих строк в нижний регистр (или в верхний регистр) с помощью а затем сравнение с — это решение.

Не используйте оператор == для сравнения строк


Если вы не можете гарантировать, что все строки были интернированы (см. Ниже), вы не должны использовать операторы или Для сравнения строк. Эти операторы фактически проверяют ссылки, и поскольку несколько объектов могут представлять одну и ту же строку, это может привести к неправильному ответу.

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

Сравнение строк в инструкции switch

Java SE 7

Начиная с Java 1.7, можно сравнить переменную String с литералами в инструкции . Убедитесь, что String не имеет значения null, иначе он всегда будет генерировать . Значения сравниваются с использованием , т.е. чувствительны к регистру.

Сравнение строк с постоянными значениями

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

В то время как выкинет если имеет значение , будет оцениваться как .

Java SE 7

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

(Примечание: Это спорно , как к тому, что лучше избегать в целом, или пусть произойдет , а затем устранить причину, см здесь и здесь , конечно, назвав стратегию избегания «лучшая практика» не является оправданной.) .

Строковые упорядочения

Класс реализует с методом (как описано в начале этого примера). Это делает естественным упорядочение объектов с учетом регистра. Класс предоставляет константу называемую подходящую для сортировки без регистра.

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

Спецификация языка Java ( ) гласит следующее:

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

Например:

За кулисами механизм интернирования поддерживает хеш-таблицу, содержащую все интернированные строки, которые все еще доступны . Когда вы вызываете в , метод ищет объект в хеш-таблице:

  • Если строка найдена, то это значение возвращается как интернированная строка.
  • В противном случае копия строки добавляется в хэш-таблицу, и эта строка возвращается как интернированная строка.

Можно использовать интернирование, чтобы строки могли сравниваться с помощью . Однако есть серьезные проблемы с этим; см. Pitfall. Интернированные строки, чтобы вы могли использовать ==, — это плохая идея для деталей. Это не рекомендуется в большинстве случаев.

Previous Next

Compact String – Java 9

Java 9 has brought the concept of compact Strings back.

This means that whenever we create a String if all the characters of the String can be represented using a byte — LATIN-1 representation, a byte array will be used internally, such that one byte is given for one character.

In other cases, if any character requires more than 8-bits to represent it, all the characters are stored using two bytes for each — UTF-16 representation.

So basically, whenever possible, it’ll just use a single byte for each character.

Now, the question is – how will all the String operations work? How will it distinguish between the LATIN-1 and UTF-16 representations?

Well, to tackle this issue, another change is made to the internal implementation of the String. We have a final field coder, that preserves this information.

3.1. String Implementation in Java 9


Until now, the String was stored as a char[]:

From now on, it’ll be a byte[]:

The variable coder:

Where the coder can be:

Most of the String operations now check the coder and dispatch to the specific implementation:

With all the info the JVM needs ready and available, the CompactString VM option is enabled by default. To disable it, we can use:

3.2. How coder Works

In Java 9 String class implementation, the length is calculated as:

If the String contains only LATIN-1, the value of the coder will be 0 so the length of the String will be the same as the length of the byte array.

In other cases, if the String is in UTF-16 representation, the value of coder will be 1, and hence the length will be half the size of the actual byte array.

Note that all the changes made for Compact String, are in the internal implementation of the String class and are fully transparent for developers using String.

Compact Strings vs. Compressed Strings

In case of JDK 6 Compressed Strings, a major problem faced was that the String constructor accepted only char[] as an argument. In addition to this, many String operations depended on char[] representation and not a byte array. Due to this, a lot of unpacking had to be done, which affected the performance.

Whereas in case of Compact String, maintaining the extra field “coder” can also increase the overhead. To mitigate the cost of the coder and the unpacking of bytes to chars (in case of UTF-16 representation), some of the methods are intrinsified and the ASM code generated by the JIT compiler has also been improved.

This change resulted in some counter-intuitive results. The LATIN-1 indexOf(String) calls an intrinsic method, whereas the indexOf(char) does not. In case of UTF-16, both of these methods call an intrinsic method. This issue affects only the LATIN-1 String and will be fixed in future releases.

Thus, Compact Strings are better than the Compressed Strings in terms of performance.

To find out how much memory is saved using the Compact Strings, various Java application heap dumps were analyzed. And, while results were heavily dependent on the specific applications, the overall improvements were almost always considerable.

4.1. Difference in Performance

Let’s see a very simple example of the performance difference between enabling and disabling Compact Strings:

Here, we are creating 10 million Strings and then appending them in a naive manner. When we run this code (Compact Strings are enabled by default), we get the output:

Similarly, if we run it by disabling the Compact Strings using: -XX:-CompactStrings option, the output is:

Clearly, this is a surface level test, and it can’t be highly representative – it’s only a snapshot of what the new option may do to improve performance in this particular scenario.


С этим читают