Как объединить элементы массива в Java: 5 эффективных способов

Для кого эта статья:

• Java-разработчики, особенно среднего и высокого уровня
• Студенты и начинающие разработчики, желающие углубить свои знания в Java

• Программисты, занимающиеся оптимизацией производительности приложений

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

Работаете с массивами в Java, но постоянно натыкаетесь на проблемы с их объединением? Пройдите Курс Java-разработки от Skypro, где вы не только освоите профессиональные методы работы с коллекциями и массивами, но и научитесь выбирать оптимальные решения для конкретных задач. Наши студенты получают практические навыки, которые сразу применяют в реальных проектах и на собеседованиях в крупных IT-компаниях.

Способ 1: String.join() для элегантного объединения массивов

Метод String.join() появился в Java 8 и сразу стал фаворитом среди разработчиков благодаря своей элегантности и лаконичности. Он специально разработан для задачи объединения строк с разделителем и предлагает чистый, читаемый и эффективный способ сделать это.

Синтаксис метода прост и интуитивно понятен:

String[] fruits = {"яблоко", "банан", "апельсин", "груша"};
String joined = String.join(", ", fruits);
// Результат: "яблоко, банан, апельсин, груша"

Первым аргументом метода выступает разделитель, который будет помещён между элементами. Вторым аргументом может быть массив строк, Iterable<CharSequence> или несколько строковых аргументов переменной длины.

Преимущества String.join() очевидны:

• Лаконичный и понятный синтаксис
• Отсутствие необходимости обрабатывать случаи пустых массивов
• Автоматическое управление разделителями (разделитель не добавляется в начале и в конце)
• Оптимизированная производительность

Особенно элегантно выглядит использование String.join() в цепочке методов:

String result = String.join(" | ", 
Arrays.stream(numbers)
.map(String::valueOf)
.toArray(String[]::new));

Игорь Васильев, технический лид команды разработки

Недавно мне пришлось ревьюить код, где младший разработчик использовал цикл for с конкатенацией строк для объединения списка тегов товаров в строку с запятыми. Код был не только громоздким, но и создавал новую строку на каждой итерации, что негативно влияло на производительность.

Я показал ему решение с использованием String.join(): одна строка кода заменила 10 строк его реализации. "Меньше кода — меньше багов", — напомнил я. Через неделю этот же разработчик прислал мне сообщение о том, как он применил String.join() в другой части проекта и смог избавиться от странного бага, связанного с обработкой пустых строк, который преследовал команду больше месяца.

Однако у метода String.join() есть и ограничения. Он работает только со строками. Если ваш массив содержит другие типы данных, вам придется сначала преобразовать их в строки:

Integer[] numbers = {1, 2, 3, 4, 5};
String joined = String.join(", ", 
Arrays.stream(numbers)
.map(String::valueOf)
.toArray(String[]::new));

Таблица ниже демонстрирует различные сценарии использования String.join():

Способ 2: StringBuilder для высокопроизводительной конкатенации

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

Вот как можно объединить элементы массива с разделителем, используя StringBuilder:

String[] cities = {"Москва", "Санкт-Петербург", "Казань", "Новосибирск"};
StringBuilder builder = new StringBuilder();

for (int i = 0; i < cities.length; i++) {
builder.append(cities[i]);
if (i < cities.length – 1) {
builder.append(", ");
}
}

String result = builder.toString();
// Результат: "Москва, Санкт-Петербург, Казань, Новосибирск"

Более элегантный подход использует итерацию for-each с проверкой первого элемента:

String[] cities = {"Москва", "Санкт-Петербург", "Казань", "Новосибирск"};
StringBuilder builder = new StringBuilder();
boolean first = true;

for (String city : cities) {
if (first) {
first = false;
} else {
builder.append(", ");
}
builder.append(city);
}

String result = builder.toString();

Преимущества использования StringBuilder для объединения элементов массива:

• Значительно более высокая производительность при работе с большими массивами
• Меньшее использование памяти благодаря отсутствию создания промежуточных строк
• Гибкий контроль над добавлением разделителей
• Возможность предварительного распределения памяти, если известен примерный размер результирующей строки

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

String[] cities = {"Москва", "Санкт-Петербург", "Казань", "Новосибирск"};
// Рассчитываем примерный размер
int capacity = 0;
for (String city : cities) {
capacity += city.length();
}
capacity += (cities.length – 1) * 2; // для разделителей ", "

StringBuilder builder = new StringBuilder(capacity);
// ... далее как в предыдущем примере

Использование StringBuilder особенно целесообразно в следующих сценариях:

Способ 3: Преобразование и объединение с Arrays.toString()

Метод Arrays.toString() представляет собой быстрый и удобный способ получить строковое представление массива. Он автоматически заключает элементы в квадратные скобки и разделяет их запятыми. Хотя этот метод не позволяет напрямую задать пользовательский разделитель, его можно комбинировать с другими методами для достижения желаемого результата.

Базовое использование Arrays.toString() выглядит следующим образом:

String[] planets = {"Меркурий", "Венера", "Земля", "Марс"};
String result = Arrays.toString(planets);
// Результат: "[Меркурий, Венера, Земля, Марс]"

Но в большинстве случаев нам нужна строка без квадратных скобок. Здесь можно применить метод substring():

String result = Arrays.toString(planets);
result = result.substring(1, result.length() – 1);
// Результат: "Меркурий, Венера, Земля, Марс"

Если же необходимо заменить стандартный разделитель (запятая и пробел) на что-то другое, можно использовать метод replace() или replaceAll():

String result = Arrays.toString(planets);
result = result.substring(1, result.length() – 1);
result = result.replaceAll(", ", " | ");
// Результат: "Меркурий | Венера | Земля | Марс"

Марина Соколова, руководитель отдела бэкенд-разработки

В нашем проекте по анализу данных необходимо было создать CSV-отчет из многомерных массивов. Новый разработчик использовал вложенные циклы с ручной обработкой каждого элемента — код занимал десятки строк и был трудночитаемым.

Я предложила элегантное решение с использованием Arrays.toString() и регулярных выражений для форматирования. Мы сократили код в 5 раз и ускорили обработку. Самое интересное произошло, когда мы получили нестандартные данные с запятыми внутри значений: наше решение справилось автоматически, а старый подход пришлось бы полностью переписывать. Клиент был в восторге от скорости, с которой мы адаптировали систему под новые требования.

Преимущества и недостатки использования Arrays.toString():

• Преимущества:
• Простота использования — всего одна строка кода для получения базового строкового представления
• Автоматическая обработка null-значений (они представляются как строка "null")
• Работает с массивами любых примитивных типов и объектов
• Недостатки:
• Дополнительные манипуляции для получения строки без квадратных скобок
• Дополнительные операции для изменения стандартного разделителя
• Менее эффективно для очень больших массивов по сравнению с StringBuilder

Метод Arrays.toString() также может быть использован для преобразования массивов примитивных типов в строку без необходимости предварительного преобразования каждого элемента:

int[] numbers = {1, 2, 3, 4, 5};
String result = Arrays.toString(numbers);
// Результат: "[1, 2, 3, 4, 5]"
result = result.substring(1, result.length() – 1);
// Результат: "1, 2, 3, 4, 5"

Для многомерных массивов можно использовать Arrays.deepToString():

String[][] grid = {
{"A", "B", "C"},
{"D", "E", "F"},
{"G", "H", "I"}
};
String result = Arrays.deepToString(grid);
// Результат: "[[A, B, C], [D, E, F], [G, H, I]]"

В случае сложных объектов результат Arrays.toString() зависит от реализации метода toString() этих объектов. Если необходимо особое форматирование, может потребоваться переопределить метод toString() в соответствующем классе.

Способ 4: Функциональный подход через Stream API

Stream API, введённый в Java 8, предлагает элегантный функциональный подход к обработке последовательностей элементов. Это мощный инструмент, который позволяет не только объединять элементы массива с разделителем, но и применять различные трансформации к данным в процессе объединения. 🌊

Базовый пример объединения элементов массива с разделителем через Stream API:

String[] colors = {"красный", "зелёный", "синий", "жёлтый"};
String result = Arrays.stream(colors)
.collect(Collectors.joining(", "));
// Результат: "красный, зелёный, синий, жёлтый"

Метод Collectors.joining() предлагает несколько перегрузок, позволяющих указать не только разделитель, но и префикс с суффиксом:

String result = Arrays.stream(colors)
.collect(Collectors.joining(", ", "Цвета: [", "]"));
// Результат: "Цвета: [красный, зелёный, синий, жёлтый]"

Особая сила Stream API проявляется при необходимости предварительной обработки элементов перед объединением. Например, фильтрация, преобразование или сортировка:

String[] items = {"apple", "banana", null, "cherry", "date", ""};

// Фильтрация null и пустых строк, преобразование к верхнему регистру
String result = Arrays.stream(items)
.filter(Objects::nonNull)
.filter(s -> !s.isEmpty())
.map(String::toUpperCase)
.collect(Collectors.joining(" | "));
// Результат: "APPLE | BANANA | CHERRY | DATE"

Stream API особенно полезен при работе с массивами объектов, когда требуется извлечение определённых полей:

class Product {
private String name;
private double price;

// Конструктор, геттеры, сеттеры...
public String getName() { return name; }
public double getPrice() { return price; }
}

Product[] products = {
new Product("Телефон", 999.99),
new Product("Ноутбук", 1499.99),
new Product("Планшет", 599.99)
};

String productNames = Arrays.stream(products)
.map(Product::getName)
.collect(Collectors.joining(", "));
// Результат: "Телефон, Ноутбук, Планшет"

Преимущества использования Stream API для объединения элементов:

• Декларативный стиль программирования, делающий код более читаемым
• Возможность комбинирования с другими операциями (map, filter, distinct и т.д.)
• Возможность параллельной обработки с помощью parallelStream()
• Естественная обработка null-значений с помощью фильтров
• Сокращение количества промежуточного кода по сравнению с императивным подходом

Однако есть и некоторые нюансы, о которых следует помнить:

• Для небольших массивов может быть менее эффективным из-за накладных расходов на создание Stream
• Некоторые разработчики, не знакомые с функциональным программированием, могут испытывать трудности при чтении кода
• При работе с массивами примитивных типов требуется преобразование в объектный Stream

Пример работы с массивом примитивных типов:

int[] numbers = {1, 2, 3, 4, 5};
String result = Arrays.stream(numbers)
.mapToObj(String::valueOf)
.collect(Collectors.joining(" – "));
// Результат: "1 – 2 – 3 – 4 – 5"

Способ 5: Apache Commons StringUtils для удобной работы

Библиотека Apache Commons Lang предоставляет класс StringUtils, который содержит множество полезных утилит для работы со строками, включая метод join() для объединения элементов коллекции или массива с разделителем. Этот метод существовал задолго до появления String.join() в Java 8 и до сих пор остается популярным благодаря своей функциональности и удобству использования. 📚

Для начала необходимо добавить зависимость в ваш проект. В Maven это делается так:

<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>

Базовое использование StringUtils.join() выглядит следующим образом:

import org.apache.commons.lang3.StringUtils;

String[] animals = {"кот", "собака", "хомяк", "попугай"};
String result = StringUtils.join(animals, ", ");
// Результат: "кот, собака, хомяк, попугай"

StringUtils.join() имеет множество перегрузок, что делает его чрезвычайно гибким. Вот некоторые из них:

// Объединение части массива (с 1-го индекса по 3-й)
String result = StringUtils.join(animals, ", ", 1, 3);
// Результат: "собака, хомяк"

// Объединение коллекции
List<String> fruits = Arrays.asList("яблоко", "груша", "банан");
result = StringUtils.join(fruits, " и ");
// Результат: "яблоко и груша и банан"

// Объединение массива объектов
Integer[] numbers = {1, 2, 3, 4, 5};
result = StringUtils.join(numbers, " + ");
// Результат: "1 + 2 + 3 + 4 + 5"

Одно из главных преимуществ StringUtils.join() — корректная обработка null-значений:

String[] data = {"a", null, "c", "", "e"};

// По умолчанию null преобразуется в строку "null"
String result1 = StringUtils.join(data, ", ");
// Результат: "a, null, c, , e"

// С использованием кастомной обработки null
String result2 = Arrays.stream(data)
.map(s -> s == null ? "[ПУСТО]" : s)
.collect(Collectors.joining(", "));
// Результат: "a, [ПУСТО], c, , e"

Сравнение различных аспектов пяти рассмотренных методов объединения элементов массива:

Преимущества использования StringUtils.join():

• Работает со всеми версиями Java (как старыми, так и новыми)
• Предлагает больше перегрузок и возможностей, чем стандартный String.join()
• Корректная обработка null-значений
• Возможность объединения части массива (с указанным начальным и конечным индексом)
• Совместимость с другими полезными утилитами из библиотеки Apache Commons

Недостатки:

• Необходимость подключения внешней библиотеки
• Небольшой overhead из-за дополнительных проверок и функциональности
• Потенциальные конфликты версий в больших проектах

StringUtils также содержит множество других полезных методов для работы со строками, таких как isEmpty(), isBlank(), capitalize(), reverse() и многие другие, что делает его мощным инструментом в арсенале Java-разработчика.

Выбор правильного метода объединения элементов массива с разделителем зависит от конкретного сценария использования. Для большинства случаев String.join() предлагает идеальный баланс между читаемостью и производительностью. При работе с большими массивами или требуется динамическое создание строк, StringBuilder становится оптимальным выбором. Stream API незаменим, когда необходима предварительная обработка элементов перед объединением. Помните: хороший инженер выбирает инструмент под задачу, а не подгоняет задачу под знакомый инструмент. Теперь у вас есть пять мощных методов в арсенале — используйте их мудро.