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

От / 
🔥 🚀 Важно для всех, кто работает с Java! 🔥
На JavaRocks ты найдешь уникальные туториалы, практические задачи и редкие книги, которых не найти в свободном доступе. Присоединяйся к нашему Telegram-каналу JavaRocks — стань частью профессионального сообщества!

Конкатенация строк в Java — это процесс объединения двух или более строк в одну новую строку с последующим возвратом результата. Такая операция часто используется при формировании сообщений, построении SQL-запросов, логировании и других задачах, где важно собрать текст из разных частей. Кроме того, конкатенация применяется для преобразования других типов данных в строку.

В Java есть два основных способа выполнить конкатенацию.

метод concat()

Метод Concat() указанную строку в конец текущей строки и возвращает новую сформированную строку. С его помощью можно объединять две, три и более строк последовательно:

Сигнатура метода concat()

public String concat(String str)

Метод объединяет строку str в конце текущей строки и возвращает результат. Например:

String s1 = “Hello ”;
s1.concat("World")
Run Code

Этот вызов возвращает новую строку «Hello World».

Пример метода Concat()

В примере ниже сначала объединяются две строки после их инициализации, затем объединяются четыре строки. Также показан интересный пример использования concat() внутри метода, который возвращает разные сообщения в зависимости от переданного аргумента.

public class ConcatTest {

    public static void main(String[] args) {
        // объединение строк с помощью метода concat()
        String string1 = "I learn ";
        String string2 = "concatenation in Java";
        // используем concat() для объединения двух строк
        String result = string1.concat(string2);
        System.out.println(result);
        // concat() для объединения четырёх строк
        String myWebSite = "Code".concat("Gym").concat(".cc").concat("/quest");
        System.out.println(myWebSite); // результат выполнения строки: "CodeGym.cc/quest"

        System.out.println(myMessage(true));
        System.out.println(myMessage(false));
    }

    private static String myMessage(boolean b) {   // concat() с выбором на основе условия
        return "I have".concat(b ? " " : "n't ").concat("got it");
    }

}
Run Code

Вывод: 

I learn concatenation in Java
CodeGym.cc/quest
I have got it
I haven't got it

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

Конкатенация с использованием операторов + и +=

В Java строки можно объединять с помощью операторов + и += . как это делается с числами. Эти операторы работают аналогично методу concat() . Например, объединим строку «Code» и строку «Gym».

public class StringConcat {
   public static void main(String[] args) {

       String myString = "Code" + "Gym";
       myString+= ".cc";
       System.out.println(myString);
   }
}
Run Code

Хотя Java не поддерживает перегрузку операторов для пользовательских классов, но эти два оператора ведут себя так, как будто они перегружены для строк. Обычно + используется для объединения чисел, но если хотя бы один из операндов — строка, то компилятор автоматически преобразует выражение в конкатенацию. Это значит, что строки будут объединены, а не складываться как числа. На самом деле, при таком объединении компилятор не вызывает метод concat(), а создает объект StringBuilder и вызывает его метод append(). Это делается для повышения производительности.

public class StringTest2 {

   public static void main(String[] args) {

       String hello = "hello";
       String world = " world!";

       String helloworld = (new StringBuilder().append(hello).append(world).toString());
       System.out.println(helloworld);
       // то же самое, что и:
       String result = hello + world;
   }
}
Run Code

Concat(0) или + ?

Если вам нужно объединить строки только один раз, используйте метод concat() . Для всех остальных случаев лучше использовать либо оператор + , либо Stringbuffer / StringBuilder .

Также оператор + используется для преобразования типов. Если один из операндов – число, а второй – строка, то на выходе мы получим строку. Пример:

public class StringConcat {
   public static void main(String[] args) {
       int myInt = 5;
       String myString = " days";

       System.out.println(myInt + myString);
       boolean b = (myInt + myString) instanceof String;
       System.out.println(b);
   }
}
Run Code

Мы использовали instanceof, чтобы проверить, является ли результат выражения (myInt + myString) строкой. Ответ – да. Вот вывод этой программы:

5 days
true

Также стоит учитывать различия в поведении + и concat() работают по-разному, , если один из операндов – null. Если использовать + или += , то null будет преобразован в строку null:

public class StringConcat {
   public static void main(String[] args) {

       String myString = "book ";
       System.out.println(myString + null);
       System.out.println((myString + null) instanceof String);
   }
}
Run Code

Вывод: 

book null
true

Если мы применим метод concat() для той же операции, то получим исключение NullPointerException.

public class StringConcat {
   public static void main(String[] args) {

       String myString = "book ";
       System.out.println(myString.concat(null));

   }
}
Run Code

Вывод:

Exception in thread "main" java.lang.NullPointerException
	at java.base/java.lang.String.concat(String.java:1972)
	at StringConcat.main(StringConcat.java:6)

Итак, concat() и "+" оператор — это два популярных способа объединения строк в Java. Выбор зависит от ситуации: единичная операция – concat()? , множественные – + или StringBuilder. Выбор правильного подхода зависит от таких факторов, как производительность и читаемость.

Использование StringJoiner для конкатенации строк

Представленный в Java 8, StringJoiner он предоставляет современный и гибкий способ объединения строк с дополнительными разделителями, префиксами и суффиксами.

import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        StringJoiner joiner = new StringJoiner(", ", "[", "]");
        joiner.add("Java");
        joiner.add("Python");
        joiner.add("C++");
        System.out.println(joiner.toString()); // Вывод: [Java, Python, C++]
    }
}
Run Code

StringJoiner особенно полезен при форматировании строк с постоянными разделителями или обрамлением, например — при генерации списков, CSV-форматов или вывода в лог.

Объединение строк с помощью Collectors.joining в Stream API

Этот Collectors.joining метод, являющийся частью Stream API, предлагает элегантный и эффективный способ объединения строк из коллекций.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CollectorsJoiningExample {
    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java", "Python", "C++");
        String result = languages.stream()
                                 .collect(Collectors.joining(", ", "[", "]"));
        System.out.println(result); // Вывод: [Java, Python, C++]
    }
}
Run Code

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

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

Выбор подхода к объединению строк может заметно сказаться на производительности приложения, особенно при обработке больших объёмов данных или в случаях с повторяющимися операциями. Эффективность становится критичной, когда строки объединяются в цикле или формируются динамически на протяжении выполнения программы.

Соображения производительности

  • Оператор + при множественных конкатенациях компилятором преобразуется во внутреннее использование StringBuilder или StringBuffer. Это делает его эффективным в большинстве случаев.
  • Метод concat()может работать немного быстрее при объединении ровно двух строк, поскольку в этом случае не создаются промежуточные объекты.

Соображения читабельности

  • Оператор + считается более интуитивным и читабельным для простой конкатенации.
  • Метод concat() менее удобен для восприятия, особенно при множественном объединении, и требует, чтобы все операнды были ненулевыми. В противном случае может возникнуть ошибка NullPointerException.

Предотвращение неэффективных решений

Избегайте объединения строк в цикле с помощью "+" оператора, так как при этом на каждой итерации создается новый String объект, что приводит к увеличению потребления памяти и снижению производительности.

Использование StringBuilder для эффективности

В задачах, где строки объединяются многократно, особенно в циклах, предпочтительнее использовать StringBuilder, а не оператор "+". Это позволяет избежать создания большого количества промежуточных объектов String, что снижает нагрузку на память и ускоряет выполнение.

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append("example");
}
String result = builder.toString();
Run Code

Заключение

Оператор "+" остаётся наиболее удобным выбором в большинстве случаев благодаря своей читаемости и простоте. Метод concat() может быть оправдан, если тестирование производительности показывает его преимущество в конкретной ситуации.

Перевод статьи «String Concatenation in Java».

Оставьте комментарий

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

Прокрутить вверх