像 PHP 的 join() 这样的数组的 Java 函数？答案

【问题标题】：Java function for arrays like PHP's join()?像 PHP 的 join() 这样的数组的 Java 函数？
【发布时间】：2010-12-03 16:18:57
【问题描述】：

我想用胶线加入String[]。有这个功能吗？

【问题讨论】：

Java 8 开箱即用地包含此功能。我建议读者滚动到@Marek Gregor 的答案（并投票给它..）
A quick and easy way to join array elements with a separator (the opposite of split) in Java的可能重复

标签： java arrays

【解决方案1】：

从Java8开始可以使用String.join()。

String.join(", ", new String[]{"Hello", "World", "!"})

生成：

Hello, World, !

否则，Apache Commons Lang 有一个 StringUtils 类，该类有一个 join 函数，它将数组连接在一起以形成一个 String。

例如：

StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")

生成以下String：

Hello, World, !

【讨论】：

为了人们搜索这个答案的好处，可能应该注意这也相当于 Perl 连接。
它说它对我来说是未定义的
@Ninjaxor 1. commons-lang*jar 必须在类路径中 2. import org.apache.commons.lang3.StringUtils;
我建议您编辑此答案以附加对 Java 8 中引入的新 String.join() 方法的引用。这样，大量阅读此已接受答案的人将从该知识中受益。目前，提到这一事实的最高投票答案在下面相当丢失......
值得一提的是，String.join() 仅适用于 List<CharSequence> 或 CharSequence[] 元素。

【解决方案2】：

如果您正在寻找在 android 中使用什么，它是：

String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)

例如：

String joined = TextUtils.join(";", MyStringArray);

【讨论】：

这显然是所有 Android 版本的最佳答案，因为 Java 8 只是在一段时间内出现在 Android 上。此解决方案使用内置的 Android 库，而不是这些愚蠢的“包含一个巨大的库来执行一个操作”的解决方案。
2017 年 9 月，Java 8 for Android 还很遥远。感谢您的回答！

【解决方案3】：

在 Java 8 中，您可以使用

1) 流 API：

String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));

2) 新的 String.join 方法：https://stackoverflow.com/a/21756398/466677

3) java.util.StringJoiner 类：http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html

【讨论】：

【解决方案4】：

你可以用大约十行代码轻松编写这样一个函数：

String combine(String[] s, String glue)
{
  int k = s.length;
  if ( k == 0 )
  {
    return null;
  }
  StringBuilder out = new StringBuilder();
  out.append( s[0] );
  for ( int x=1; x < k; ++x )
  {
    out.append(glue).append(s[x]);
  }
  return out.toString();
}

【讨论】：

根据你的良好做法......这些事情没有通用标准。
但是如果我包含大括号，那将增加两行代码，而且我不可能声称在 11 行中就完成了！
问题是当你过了一会儿，或者其他人，匆忙，在 if/for 中添加另一行而不添加大括号；或在 if(k==0) 之后删除 return null，在某些情况下会编译但会不正确。那么最好为那个右大括号多牺牲一行（开头可以保持在相同的 if/for 行）。
我认为虽然大多数语言都将此类功能打包到其核心中，但 Java 社区鼓励每个人重新发明轮子，这真是太棒了。
11 行？呸!我可以在1内完成！只需删除源文件中的所有换行符。

【解决方案5】：

一个小mod而不是使用substring()：

//join(String array,delimiter)
public static String join(String r[],String d)
{
        if (r.length == 0) return "";
        StringBuilder sb = new StringBuilder();
        int i;
        for(i=0;i<r.length-1;i++){
            sb.append(r[i]);
            sb.append(d);
        }
        sb.append(r[i]);
        return sb.toString();
}

【讨论】：

投了赞成票，因为您不需要添加任何库。
第 7 行：如果对每个 String 使用两次 .append() 而不是将它们连接起来然后附加到构建器，会更好吗？

【解决方案6】：

与最近的许多问题一样，Java 8 来拯救：

Java 8 向 java.lang.String 添加了一个新的静态方法，它完全符合您的要求：

public static String join(CharSequence delimeter, CharSequence... elements);

使用它：

String s = String.join(", ", new String[] {"Hello", "World", "!"});

结果：

"Hello, World, !"

【讨论】：

【解决方案7】：

Google guava 的库也有this kind of capability。您也可以从 API 中查看 String[] 示例。

如 api 中所述，请注意构建器方法的不变性。

它可以接受一组对象，因此它适用于您的情况。根据我以前的经验，我尝试加入一个可迭代的 Stack，它工作正常。

我的样品：

Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");

打印出来：|i am a coder|

【讨论】：

【解决方案8】：

给定：

String[] a = new String[] { "Hello", "World", "!" };

然后作为 coobird 答案的替代方案，胶水是“，”：

Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")

或与不同的字符串连接，例如“&”。

Arrays.asList(a).toString().replaceAll(", ", " &amp; ").replaceAll("^\\[|\\]$", "")

但是...只有当您知道数组或列表中的值不包含字符串“，”时，此选项才有效。

【讨论】：

Arrays.asList(a).toString() 为我想做的事工作

【解决方案9】：

如果您使用的是Spring Framework，那么您有StringUtils 类：

import static org.springframework.util.StringUtils.arrayToDelimitedString;

arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");

【讨论】：

【解决方案10】：

不在核心，不。搜索“java 数组连接字符串胶水”将为您提供一些关于如何实现此目的的代码 sn-ps。

例如

public static String join(Collection s, String delimiter) {
    StringBuffer buffer = new StringBuffer();
    Iterator iter = s.iterator();
    while (iter.hasNext()) {
        buffer.append(iter.next());
        if (iter.hasNext()) {
            buffer.append(delimiter);
        }
    }
    return buffer.toString();
}

【讨论】：

使用 StringBuilder（非线程安全）代替 StringBuffer（线程安全）以获得更好的性能。界面是一样的。
这似乎来自snippets.dzone.com/posts/show/91。 cmets 提出了一个大大改进的版本： public static String join( Iterable pColl, String separator ) { Iterator oIter； if ( pColl == null || ( !( oIter = pColl.iterator() ).hasNext() ) ) return ""; StringBuilder oBuilder = new StringBuilder(String.valueOf(oIter.next())); while ( oIter.hasNext() ) oBuilder.append( 分隔符 ).append( oIter.next() );返回 oBuilder.toString(); }

【解决方案11】：

如果您在这里寻找快速的数组到字符串的转换，请尝试Arrays.toString()。

创建传递的Object[] 的字符串表示形式。结果是用方括号 ("[]") 包围，每个元素都转换为字符串通过String.valueOf(Object) 并由", " 分隔。如果数组是 null，然后返回"null"。

【讨论】：

非常感谢！字符串由“，”分隔，整个东西周围都有“[]”，这对我来说很好。

【解决方案12】：

只是为了“我是最矮的”挑战，这里是我的；）

迭代：

public static String join(String s, Object... a) {
    StringBuilder o = new StringBuilder();
    for (Iterator<Object> i = Arrays.asList(a).iterator(); i.hasNext();)
        o.append(i.next()).append(i.hasNext() ? s : "");
    return o.toString();
}

递归：

public static String join(String s, Object... a) {
    return a.length == 0 ? "" : a[0] + (a.length == 1 ? "" : s + join(s, Arrays.copyOfRange(a, 1, a.length)));
}

【讨论】：

递归版本很优雅。肯定会使用它。
递归版本可能很优雅，但对于大型数组（“copyOfRange()”）效率低下。

【解决方案13】：

我所知道的没有内置的。

Apache Commons Lang 有一个名为 StringUtils 的类，其中包含许多连接函数。

【讨论】：

【解决方案14】：

我就是这样做的。

private String join(String[] input, String delimiter)
{
    StringBuilder sb = new StringBuilder();
    for(String value : input)
    {
        sb.append(value);
        sb.append(delimiter);
    }
    int length = sb.length();
    if(length > 0)
    {
        // Remove the extra delimiter
        sb.setLength(length - delimiter.length());
    }
    return sb.toString();
}

【讨论】：

【解决方案15】：

类似的选择

/**
 * @param delimiter 
 * @param inStr
 * @return String
 */
public static String join(String delimiter, String... inStr)
{
    StringBuilder sb = new StringBuilder();
    if (inStr.length > 0)
    {
        sb.append(inStr[0]);
        for (int i = 1; i < inStr.length; i++)
        {
            sb.append(delimiter);                   
            sb.append(inStr[i]);
        }
    }
    return sb.toString();
}

【讨论】：

【解决方案16】：

我的旋转。

public static String join(Object[] objects, String delimiter) {
  if (objects.length == 0) {
    return "";
  }
  int capacityGuess = (objects.length * objects[0].toString().length())
      + ((objects.length - 1) * delimiter.length());
  StringBuilder ret = new StringBuilder(capacityGuess);
  ret.append(objects[0]);
  for (int i = 1; i < objects.length; i++) {
    ret.append(delimiter);
    ret.append(objects[i]);
  }
  return ret.toString();
}

public static String join(Object... objects) {
  return join(objects, "");
}

【讨论】：

【解决方案17】：

你喜欢我只使用 String 类的方法的 3 行方式吗？

static String join(String glue, String[] array) {
    String line = "";
    for (String s : array) line += s + glue;
    return (array.length == 0) ? line : line.substring(0, line.length() - glue.length());
}

【讨论】：

这并不意味着高效。如果您需要效率，请使用StringBuilder：P

【解决方案18】：

从“str1”、“str2”、“”中获取“str1,str2”：

Stream.of("str1", "str2", "").filter(str -> !str.isEmpty()).collect(Collectors.joining(", "));

你也可以添加额外的空检查

【讨论】：

【解决方案19】：

如果您使用的是函数式 Java 库，并且由于某种原因无法使用 Java 8 中的 Streams（使用 Android + Retrolambda 插件时可能会出现这种情况），这里有一个函数式解决方案适合您：

String joinWithSeparator(List<String> items, String separator) {
    return items
            .bind(id -> list(separator, id))
            .drop(1)
            .foldLeft(
                    (result, item) -> result + item,
                    ""
            );
}

请注意，这不是最有效的方法，但它确实适用于小型列表。

【讨论】：

【解决方案20】：

无论您选择何种方法，请注意数组中的空值。它们的字符串表示为“null”，因此如果这不是您想要的行为，请跳过 null 元素。

String[] parts = {"Hello", "World", null, "!"};
Stream.of(parts)
      .filter(Objects::nonNull)
      .collect(Collectors.joining(" "));

【讨论】：

【解决方案21】：

我使用 StringBuilder 这样做：

public static String join(String[] source, String delimiter) {
    if ((null == source) || (source.length < 1)) {
        return "";
    }

    StringBuilder stringbuilder = new StringBuilder();
    for (String s : source) {
        stringbuilder.append(s + delimiter);
    }
    return stringbuilder.toString();
} // join((String[], String)

【讨论】：

s + delimiter（与加号运算符的字符串连接）违背了使用StringBuilder 的全部目的。
另外，这种方法意味着像：{"foo", "bar"} 这样带有分隔符 ":" 的数组将被转换为 "foo:bar:"

【解决方案22】：

我大部分时间都使用简单的速记技巧..

String op = new String;
for (int i : is) 
{
    op += candidatesArr[i-1]+",";
}
op = op.substring(0, op.length()-1);

【讨论】：

这仅适用于长度为 1 的分隔符，如果您想要不同长度的分隔符，则需要“幻数”（尽管非常本地化）。
追加时可以添加多个字符
而不是简单地做： op = op.substring(0, op.length() - ",".length());有什么大不了的？

【解决方案23】：

java.util.Arrays 有一个“asList”方法。与 java.util.List/ArrayList API 一起为您提供所需的一切：;

private static String[] join(String[] array1, String[] array2) {

    List<String> list = new ArrayList<String>(Arrays.asList(array1));
    list.addAll(Arrays.asList(array2));
    return list.toArray(new String[0]);
}

【讨论】：

问题是如何用分隔符连接字符串数组，而不是如何将两个字符串数组连接在一起。