Вспомогательные классы для работы со строками в Java

1. Класс StringTokenizer

И еще несколько самых частых сценариев работы со строками. Как разбить строку на несколько частей? Для этого есть несколько способов.

Метод split()

Первый способ разбить строку на несколько частей — использовать метод split(). В него в качестве параметра нужно передать регулярное выражение: специальный шаблон строки-разделителя. Что такое регулярное выражение, вы узнаете в квесте Java Multithreading.

Пример:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

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

Класс StringTokenizer

В Java есть специальный класс, вся работа которого — разделять строку на подстроки.

Этот класс не использует регулярные выражения: вместо этого в него просто передается строка, состоящая из символов-разделителей. Преимущества этого подхода в том, что он не разбивает сразу всю строку на кусочки, а потихоньку идет от начала к концу.

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

String nextToken()

boolean hasMoreTokens()

Этот класс чем-то напоминает класс Scanner, у которого тоже были методы nextLine() и hasNextLine().

Создать объект StringTokenizer можно командой:

StringTokenizer имя = new StringTokenizer(строка, разделители);

Где строка — это строка, которую будем делить на части. А разделители — это строка, каждый символ которой считается символом-разделителем. Пример:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

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

2. Метод String.format() и класс StringFormatter

И еще один интересный метод класса String — format().

Допустим, у вас есть различные переменные с данными. Как вывести их на экран одной строкой? Например, у нас есть данные (левая колонка) и желаемый вывод (правая колонка):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

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

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Такой код не слишком читабельный. Более того, если бы имена переменных были длиннее, код стал бы еще сложнее:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Не очень читаемо, не так ли?

Однако в реальных программах такая ситуация встречается часто, поэтому я хочу рассказать о способе, как проще и короче записать этот код.

String.format

У класса String есть статический метод format(): он позволяет задать шаблон объединения строки с данными. Общий вид этой команды такой:

String имя = String.format(шаблон, параметры);

Пример:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

В метод format() первым параметром передают строку-шаблон, которая содержит весь нужный текст, а в местах, где нужно вставлять данные, написаны специальные символы типа %d, %s и т.п.

Вот эти %s и %d метод format() и заменяют на параметры, которые идут следом за строкой-шаблоном. Если нужно подставить строку, мы пишем %s, если число — %d. Пример:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Вот краткий список параметров, которые можно использовать внутри шаблона:

%s

%d

%f

%b

%c

%t

%%

Эти параметры указывают на тип данных, но есть еще параметры, которые указывают на порядок данных. Чтобы взять параметр по его номеру (нумерация начинается с единицы), нужно записать %1$d вместо %d. Пример:

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$d возьмет 3-й параметр-переменную, %2$d возьмет второй параметр. %d возьмет самый первый параметр-переменную. Параметры шаблона %s, %d обращаются к переменным-параметрам независимо от параметров шаблона типа %3$d или %2$s

3. String Pool

Все строки, которые были заданы в коде в виде литералов, во время работы программы хранятся в памяти в так называемом StringPool. StringPool — это специальный массив для хранения строк. Цель его создания — оптимизация хранения строк:

Во-первых, строки, заданные в коде, нужно все-таки где-то хранить. Код — это команды, а данные (тем более такие большие как строки) нужно хранить в памяти отдельно от кода. В коде фигурируют только ссылки на объекты-строки.

Во-вторых, все одинаковые литералы можно хранить в памяти только один раз. Так оно и работает. Когда код вашего класса загружается Java-машиной, все строковые литералы добавляются в StringPool, если их там еще нет. Если уже есть, просто используется ссылка на строку из StringPool.

Поэтому если в своем коде вы присвоите нескольким String-переменным одинаковые литералы, переменные будут содержать одинаковые ссылки. В StringPool литерал будет добавлен только один раз, во всех остальных случаях будет браться ссылка на уже загруженную в StringPool строку.

Как это примерно работает:

String a = "Привет";
String b = "Привет";
String c = "Пока";

String[] pool = {"Привет", "Пока"};
a = pool[0];
b = pool[0];
c = pool[1];

Именно поэтому переменные a и b будут хранить одинаковые ссылки.

Метод intern()

Ну и самое интересное: вы можете программно добавить любую строку в StringPool. Для этого нужно просто вызвать метод intern() у String-переменной.

Метод intern() добавит строку в StringPool, если ее еще там нет, и вернет ссылку на строку из StringPool.

Если в StringPool добавить с помощью метода intern() две идентичные строки, метод вернет одинаковые ссылки. Это можно использовать чтобы сравнивать строки по ссылке. Пример:

String a = new String("Привет");
String b = new String("Привет");
System.out.println(a == b);

false

String a = new String("Привет");
String b = new String("Привет");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Вряд ли вы будете часто пользоваться этим методом, однако о нем любят спрашивать на собеседованиях, поэтому лучше о нем знать, чем не знать.