一种逆转java String.split（）效果的方法？

我正在寻找一种方法，将字符串数组组合成分隔字符 一串与split（）相反的字符串

---

在我尝试写我自己的东西之前，我想问一下论坛（因为JDK拥有一切）

在JDK中没有我知道的方法。在类中有各种重载的

join（）

方法，这些方法可以执行您想要的操作。

如果您想使用集合来滚动自己的方法，则有几个示例。例如：

public static String join(AbstractCollection<String> s, String delimiter) {
    if (s == null || s.isEmpty()) return "";
    Iterator<String> iter = s.iterator();
    StringBuilder builder = new StringBuilder(iter.next());
    while( iter.hasNext() )
    {
        builder.append(delimiter).append(iter.next());
    }
    return builder.toString();
}

公共静态字符串联接（抽象集合、字符串分隔符）{
如果（s==null | | s.isEmpty（））返回“”；
迭代器iter=s.Iterator（）；
StringBuilder=新的StringBuilder（iter.next（））；
while（iter.hasNext（））
{
append（分隔符）.append（iter.next（））；
}
返回builder.toString（）；
}

我得到了以下示例

---

Google还在其Google Collections库中提供了一个joiner类：

---

根据前面的所有答案：

public static String join(Iterable<? extends Object> elements, CharSequence separator) 
{
    StringBuilder builder = new StringBuilder();

    if (elements != null)
    {
        Iterator<? extends Object> iter = elements.iterator();
        if(iter.hasNext())
        {
            builder.append( String.valueOf( iter.next() ) );
            while(iter.hasNext())
            {
                builder
                    .append( separator )
                    .append( String.valueOf( iter.next() ) );
            }
        }
    }

    return builder.toString();
}

publicstaticstringjoin（Iterable我更喜欢这个：

public String join(Collection<String> strCollection, String delimiter) {
    String joined = "";
    int noOfItems = 0;
    for (String item : strCollection) {
        joined += item;
        if (++noOfItems < strCollection.size())
            joined += delimiter;
    }
    return joined;
}

公共字符串联接（集合strCollection，字符串分隔符）{
字符串连接=”；
int noOfItems=0；
for（字符串项：strCollection）{
已加入+=项目；
如果（++noOfItems

这是迄今为止我找到的最整洁的解决方案。
（不要担心使用原始字符串对象而不是StringBuilder。现代Java编译器无论如何都使用StringBuilder，但此代码更具可读性）。
您可以将此功能从
数组
实用程序包中隐藏出来

导入java.util.array；
...
字符串delim=“：”，
csv_record=“Field0:Field1:Field2”，
字段[]=csv_记录分割（delim）；
String\u record=Arrays.toString（字段）
.替换（“，”，delim）
.replaceAll（“[\\[\]]”，“”）；
如果你有一个int[]，最简单的方法就是数组。toString（）

。

这个方法也不错：

public static String join(String delimitor,String ... subkeys) {
    String result = null;
    if(null!=subkeys && subkeys.length>0) {
        StringBuffer joinBuffer = new StringBuffer(subkeys[0]);
        for(int idx=1;idx<subkeys.length;idx++) {
            joinBuffer.append(delimitor).append(subkeys[idx]);
        }
        result = joinBuffer.toString();
    }
    return result;
}

公共静态字符串联接（字符串定界器、字符串…子键）{
字符串结果=null；
if（null！=子键和子键（&S）。长度>0）{
StringBuffer joinBuffer=新的StringBuffer（子键[0]）；
对于（intidx=1；idx我写了这个：

public static String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    Iterator<String> iter = col.iterator();
    if (iter.hasNext())
        sb.append(iter.next());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next());
    }
    return sb.toString();
}

并放入
.tld
文件：

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
    <function>
        <name>join</name>
        <function-class>com.core.util.ReportUtil</function-class>
        <function-signature>java.lang.String join(java.util.List, java.lang.String)</function-signature>
    </function>
</taglib>


至少从2009年开始就有一个开放的特性请求，其长短在于它将成为JDK 8的java.util.StringJoiner类功能的一部分

如果您感兴趣，这里是Oracle的问题。

下面是字符串数组上新的JDK 8 StringJoiner的示例

String[] a = new String[]{"first","second","third"};
StringJoiner sj = new StringJoiner(",");
for(String s:a) sj.add(s);
System.out.println(sj); //first,second,third

字符串中的实用程序方法使此操作更加简单：

String s = String.join(",", stringArray);

对于Android：在
有以下几种方法：

public static String join (CharSequence delimiter, Iterable tokens)
public static String join (CharSequence delimiter, Object[] tokens)

返回包含由分隔符连接的标记的字符串

tokens——要连接的数组对象。字符串将通过调用object.toString（）从对象中形成。
为了完整性，我想补充一点，一般情况下不能反转，因为它接受正则表达式

“hello\uu world”。拆分（“\uu+”）；
产生
[“hello”，“world”]


“hello\u world”。拆分（“\u+”）
产生
[“hello”，“world”]

这些从不同的起点产生相同的结果。分裂不是一对一的操作，因此是不可逆的

综上所述，如果你假设你的参数是一个固定的字符串，而不是正则表达式，那么你当然可以使用许多贴出的答案中的一个来实现这一点。
如果你使用jdk8，请参阅@Nathaniel Johnson's，因为那更好

我认为这里的很多答案都很复杂或者不容易理解。既然分支预测如此高效，为什么不使用if语句呢

public static String join(List<String> fooList){

    if (fooList.isEmpty()) return "";

    StringBuilder sb = null;

    for (String element : fooList) {

        if (sb == null) {
            sb = new StringBuilder();
        } else {
            sb.append(", ");
        }

        sb.append(element);
    }
    return sb.toString();
}

公共静态字符串联接（列表列表）{
if（whoolist.isEmpty（））返回“”；
StringBuilder sb=null；
for（字符串元素：傻瓜）{
如果（sb==null）{
sb=新的StringBuilder（）；
}否则{
某人加上（“，”）；
}
某人附加（元素）；
}
使某人返回字符串（）；
}

值得一提的是，Apache使用了一个简单的for循环，其中包含一个if语句，如下所示（它使用一个数组作为其索引来知道第一个元素），openjdk 8也这样做，但使用的是单独的方法调用，而不是简单的循环。
下面的代码给出了一个基本思路。但这不是最好的解决方案

public static String splitJoin(String sourceStr, String delim,boolean trim,boolean ignoreEmpty){
    return join(Arrays.asList(sourceStr.split(delim)), delim, ignoreEmpty);
}


public static String join(List<?> list, String delim, boolean ignoreEmpty) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        if (ignoreEmpty && !StringUtils.isBlank(list.get(i).toString())) {
            sb.append(delim);
            sb.append(list.get(i).toString().trim());
        }
    }
    return sb.toString();
}

publicstaticstringsplitjoin（stringsourcestr、stringdelim、boolean trim、boolean ignoreEmpty）{
返回join（Arrays.asList（sourceStr.split（delim）），delim，ignoreEmpty）；
}
公共静态字符串联接（列表、字符串delim、布尔ignoreEmpty）{
int len=list.size（）；
如果（len==0）
返回“”；
StringBuilder sb=新的StringBuilder（list.get（0.toString（））；
对于（int i=1；i
由于JDK8，我非常喜欢Streams和Lambda，因此我建议：

public static String join( String delimiter, String[] array )
{
    return Arrays.asList( array ).stream().collect( Collectors.joining( delimiter ) );
}

我倾向于省略空检查，因为行为将是相同的，为什么会用特殊情况使代码复杂化？另一方面，空检查可能是正确的。@Carl:我完全同意你的空检查，并补充了这一点。检查空集合允许函数跳过不必要的迭代器创建和一个StringBuffer，所以我把它留在了。你应该使用StringBuilder而不是StringBuffer，因为StringBuffer增加了同步的开销。你不需要同步方法变量（因为只有一个线程会使用它）。您的join方法应该接受Collection，而不是AbstractCollection。更好的是，它可以接受Iterable，这使它更通用。@Steve:这两种方法都可以接受。您可以将其设置为
public static String join(List<String> fooList){

    if (fooList.isEmpty()) return "";

    StringBuilder sb = null;

    for (String element : fooList) {

        if (sb == null) {
            sb = new StringBuilder();
        } else {
            sb.append(", ");
        }

        sb.append(element);
    }
    return sb.toString();
}

public static String splitJoin(String sourceStr, String delim,boolean trim,boolean ignoreEmpty){
    return join(Arrays.asList(sourceStr.split(delim)), delim, ignoreEmpty);
}


public static String join(List<?> list, String delim, boolean ignoreEmpty) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        if (ignoreEmpty && !StringUtils.isBlank(list.get(i).toString())) {
            sb.append(delim);
            sb.append(list.get(i).toString().trim());
        }
    }
    return sb.toString();
}

public static String join( String delimiter, String[] array )
{
    return Arrays.asList( array ).stream().collect( Collectors.joining( delimiter ) );
}