Java：使用分隔符连接基元数组

假设我有一个数组：

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};

我需要使用分隔符连接它的元素，例如，

“-”

，因此我应该得到如下字符串：

"1 - 2 - 3 - 4 - 5 - 6 - 7"

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
String result = Arrays.stream(arr)
        .mapToObj(String::valueOf)
        .collect(Collectors.joining(" - "));

Stream.of(1,2,3,4).map(String::valueOf).collect(Collectors.joining("-"))

我怎么能这样做

---

PS:是的，我知道和帖子，但它的解决方案不能与一系列原语一起使用。

这里是我的想法。有几种方法可以做到这一点，它们取决于您使用的工具

---

从以下位置使用

StringUtils

和

ArrayUtils

：

不能只使用

StringUtils.join（arr，“-”）StringUtils

没有重载版本的方法。不过，它有方法

StringUtils.join（int[]，char）

适用于任何Java版本，从1.2开始

---

使用Java 8流：

大概是这样的：

"1 - 2 - 3 - 4 - 5 - 6 - 7"

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
String result = Arrays.stream(arr)
        .mapToObj(String::valueOf)
        .collect(Collectors.joining(" - "));

Stream.of(1,2,3,4).map(String::valueOf).collect(Collectors.joining("-"))

事实上，使用流可以获得很多不同的结果

Java8的方法

String.join（）

仅适用于字符串，因此要使用它，您仍然必须将

int[]

转换为

String[]

String[] sarr = Arrays.stream(arr).mapToObj(String::valueOf).toArray(String[]::new);
String result = String.join(" - ", sarr);

---

如果您坚持使用Java 7或更早版本而没有库，您可以编写自己的实用程序方法：

public static String myJoin(int[] arr, String separator) {
    if (null == arr || 0 == arr.length) return "";

    StringBuilder sb = new StringBuilder(256);
    sb.append(arr[0]);

    //if (arr.length == 1) return sb.toString();

    for (int i = 1; i < arr.length; i++) sb.append(separator).append(arr[i]);

    return sb.toString();
}

---

可以使用番石榴连接元素。你可以在那里找到更多的例子和文档

更准确地说，你应该首先将你的数组包装成一个

列表

，里面有或是番石榴的等价物

Joiner.on("-")
      .join(Arrays.asList(1, 2, 3, 4, 5, 6, 7));

Joiner.on("-")
      .join(Ints.asList(arr));

---

在Java8+中，可以使用和。大概

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };
StringJoiner sj = new StringJoiner(" - ");
IntStream.of(arr).forEach(x -> sj.add(String.valueOf(x)));
System.out.println(sj.toString());

输出为（按要求）

---

我相信在Kotlin/Scala或其他JVM语言中也有一种方法可以做到这一点，但对于上面提到的一小部分值，您可以始终保持简单：

int i, arrLen = arr.length;
 StringBuilder tmp = new StringBuilder();
 for (i=0; i<arrLen-1; i++)
    tmp.append(arr[i] +" - ");
 tmp.append(arr[arrLen-1]);

 System.out.println( tmp.toString() );

int i，arrLen=arr.length；
StringBuilder tmp=新的StringBuilder（）；
对于（i=0；i我一直在寻找一种在流中连接原语的方法，而不必首先为每一个原语实例化字符串。我已经做到了这一点，但仍然需要对它们进行装箱

LongStream.range(0, 500).boxed().collect(Collector.of(StringBuilder::new, (sb, v) -> {
    if (sb.length() != 0)
        sb.append(',');
    sb.append(v.longValue());
}, (a, b) -> a.length() == 0 ? b : b.length() != 0 ? a.append(',').append(b) : a, StringBuilder::toString));

Java 8解决方案如下所示：

"1 - 2 - 3 - 4 - 5 - 6 - 7"

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
String result = Arrays.stream(arr)
        .mapToObj(String::valueOf)
        .collect(Collectors.joining(" - "));

Stream.of(1,2,3,4).map(String::valueOf).collect(Collectors.joining("-"))

适用于Java 7或更早版本。

public static StringBuilder join(CharSequence delimiter, int... arr) {
    if (null == delimiter || null == arr) throw new NullPointerException();

    StringBuilder sb = new StringBuilder(String.valueOf(arr[0]));
    for (int i = 1; i < arr.length; i++) sb.append(delimiter).append(arr[i]);

    return sb;
}

public static void main(String[] args) {
    StringBuilder sb = join(" - ", 1, 2, 3, 4);
    System.out.println(sb.toString());//you could pass sb also coz println automatically call toString method within it
    System.out.println(sb.insert(0, "[").append("]"));
}

公共静态StringBuilder联接（字符序列分隔符，int…arr）{
if（null==分隔符| | null==arr）抛出新的NullPointerException（）；
StringBuilder sb=新的StringBuilder（String.valueOf（arr[0]）；
for（inti=1；i

输出：

1-2-3-4

[1-2-3-4]

如果分隔符是单字符，则可以使用通用语言：

int[] arr = {1, 2, 3, 4, 5, 6, 7};
String result = StringUtils.join(arr, '-');

但是，如果分隔符是字符串，则应使用其他分隔符，因为StringUtils表现不好（）。
您可以
.collect（Collectors.joining（“，”））
而不是临时字符串数组。概述不错！对于java 1.7版本：从技术上讲，在循环之前不需要进行arr.length==1检查，但这也很好。@shmosel，没有。
Arrays.stream（arr）
生成一个
IntStream
，其中没有这样的
collect（）
method。对于基本数组，Gava提供了基本
.asList（）
方法，例如，-不能将
Array.asList（）
用于基本数组。是的，
arrays.asList（arr）
将生成一个大小为1=）的
List
，这是我们的基本数组中的一个元素。好的！正如我所说，有很多方法可以通过streams.OP使用“-”作为分隔符来实现