在 Java 中构建一串分隔项的最佳方法是什么？

Question

在使用 Java 应用程序时，我最近需要组装一个以逗号分隔的值列表以传递给另一个 web 服务，而无需事先知道有多少元素。 我能想到的最好的事情是这样的：

public String appendWithDelimiter( String original, String addition, String delimiter ) {
    if ( original.equals( "" ) ) {
        return addition;
    } else {
        return original + delimiter + addition;
    }
}

String parameterString = "";
if ( condition ) parameterString = appendWithDelimiter( parameterString, "elementName", "," );
if ( anotherCondition ) parameterString = appendWithDelimiter( parameterString, "anotherElementName", "," );

我意识到这不是特别有效，因为到处都在创建字符串，但我的目的是为了清晰而不是优化。

在 Ruby 中，我可以这样做，感觉更优雅：

parameterArray = [];
parameterArray << "elementName" if condition;
parameterArray << "anotherElementName" if anotherCondition;
parameterString = parameterArray.join(",");

但由于 Java 缺少连接命令，我想不出任何等效的东西。

那么，在 Java 中执行此操作的最佳方法是什么？

Answer 1

预 Java 8：

Apache 的 commons lang 在这里是您的朋友 - 它提供了一种与您在 Ruby 中引用的方法非常相似的连接方法：

StringUtils.join(java.lang.Iterable,char)

---

Java 8：

Java 8 通过StringJoiner和String.join()提供开箱即用的连接。 下面的片段显示了如何使用它们：

StringJoiner

StringJoiner joiner = new StringJoiner(",");
joiner.add("01").add("02").add("03");
String joinedString = joiner.toString(); // "01,02,03"

---

String.join(CharSequence delimiter, CharSequence... elements))

String joinedString = String.join(" - ", "04", "05", "06"); // "04 - 05 - 06"

---

String.join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

List<String> strings = new LinkedList<>();
strings.add("Java");strings.add("is");
strings.add("cool");
String message = String.join(" ", strings);
//message returned is: "Java is cool"

Answer 2

您可以编写一个适用于 java.util.Lists 的小连接式实用程序方法

public static String join(List<String> list, String delim) {

    StringBuilder sb = new StringBuilder();

    String loopDelim = "";

    for(String s : list) {

        sb.append(loopDelim);
        sb.append(s);            

        loopDelim = delim;
    }

    return sb.toString();
}

然后像这样使用它：

    List<String> list = new ArrayList<String>();

    if( condition )        list.add("elementName");
    if( anotherCondition ) list.add("anotherElementName");

    join(list, ",");

Answer 3

在 Android 的情况下，来自 commons 的 StringUtils class 不可用，所以为此我使用了

android.text.TextUtils.join(CharSequence delimiter, Iterable tokens)

http://developer.android.com/reference/android/text/TextUtils.html

Answer 4

Google 的 Guava 库有com.google.common.base.Joiner class 有助于解决此类任务。

样品：

"My pets are: " + Joiner.on(", ").join(Arrays.asList("rabbit", "parrot", "dog")); 
// returns "My pets are: rabbit, parrot, dog"

Joiner.on(" AND ").join(Arrays.asList("field1=1" , "field2=2", "field3=3"));
// returns "field1=1 AND field2=2 AND field3=3"

Joiner.on(",").skipNulls().join(Arrays.asList("London", "Moscow", null, "New York", null, "Paris"));
// returns "London,Moscow,New York,Paris"

Joiner.on(", ").useForNull("Team held a draw").join(Arrays.asList("FC Barcelona", "FC Bayern", null, null, "Chelsea FC", "AC Milan"));
// returns "FC Barcelona, FC Bayern, Team held a draw, Team held a draw, Chelsea FC, AC Milan"

---

这是 一篇关于 Guava 的字符串实用程序的文章。

Answer 5

在 Java 8 中，您可以使用String.join() ：

List<String> list = Arrays.asList("foo", "bar", "baz");
String joined = String.join(" and ", list); // "foo and bar and baz"

另请查看 Stream API 示例的此答案。

Answer 6

在 Java 8 你可以这样做：

list.stream().map(Object::toString)
        .collect(Collectors.joining(delimiter));

如果列表有空值，您可以使用：

list.stream().map(String::valueOf)
        .collect(Collectors.joining(delimiter))

它还支持前缀和后缀：

list.stream().map(String::valueOf)
        .collect(Collectors.joining(delimiter, prefix, suffix));

Answer 7

您可以概括它，但正如您所说，Java 中没有加入。

这可能会更好。

public static String join(Iterable<? extends CharSequence> s, String delimiter) {
    Iterator<? extends CharSequence> iter = s.iterator();
    if (!iter.hasNext()) return "";
    StringBuilder buffer = new StringBuilder(iter.next());
    while (iter.hasNext()) buffer.append(delimiter).append(iter.next());
    return buffer.toString();
}

Answer 8

使用基于java.lang.StringBuilder的方法。 （“一个可变的字符序列。”）

就像您提到的那样，所有这些字符串连接都在创建字符串。 StringBuilder不会那样做。

为什么使用StringBuilder而不是StringBuffer ？ 来自StringBuilder javadoc：

在可能的情况下，建议优先使用此 class 而不是 StringBuffer，因为它在大多数实现下会更快。

Answer 9

我会使用谷歌 Collections。 有一个不错的加入设施。
http://google-collections.googlecode.com/svn/trunk/javadoc/index.html?com/google/common/base/Join.ZFC35FDC70D5FC69D2693EZ883A822C7A

但如果我想自己写，

package util;

import java.util.ArrayList;
import java.util.Iterable;
import java.util.Collections;
import java.util.Iterator;

public class Utils {
    // accept a collection of objects, since all objects have toString()
    public static String join(String delimiter, Iterable<? extends Object> objs) {
        if (objs.isEmpty()) {
            return "";
        }
        Iterator<? extends Object> iter = objs.iterator();
        StringBuilder buffer = new StringBuilder();
        buffer.append(iter.next());
        while (iter.hasNext()) {
            buffer.append(delimiter).append(iter.next());
        }
        return buffer.toString();
    }

    // for convenience
    public static String join(String delimiter, Object... objs) {
        ArrayList<Object> list = new ArrayList<Object>();
        Collections.addAll(list, objs);
        return join(delimiter, list);
    }
}

我认为它更适合使用 object 集合，因为现在您不必在加入对象之前将它们转换为字符串。

Answer 10

Apache commons StringUtils class 有一个join方法。

Answer 11

Java 8

stringCollection.stream().collect(Collectors.joining(", "));

Answer 12

Java 8 原生型

List<Integer> example;
example.add(1);
example.add(2);
example.add(3);
...
example.stream().collect(Collectors.joining(","));

Java 8 定制 Object：

List<Person> person;
...
person.stream().map(Person::getAge).collect(Collectors.joining(","));

Answer 13

使用 StringBuilder 和 class Separator

StringBuilder buf = new StringBuilder();
Separator sep = new Separator(", ");
for (String each : list) {
    buf.append(sep).append(each);
}

分隔符包裹一个分隔符。 分隔符由 Separator 的toString方法返回，除非在第一次调用时返回空字符串！

class Separator的源代码

public class Separator {

    private boolean skipFirst;
    private final String value;

    public Separator() {
        this(", ");
    }

    public Separator(String value) {
        this.value = value;
        this.skipFirst = true;
    }

    public void reset() {
        skipFirst = true;
    }

    public String toString() {
        String sep = skipFirst ? "" : value;
        skipFirst = false;
        return sep;
    }

}

Answer 14

还有一个最小的（如果您不想为了加入字符串而将 Apache Commons 或 Gauva 包含到项目依赖项中）

/**
 *
 * @param delim : String that should be kept in between the parts
 * @param parts : parts that needs to be joined
 * @return  a String that's formed by joining the parts
 */
private static final String join(String delim, String... parts) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < parts.length - 1; i++) {
        builder.append(parts[i]).append(delim);
    }
    if(parts.length > 0){
        builder.append(parts[parts.length - 1]);
    }
    return builder.toString();
}

Answer 15

您可以为此使用 Java 的StringBuilder类型。 还有StringBuffer ，但它包含通常不必要的额外线程安全逻辑。

Answer 16

如果您使用的是Eclipse Collections ，则可以使用makeString()或appendString() 。

makeString()返回一个String表示，类似于toString() 。

它具有三个 forms

• makeString(start, separator, end)
• makeString(separator)默认开始和结束为空字符串
• makeString()默认分隔符为", " （逗号和空格）

代码示例：

MutableList<Integer> list = FastList.newListWith(1, 2, 3);
assertEquals("[1/2/3]", list.makeString("[", "/", "]"));
assertEquals("1/2/3", list.makeString("/"));
assertEquals("1, 2, 3", list.makeString());
assertEquals(list.toString(), list.makeString("[", ", ", "]"));

appendString()类似于makeString() ，但它附加到Appendable （如StringBuilder ）并且是void 。 它具有相同的三个 forms，还有一个附加的第一个参数，即 Appendable。

MutableList<Integer> list = FastList.newListWith(1, 2, 3);
Appendable appendable = new StringBuilder();
list.appendString(appendable, "[", "/", "]");
assertEquals("[1/2/3]", appendable.toString());

如果您无法将您的收藏转换为 Eclipse Collections 类型，只需使用相关适配器对其进行调整。

List<Object> list = ...;
ListAdapter.adapt(list).makeString(",");

注意：我是 Eclipse collections 的提交者。

Answer 17

如果您使用的是 Spring MVC，那么您可以尝试以下步骤。

import org.springframework.util.StringUtils;

List<String> groupIds = new List<String>;   
groupIds.add("a");    
groupIds.add("b");    
groupIds.add("c");

String csv = StringUtils.arrayToCommaDelimitedString(groupIds.toArray());

这将导致a,b,c

Answer 18

为什么不编写自己的 join() 方法？ 它将作为参数集合的字符串和分隔符字符串。 在该方法中迭代集合并在 StringBuffer 中构建您的结果。

Answer 19

对于那些在 Spring 上下文中的人，他们的StringUtils class 也很有用：

有许多有用的快捷方式，例如：

• collectionToCommaDelimitedString(Collection coll)
• collectionToDelimitedString(Collection coll, String delim)
• arrayToDelimitedString(Object[] arr, String delim)

和许多其他人。

如果您尚未使用 Java 8 并且您已经在 Spring 上下文中，这可能会有所帮助。

我更喜欢它而不是 Apache Commons（虽然也非常好），因为它更容易像这样：

// Encoding Set<String> to String delimited 
String asString = org.springframework.util.StringUtils.collectionToDelimitedString(codes, ";");

// Decoding String delimited to Set
Set<String> collection = org.springframework.util.StringUtils.commaDelimitedListToSet(asString);

Answer 20

您可能应该使用带有append方法的StringBuilder来构建您的结果，但除此之外，这与 Java 提供的解决方案一样好。

Answer 21

为什么不在 Java 中执行与在 ruby 中相同的操作，即仅在将所有片段添加到数组后创建分隔符分隔字符串？

ArrayList<String> parms = new ArrayList<String>();
if (someCondition) parms.add("someString");
if (anotherCondition) parms.add("someOtherString");
// ...
String sep = ""; StringBuffer b = new StringBuffer();
for (String p: parms) {
    b.append(sep);
    b.append(p);
    sep = "yourDelimiter";
}

您可能希望在单独的辅助方法中移动该 for 循环，并使用 StringBuilder 而不是 StringBuffer ...

编辑：修复了追加的顺序。

Answer 22

使用 Java 5 个变量 args，因此您不必将所有字符串显式地填充到集合或数组中：

import junit.framework.Assert;
import org.junit.Test;

public class StringUtil
{
    public static String join(String delim, String... strings)
    {
        StringBuilder builder = new StringBuilder();

        if (strings != null)
        {
            for (String str : strings)
            {
                if (builder.length() > 0)
                {
                    builder.append(delim).append(" ");
                }
                builder.append(str);
            }
        }           
        return builder.toString();
    }
    @Test
    public void joinTest()
    {
        Assert.assertEquals("", StringUtil.join(",", null));
        Assert.assertEquals("", StringUtil.join(",", ""));
        Assert.assertEquals("", StringUtil.join(",", new String[0]));
        Assert.assertEquals("test", StringUtil.join(",", "test"));
        Assert.assertEquals("foo, bar", StringUtil.join(",", "foo", "bar"));
        Assert.assertEquals("foo, bar, x", StringUtil.join(",", "foo", "bar", "x"));
    }
}

Answer 23

使用Dollar很简单，只需键入：

String joined = $(aCollection).join(",");

注意：它也适用于数组和其他数据类型

执行

在内部，它使用了一个非常巧妙的技巧：

@Override
public String join(String separator) {
    Separator sep = new Separator(separator);
    StringBuilder sb = new StringBuilder();

    for (T item : iterable) {
        sb.append(sep).append(item);
    }

    return sb.toString();
}

class Separator仅在第一次调用时返回空字符串，然后返回分隔符：

class Separator {

    private final String separator;
    private boolean wasCalled;

    public Separator(String separator) {
        this.separator = separator;
        this.wasCalled = false;
    }

    @Override
    public String toString() {
        if (!wasCalled) {
            wasCalled = true;
            return "";
        } else {
            return separator;
        }
    }
}

Answer 24

修复答案 Rob Dickerson。

它更容易使用：

public static String join(String delimiter, String... values)
{
    StringBuilder stringBuilder = new StringBuilder();

    for (String value : values)
    {
        stringBuilder.append(value);
        stringBuilder.append(delimiter);
    }

    String result = stringBuilder.toString();

    return result.isEmpty() ? result : result.substring(0, result.length() - 1);
}

Answer 25

来自 izb 的版本略有改进 [速度]：

public static String join(String[] strings, char del)
{
    StringBuilder sb = new StringBuilder();
    int len = strings.length;

    if(len > 1) 
    {
       len -= 1;
    }else
    {
       return strings[0];
    }

    for (int i = 0; i < len; i++)
    {
       sb.append(strings[i]).append(del);
    }

    sb.append(strings[i]);

    return sb.toString();
}

Answer 26

我个人经常使用以下简单的解决方案进行日志记录：

List lst = Arrays.asList("ab", "bc", "cd");
String str = lst.toString().replaceAll("[\\[\\]]", "");

Answer 27

如果要在对象属性列表中应用逗号。 这是我发现最有用的方式。

这里getName()是 class 的字符串属性，我一直在尝试添加“，”。

字符串消息 = listName.stream().map(list -> list.getName()).collect(Collectors.joining(", "));

Answer 28

你可以尝试这样的事情：

StringBuilder sb = new StringBuilder();
if (condition) { sb.append("elementName").append(","); }
if (anotherCondition) { sb.append("anotherElementName").append(","); }
String parameterString = sb.toString();

Answer 29

所以基本上是这样的：

public static String appendWithDelimiter(String original, String addition, String delimiter) {

if (original.equals("")) {
    return addition;
} else {
    StringBuilder sb = new StringBuilder(original.length() + addition.length() + delimiter.length());
        sb.append(original);
        sb.append(delimiter);
        sb.append(addition);
        return sb.toString();
    }
}

Answer 30

不知道这是否真的更好，但至少它使用了 StringBuilder，这可能会稍微更有效率。

如果您可以在进行任何参数定界之前建立参数列表，那么下面是一种更通用的方法。

// Answers real question
public String appendWithDelimiters(String delimiter, String original, String addition) {
    StringBuilder sb = new StringBuilder(original);
    if(sb.length()!=0) {
        sb.append(delimiter).append(addition);
    } else {
        sb.append(addition);
    }
    return sb.toString();
}


// A more generic case.
// ... means a list of indeterminate length of Strings.
public String appendWithDelimitersGeneric(String delimiter, String... strings) {
    StringBuilder sb = new StringBuilder();
    for (String string : strings) {
        if(sb.length()!=0) {
            sb.append(delimiter).append(string);
        } else {
            sb.append(string);
        }
    }

    return sb.toString();
}

public void testAppendWithDelimiters() {
    String string = appendWithDelimitersGeneric(",", "string1", "string2", "string3");
}

Answer 31

您的方法还不错，但您应该使用 StringBuffer 而不是使用 + 号。 + 有一个很大的缺点，即为每个单独的操作创建一个新的 String 实例。 你的字符串越长，开销就越大。 所以使用 StringBuffer 应该是最快的方法：

public StringBuffer appendWithDelimiter( StringBuffer original, String addition, String delimiter ) {
        if ( original == null ) {
                StringBuffer buffer = new StringBuffer();
                buffer.append(addition);
                return buffer;
        } else {
                buffer.append(delimiter);
                buffer.append(addition);
                return original;
        }
}

完成创建字符串后，只需在返回的 StringBuffer 上调用 toString()。

Answer 32

如果您的代码不是线程化的，则应该使用 StringBuilder，如果是，则应使用 StringBuffer，而不是使用字符串连接。

Answer 33

你让这变得比它必须的复杂一点。 让我们从示例的结尾开始：

String parameterString = "";
if ( condition ) parameterString = appendWithDelimiter( parameterString, "elementName", "," );
if ( anotherCondition ) parameterString = appendWithDelimiter( parameterString, "anotherElementName", "," );

随着使用 StringBuilder 而不是 String 的微小变化，这变为：

StringBuilder parameterString = new StringBuilder();
if (condition) parameterString.append("elementName").append(",");
if (anotherCondition) parameterString.append("anotherElementName").append(",");
...

完成后（我假设您还必须检查其他一些条件），只需确保使用以下命令删除尾逗号：

if (parameterString.length() > 0) 
    parameterString.deleteCharAt(parameterString.length() - 1);

最后，得到你想要的字符串

parameterString.toString();

您还可以将第二次调用 append 中的“，”替换为可以设置为任何内容的通用分隔符字符串。 如果您有一个您知道需要 append 的东西的列表（无条件），您可以将此代码放在一个采用字符串列表的方法中。

Answer 34

//Note: if you have access to Java5+, 
//use StringBuilder in preference to StringBuffer.  
//All that has to be replaced is the class name.  
//StringBuffer will work in Java 1.4, though.

appendWithDelimiter( StringBuffer buffer, String addition, 
    String delimiter ) {
    if ( buffer.length() == 0) {
        buffer.append(addition);
    } else {
        buffer.append(delimiter);
        buffer.append(addition);
    }
}


StringBuffer parameterBuffer = new StringBuffer();
if ( condition ) { 
    appendWithDelimiter(parameterBuffer, "elementName", "," );
}
if ( anotherCondition ) {
    appendWithDelimiter(parameterBuffer, "anotherElementName", "," );
}

//Finally, to return a string representation, call toString() when returning.
return parameterBuffer.toString(); 

Answer 35

不要使用 join、delimiter 或 StringJoiner 方法和类，因为它们在 Android N 和 O 版本下不起作用。 否则使用简单的代码逻辑作为；

 List<String> tags= emp.getTags();
        String tagTxt="";
        for (String s : tags) {
            if (tagTxt.isEmpty()){
                tagTxt=s;
            }else
                tagTxt= tagTxt+", "+s;
        }  

Answer 36

因此，您可能会做一些事情来获得您正在寻找的感觉：

1) 扩展列表 class - 并向其中添加连接方法。 join 方法将简单地完成连接和添加分隔符的工作（这可能是 join 方法的参数）

2) 看起来 Java 7 将向 java 添加扩展方法 - 这允许您将特定方法附加到 class 上，甚至可以将其添加为方法方法以加入或添加方法：收藏。

现在，解决方案 1 可能是唯一现实的解决方案，尽管由于 Java 7 还没有推出:) 但它应该可以正常工作。

要使用这两者，您只需像往常一样将所有项目添加到列表或集合中，然后调用新的自定义方法来“加入”它们。

Answer 37

public static String join(String[] strings, char del)
{
    StringBuffer sb = new StringBuffer();
    int len = strings.length;
    boolean appended = false;
    for (int i = 0; i < len; i++)
    {
        if (appended)
        {
            sb.append(del);
        }
        sb.append(""+strings[i]);
        appended = true;
    }
    return sb.toString();
}