Java中使用分隔符（与拆分相反）连接数组元素的一种快速简便的方法

看

我正在寻找一种快速简单的方法来做完全相反的分裂 因此它将导致

[“a”、“b”、“c”]

变成

“a、b、c”

遍历数组需要添加条件（如果这不是最后一个元素，请添加分隔符）或使用子字符串删除最后一个分隔符

---

我确信有一种经过认证的、高效的方法可以做到这一点（Apache Commons？）

您希望如何在项目中使用它？

它在StringUtils中：

“我确信有一种经过认证的高效方法可以做到这一点（Apache Commons？）”

是的，显然是

StringUtils.join(array, separator)

确实有一种方法可以将

字符串

数组与指定的分隔符连接在一起

例如：

String[] s = new String[] {"a", "b", "c"};
String joined = StringUtils.join(s, ",");  // "a,b,c"

但是，我怀疑，正如您所提到的，在上述方法的实际实现中一定存在某种条件或子字符串处理

public static String join(String[] values)
{
    return join(values, ',');
}

public static String join(String[] values, char delimiter)
{
    return join(Arrays.asList(values), String.valueOf(delimiter));
}

// To match Apache commons-lang: StringUtils.join(values, delimiter)
public static String join(String[] values, String delimiter)
{
    return join(Arrays.asList(values), delimiter);
}

public static String join(Collection<?> values)
{
    return join(values, ',');
}

public static String join(Collection<?> values, char delimiter)
{
    return join(values, String.valueOf(delimiter));
}

public static String join(Collection<?> values, String delimiter)
{
    if (values == null)
    {
        return new String();
    }

    StringBuffer strbuf = new StringBuffer();

    boolean first = true;

    for (Object value : values)
    {
        if (!first) { strbuf.append(delimiter); } else { first = false; }
        strbuf.append(value.toString());
    }

    return strbuf.toString();
}

如果我要执行

字符串

连接，并且没有任何其他理由使用Commons Lang，我可能会使用自己的方法来减少对外部库的依赖性。

对于这个特定问题，我更喜欢Apache StringUtils：

Joiner.on(separator).join(array)

---

与StringUtils相比，Joiner API具有流畅的设计，并且更加灵活，例如，

null

元素可以被跳过或替换为占位符。另外，

Joiner

还具有一个功能，可以使用键和值之间的分隔符连接贴图

可以将replace和replaceAll与正则表达式一起使用

String[] strings = {"a", "b", "c"};

String result = Arrays.asList(strings).toString().replaceAll("(^\\[|\\]$)", "").replace(", ", ",");

因为

Arrays.asList（）.toString（）

生成“[a，b，c]”，所以我们执行

replaceAll

以删除第一个和最后一个括号，然后（可选）您可以更改“，”顺序for“，”（您的新分隔符）

精简版（更少的字符）：

---

正则表达式非常强大，特别是字符串方法“replaceFirst”和“replaceAll”。试试看。

所有其他答案都包括运行时开销。。。比如使用ArrayList.toString（）.replaceAll（…），这非常浪费

我将给你零开销的最优算法； 它看起来不像其他选项那么漂亮，但在内部，这就是它们正在做的事情（在成堆的其他隐藏检查、多个数组分配和其他crud之后）

因为您已经知道您正在处理字符串，所以可以通过手动执行所有操作来节省大量数组分配。这并不漂亮，但是如果您跟踪其他实现所进行的实际方法调用，您会发现它的运行时开销尽可能小

public static String join(String separator, String ... values) {
  if (values.length==0)return "";//need at least one element
  //all string operations use a new array, so minimize all calls possible
  char[] sep = separator.toCharArray();

  // determine final size and normalize nulls
  int totalSize = (values.length - 1) * sep.length;// separator size
  for (int i = 0; i < values.length; i++) {
    if (values[i] == null)
      values[i] = "";
    else
      totalSize += values[i].length();
  }

  //exact size; no bounds checks or resizes
  char[] joined = new char[totalSize];
  int pos = 0;
  //note, we are iterating all the elements except the last one
  for (int i = 0, end = values.length-1; i < end; i++) {
    System.arraycopy(values[i].toCharArray(), 0, 
      joined, pos, values[i].length());
    pos += values[i].length();
    System.arraycopy(sep, 0, joined, pos, sep.length);
    pos += sep.length;
  }
  //now, add the last element; 
  //this is why we checked values.length == 0 off the hop
  System.arraycopy(values[values.length-1].toCharArray(), 0,
    joined, pos, values[values.length-1].length());

  return new String(joined);
}

公共静态字符串联接（字符串分隔符、字符串…值）{
if（values.length==0）返回“”；//至少需要一个元素
//所有字符串操作都使用新数组，因此尽可能减少所有调用
char[]sep=separator.toCharArray（）；
//确定最终大小并规范化空值
int totalSize=（values.length-1）*sep.length；//分隔符大小
对于（int i=0；i

一个没有任何第三方参与的快速简单的解决方案

public static String strJoin(String[] aArr, String sSep) {
    StringBuilder sbStr = new StringBuilder();
    for (int i = 0, il = aArr.length; i < il; i++) {
        if (i > 0)
            sbStr.append(sSep);
        sbStr.append(aArr[i]);
    }
    return sbStr.toString();
}

公共静态字符串strJoin（字符串[]aArr，字符串sSep）{
StringBuilder sbStr=新的StringBuilder（）；
对于（int i=0，il=aArr.length；i0）
sbStr.append（sSep）；
sbStr.append（aArr[i]）；
}
返回sbStr.toString（）；
}

在Java 1.8中有一个新功能，因此不需要Guava或Apache Commons：

String str = new StringJoiner(",").add("a").add("b").add("c").toString();

或者直接将集合与新的流api一起使用：

String str = Arrays.asList("a", "b", "c").stream().collect(Collectors.joining(","));

---

这个小功能总是派上用场的

public static String join(String[] strings, int startIndex, String separator) {
    StringBuffer sb = new StringBuffer();
    for (int i=startIndex; i < strings.length; i++) {
        if (i != startIndex) sb.append(separator);
        sb.append(strings[i]);
    }
    return sb.toString();
}

公共静态字符串联接（字符串[]字符串，int-startIndex，字符串分隔符）{
StringBuffer sb=新的StringBuffer（）；
for（int i=startIndex；i

此选项快速且清晰：

  public static String join(String separator, String... values) {
    StringBuilder sb = new StringBuilder(128);
    int end = 0;
    for (String s : values) {
      if (s != null) {
        sb.append(s);
        end = sb.length();
        sb.append(separator);
      }
    }
    return sb.substring(0, end);
  }

---

更简单的是，您可以只使用数组，这样您将得到一个字符串，其中数组的值用“，”分隔

因此，您将得到以下结果：concat=“[a，b，c]”

更新

然后，您可以按照Jeff的建议，使用子字符串除去括号

concat = concat.substring(1, concat.length() -1);

因此，您将使用concat=“a，b，c”

如果要使用Kotlin：

 val concat = myArray.joinToString(separator = ",") //"a,b,c"

---

如果您使用的是Android，则可以使用Java 8以非常简洁的方式执行此操作：

String.join(delimiter, elements);

这有三种方式：

1） 直接指定元素

String joined1 = String.join(",", "a", "b", "c");

2） 使用数组

String[] array = new String[] { "a", "b", "c" };
String joined2 = String.join(",", array);

3） 使用iterables

List<String> list = Arrays.asList(array);
String joined3 = String.join(",", list);

List List=Arrays.asList（array）；
String joined3=String.join（“，”列表）；

自Java 1.0以来，我所采用的方法不断发展，以提供可读性并维护与旧Java版本向后兼容的合理选项，同时还提供方法签名，作为apache commons-lang的替换。出于性能原因，我可以看到对使用Arrays.asList的一些可能的反对意见，但我更喜欢具有合理默认值的助手方法，而不重复执行实际工作的方法。这种方法为可靠的方法提供了适当的入口点，该方法不需要

String[] array = new String[] { "a", "b", "c" };
String joined2 = String.join(",", array);

List<String> list = Arrays.asList(array);
String joined3 = String.join(",", list);

public static String join(String[] values)
{
    return join(values, ',');
}

public static String join(String[] values, char delimiter)
{
    return join(Arrays.asList(values), String.valueOf(delimiter));
}

// To match Apache commons-lang: StringUtils.join(values, delimiter)
public static String join(String[] values, String delimiter)
{
    return join(Arrays.asList(values), delimiter);
}

public static String join(Collection<?> values)
{
    return join(values, ',');
}

public static String join(Collection<?> values, char delimiter)
{
    return join(values, String.valueOf(delimiter));
}

public static String join(Collection<?> values, String delimiter)
{
    if (values == null)
    {
        return new String();
    }

    StringBuffer strbuf = new StringBuffer();

    boolean first = true;

    for (Object value : values)
    {
        if (!first) { strbuf.append(delimiter); } else { first = false; }
        strbuf.append(value.toString());
    }

    return strbuf.toString();
}