Join Array of Primitives with Separator in Java – 在Java中用分离器连接基元数组

最后修改: 2018年 11月 30日

中文/混合/英文(键盘快捷键：t)

1. Introduction

1.绪论

In this quick tutorial, we’ll learn how to join an array of primitives with a single-character separator in Java. For our examples, we’ll consider two arrays: an array of int and an array of char.

在这个快速教程中，我们将学习如何在Java中用单字符分隔符连接一个基元数组。对于我们的例子，我们将考虑两个数组：一个int数组和一个char数组。

2. Defining the Problem

2.界定问题

Let’s start by defining an array of int and an array of char for the examples, as well as the separator character we’ll use to join their contents:

让我们先为例子定义一个int数组和一个char数组，以及我们要用来连接它们内容的分隔符。

int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
char separatorChar = '-';
String separator = String.valueOf(separatorChar);

Note that we’ve included both a char and String separator since some of the methods we’ll show require a char argument, while others require a String argument.

请注意，我们同时包含了char和String分隔符，因为我们将展示的一些方法需要一个char参数，而其他方法需要一个String参数。

The results of the joining operation will contain “1-2-3-4-5-6-7-8-9” for the int array, and “a-b-c-d-e-f” for the char array.

连接操作的结果将包含“1-2-3-4-5-6-7-8-9”用于int数组，“a-b-c-d-e-f”用于char数组。

3. Collectors.joining()

3.Collectors.join()

Let’s start with one of the available methods from the  Java 8 Stream API — Collectors.joining().

让我们从Java 8 Stream API中的一个可用方法开始 – Collectors.join()。

First, we create a Stream from an array of primitives using the Arrays.stream() method found in the java.util package. Next, we map each element to String. And finally, we concatenate the elements with our given separator.

首先，我们使用java.util包中的Arrays.stream()方法从一个基元数组中创建一个Stream。接下来，我们将每个元素映射到String。最后，我们用给定的分隔符将这些元素连接起来。

Let’s begin with our int array:

让我们从我们的int数组开始。

String joined = Arrays.stream(intArray)
  .mapToObj(String::valueOf)
  .collect(Collectors.joining(separator));

When joining our char array with this method, we must first wrap the char array into CharBuffer and then project it to char again. This is because the chars() method returns a Stream of int values.

当用这个方法加入我们的char数组时，我们必须首先将char数组包裹成CharBuffer，然后再将其投射到char。这是因为chars()方法返回一个Stream的int值。

Unfortunately, the Java Stream API does not provide a native method for wrapping a Stream of char.

不幸的是，Java Stream API并没有提供一个本地方法来包装一个Stream的char。

Let’s join our char array:

让我们加入我们的char数组。

String joined = CharBuffer.wrap(charArray).chars()
  .mapToObj(intValue -> String.valueOf((char) intValue))
  .collect(Collectors.joining(separator));

4. StringJoiner

4.StringJoiner

Similarly to Collectors.joining(), this approach makes use of the Stream API, but instead of collecting elements, it iterates through elements and adds them to a StringJoiner instance:

与Collectors.join()类似，这种方法利用了Stream API，但它不是收集元素，而是迭代元素并将它们添加到StringJoiner实例中。

StringJoiner intStringJoiner = new StringJoiner(separator);
Arrays.stream(intArray)
  .mapToObj(String::valueOf)
  .forEach(intStringJoiner::add);
String joined = intStringJoiner.toString();

Again, we have to wrap our char array into CharBuffer when using the Stream API:

同样，在使用Stream API时，我们必须将我们的char数组包装成CharBuffer。

StringJoiner charStringJoiner = new StringJoiner(separator);
CharBuffer.wrap(charArray).chars()
  .mapToObj(intChar -> String.valueOf((char) intChar))
  .forEach(charStringJoiner::add);
String joined = charStringJoiner.toString();

5. Apache Commons Lang

5.阿帕奇公社朗

The Apache Commons Lang library provides some handy methods in the StringUtils and ArrayUtils classes that we can use to join our primitive arrays.

Apache Commons Lang库在StringUtils和ArrayUtils类中提供了一些方便的方法，我们可以用来连接我们的原始数组。

To use this library, we’ll need to add the commons-lang3 dependency to our pom.xml:

为了使用这个库，我们需要将commons-lang3 依赖添加到我们的pom.xml中。

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

When working with a String separator, we’ll make use of both StringUtils and ArrayUtils.

当使用String分隔符时，我们将同时使用StringUtils和ArrayUtils。

Let’s use these together to join our int array:

让我们一起使用这些来连接我们的int数组。

String joined = StringUtils.join(ArrayUtils.toObject(intArray), separator);

Or, if we’re using a primitive char type as a separator, we can simply write:

或者，如果我们使用一个原始的char类型作为分隔符，我们可以简单地写。

String joined = StringUtils.join(intArray, separatorChar);

The implementations for joining our char array are quite similar:

加入我们的char数组的实现非常相似。

String joined = StringUtils.join(ArrayUtils.toObject(charArray), separator);

And when using a char separator:

而当使用char分隔符时。

String joined = StringUtils.join(charArray, separatorChar);

6. Guava

6.番石榴

Google’s Guava library provides the Joiner class that we can use to join our arrays. To use Guava in our project, we’ll need to add the guava Maven dependency:

Google的Guava库提供了Joiner类，我们可以用它来连接我们的数组。要在我们的项目中使用Guava，我们需要添加guavaMaven依赖项。

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

Let’s join our int array using the Joiner class:

让我们使用Joiner类连接我们的int数组。

String joined = Joiner.on(separator).join(Ints.asList(intArray));

In this example, we also used the Ints.asList() method from Guava, which nicely transforms the array of primitives into a List of Integer.

在这个例子中，我们还使用了Guava的Ints.asList()方法，该方法很好地将基元数组转换为List的Integer。

Guava offers a similar method for converting a char array to a List of Character. As a result, joining our char array looks very much like the above example that used the int array:

Guava提供了一个类似的方法来将char数组转换为List的Character.结果，加入我们的char数组看起来非常像上面使用int数组的例子。

String joined = Joiner.on(separator).join(Chars.asList(charArray));

7. StringBuilder

7.StringBuilder

Finally, if we can’t use either Java 8 or third-party libraries, we can manually join an array of elements with StringBuilder. In this case, the implementation is identical for both types of arrays:

最后，如果我们不能使用Java 8或第三方库，我们可以用StringBuilder手动连接一个数组的元素。在这种情况下，两种类型的数组的实现是相同的。

if (array.length == 0) {
    return "";
}
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < array.length - 1; i++) {
    stringBuilder.append(array[i]);
    stringBuilder.append(separator);
}
stringBuilder.append(array[array.length - 1]);
String joined = stringBuilder.toString();

8. Conclusion

8.结论

This quick article illustrates a number of ways to join an array of primitives with a given separator character or string. We showed examples using native JDK solutions, as well as additional solutions using two third-party libraries — Apache Commons Lang and Guava.

这篇快速文章说明了用给定的分隔符或字符串连接基元阵列的若干方法。我们展示了使用本地JDK解决方案的例子，以及使用两个第三方库–Apache Commons Lang和Guava的额外解决方案。

As always, the complete code used in this article is available over on GitHub.

一如既往，本文中使用的完整代码可在GitHub上找到。