Строки в Java и Kotlin

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

В Java это можно сделать следующим образом:

// Java
String name = "Joe";
System.out.println("Hello, " + name);
System.out.println("Your name is " + name.length() + " characters long");

В Kotlin используйте знак доллара ($) перед именем переменной, чтобы интерполировать значение этой переменной в вашу строку:

fun main() {
//sampleStart
    // Kotlin
    val name = "Joe"
    println("Hello, $name")
    println("Your name is ${name.length} characters long")
//sampleEnd
}

Вы можете интерполировать значение сложного выражения, заключив его в фигурные скобки, как в ${name.length}. Дополнительную информацию см. в разделе шаблоны строк.

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

В Java вы можете использовать StringBuilder:

// Java
StringBuilder countDown = new StringBuilder();
for (int i = 5; i > 0; i--) {
    countDown.append(i);
    countDown.append("\n");
}
System.out.println(countDown);

В Kotlin используйте buildString() – встроенную функцию, которая принимает логику построения строки в качестве лямбда-аргумента:

fun main() {
//sampleStart
       // Kotlin
       val countDown = buildString {
           for (i in 5 downTo 1) {
               append(i)
               appendLine()
           }
       }
       println(countDown)
//sampleEnd
}

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

Узнайте больше о правилах написания лямбда-выражений.

Создание строки из элементов коллекции

В Java вы используете Stream API, чтобы отфильтровать, отобразить, а затем собрать элементы:

// Java
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
String invertedOddNumbers = numbers
        .stream()
        .filter(it -> it % 2 != 0)
        .map(it -> -it)
        .map(Object::toString)
        .collect(Collectors.joining("; "));
System.out.println(invertedOddNumbers);

В Kotlin используйте функцию joinToString(), которую Kotlin определяет для каждого списка:

fun main() {
//sampleStart
    // Kotlin
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val invertedOddNumbers = numbers
        .filter { it % 2 != 0 }
        .joinToString(separator = ";") {"${-it}"}
    println(invertedOddNumbers)
//sampleEnd
}

Узнайте больше о применении joinToString().

Установить значение по умолчанию, если строка пустая

В Java вы можете использовать тернарный оператор:

// Java
public void defaultValueIfStringIsBlank() {
    String nameValue = getName();
    String name = nameValue.isBlank() ? "John Doe" : nameValue;
    System.out.println(name);
}

public String getName() {
    Random rand = new Random();
    return rand.nextBoolean() ? "" : "David";
}

Kotlin предоставляет встроенную функцию ifBlank(), которая принимает значение по умолчанию в качестве аргумента:

// Kotlin
import kotlin.random.Random

//sampleStart
fun main() {
    val name = getName().ifBlank { "John Doe" }
    println(name)
}

fun getName(): String =
    if (Random.nextBoolean()) "" else "David"
//sampleEnd

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

В Java вы можете использовать функцию replaceAll(). В этом случае функция replaceAll() принимает регулярные выражения ^## и ##$, которые определяют строки, начинающиеся и заканчивающиеся соответственно ##.

// Java
String input = "##place##holder##";
String result = input.replaceAll("^##|##$", "");
System.out.println(result);

В Kotlin используйте функцию removeSurrounding() с разделителем строки ##.

fun main() {
//sampleStart
    // Kotlin
    val input = "##place##holder##"
    val result = input.removeSurrounding("##")
    println(result)
//sampleEnd
}

Замена вхождений

В Java вы можете использовать классы Pattern и Matcher, например, для маскировки некоторых данных:

// Java
String input = "login: Pokemon5, password: 1q2w3e4r5t";
Pattern pattern = Pattern.compile("\\w*\\d+\\w*");
Matcher matcher = pattern.matcher(input);
String replacementResult = matcher.replaceAll(it -> "xxx");
System.out.println("Initial input: '" + input + "'");
System.out.println("Anonymized input: '" + replacementResult + "'");

В Kotlin вы используете класс Regex, который упрощает работу с регулярными выражениями. Кроме того, используйте сырые строки, чтобы упростить шаблон регулярного выражения, уменьшив количество обратных слэшей:

fun main() {
//sampleStart
    // Kotlin
    val regex = Regex("""\w*\d+\w*""") // raw string
    val input = "login: Pokemon5, password: 1q2w3e4r5t"
    val replacementResult = regex.replace(input, replacement = "xxx")
    println("Initial input: '$input'")
    println("Anonymized input: '$replacementResult'")
//sampleEnd
}

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

В Java для разделения строки с помощью символа точки (.) вам необходимо использовать экранирование (\\). Это происходит потому, что функция split() класса String принимает регулярное выражение в качестве аргумента:

// Java
System.out.println(Arrays.toString("Sometimes.text.should.be.split".split("\\.")));

В Kotlin используйте функцию Kotlin split(), которая принимает varargs из разделителей в качестве входных параметров:

fun main() {
//sampleStart
    // Kotlin
    println("Sometimes.text.should.be.split".split("."))
//sampleEnd
}

Если вам нужно разделить строку с помощью регулярного выражения, используйте перегруженную версию split(), которая принимает Regex в качестве параметра.

Получение подстроки

В Java вы можете использовать функцию substring(), которая принимает инклюзивный начальный индекс символа, с которого начинается подстрока. Чтобы получить подстроку после этого символа, вам нужно увеличить индекс:

// Java
String input = "What is the answer to the Ultimate Question of Life, the Universe, and Everything? 42";
String answer = input.substring(input.indexOf("?") + 1);
System.out.println(answer);

В Kotlin используйте функцию substringAfter() и не нужно вычислять индекс символа, после которого вы хотите получить подстроку:

fun main() {
//sampleStart
    // Kotlin
    val input = "What is the answer to the Ultimate Question of Life, the Universe, and Everything? 42"
    val answer = input.substringAfter("?")
    println(answer)
//sampleEnd
}

Кроме того, вы можете получить подстроку после последнего вхождения символа:

fun main() {
//sampleStart
    // Kotlin
    val input = "To be, or not to be, that is the question."
    val question = input.substringAfterLast(",")
    println(question)
//sampleEnd
}

Использование многострочных строк

До Java 15 существовало несколько способов создания многострочной строки. Например, использование функции join() класса String:

// Java
String lineSeparator = System.getProperty("line.separator");
String result = String.join(lineSeparator,
       "Kotlin",
       "Java");
System.out.println(result);

В Java 15 появились текстовые блоки. Следует помнить об одном моменте: если вы выводите многострочную строку, и тройные кавычки находятся на следующей строке, будет дополнительная пустая строка:

// Java
String result = """
    Kotlin
       Java
    """;
System.out.println(result);

Вывод:

Если вы поместите тройные кавычки в той же строке, что и последнее слово, эта разница в поведении исчезает.

В Kotlin вы можете отформатировать строку с кавычками на новой строке, и в выводе не будет дополнительной пустой строки. Левый крайний символ каждой строки определяет начало строки. Различие с Java заключается в том, что Java автоматически обрезает отступы, а в Kotlin вы должны сделать это явно:

fun main() {
//sampleStart
    // Kotlin   
    val result = """
        Kotlin
           Java 
    """.trimIndent()
    println(result)
//sampleEnd
}

Вывод:

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

В Kotlin вы также можете использовать функцию trimMargin() для настройки отступов:

// Kotlin
fun main() {
    val result = """
       #  Kotlin
       #  Java
   """.trimMargin("#")
    println(result)
}

Узнайте больше о многострочных строках.

Что дальше?

• Просмотрите другие Kotlin idioms.

• Узнайте, как преобразовать существующий код Java в Kotlin с помощью конвертера Java в Kotlin.

Если у вас есть любимый idiom, приглашаем вас поделиться им, отправив pull request.