在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做这个的最好方法是什么？
答案 0 :(得分：484)
Apache的commons lang是你的朋友 - 它提供了一个非常类似于你在Ruby中引用的连接方法：
StringUtils.join(java.lang.Iterable,char)
Java 8通过StringJoiner和String.join()提供开箱即用的加入功能。下面的代码段显示了如何使用它们：
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"
答案 1 :(得分：51)
您可以编写一个适用于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, ",");
答案 2 :(得分：44)
在Android的情况下，来自commons的StringUtils类不可用，所以为此我使用了
android.text.TextUtils.join(CharSequence delimiter, Iterable tokens)
http://developer.android.com/reference/android/text/TextUtils.html
答案 3 :(得分：31)
Google's Guava library有 com.google.common.base.Joiner 类，有助于解决此类任务。
样品：
"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"
答案 4 :(得分：25)
在Java 8中，您可以使用String.join()：
List<String> list = Arrays.asList("foo", "bar", "baz");
String joined = String.join(" and ", list); // "foo and bar and baz"
另请参阅this answer以获取Stream API示例。
答案 5 :(得分：20)
你可以概括它，但是你可以说，Java中没有连接。
This可能效果更好。
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();
}
答案 6 :(得分：15)
使用基于java.lang.StringBuilder的方法！ （“一个可变的字符序列。”）
就像你提到的那样，所有这些字符串连接都在创建字符串。 StringBuilder不会这样做。
为什么StringBuilder代替StringBuffer？来自StringBuilder javadoc：
在可能的情况下，建议首先使用此类优先于StringBuffer，因为在大多数实现中它会更快。
答案 7 :(得分：12)
list.stream().map(Object::toString)
.collect(Collectors.joining(delimiter));
如果list有空值，你可以使用：
list.stream().map(String::valueOf)
.collect(Collectors.joining(delimiter))
答案 8 :(得分：10)
我会使用Google Collections。有一个很好的加入设施。
http://google-collections.googlecode.com/svn/trunk/javadoc/index.html?com/google/common/base/Join.html
但如果我想自己写，
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);
}
}
我认为它对于对象集合更有效，因为现在您不必在加入对象之前将对象转换为字符串。
答案 9 :(得分：8)
Apache commons StringUtils类有一个连接方法。
答案 10 :(得分：4)
stringCollection.stream().collect(Collectors.joining(", "));
答案 11 :(得分：3)
使用StringBuilder和类Separator
StringBuilder buf = new StringBuilder();
Separator sep = new Separator(", ");
for (String each : list) {
buf.append(sep).append(each);
}
分隔符包装分隔符。分隔符的toString方法返回分隔符，除非第一次调用返回空字符串！
课程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;
}
}
答案 12 :(得分：3)
最小的一个（如果你不想仅仅为了加入字符串而将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();
}
答案 13 :(得分：3)
您可以使用Java的StringBuilder类型。还有StringBuffer，但它包含额外的线程安全逻辑，这通常是不必要的。
答案 14 :(得分：2)
如果您使用的是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
答案 15 :(得分：2)
如果您使用的是Eclipse Collections，则可以使用makeString()或appendString()。
makeString()返回String代表，类似于toString()。
它有三种形式
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。它有三种形式，附加的第一个参数是Appendable。
MutableList<Integer> list = FastList.newListWith(1, 2, 3);
Appendable appendable = new StringBuilder();
list.appendString(appendable, "[", "/", "]");
assertEquals("[1/2/3]", appendable.toString());
如果您无法将集合转换为Eclipse集合类型，只需使用相关适配器进行调整即可。
List<Object> list = ...;
ListAdapter.adapt(list).makeString(",");
注意：我是Eclipse集合的提交者。
答案 16 :(得分：2)
为什么不编写自己的join（）方法？它将作为字符串的参数集合和分隔符字符串。在该方法中迭代集合并在StringBuffer中构建结果。
答案 17 :(得分：1)
对于那些处于Spring环境中的人，他们的StringUtils类也很有用：
有许多有用的快捷方式，例如：
和其他许多人。
如果您尚未使用Java 8并且已经处于Spring环境中，那么这将非常有用。
我更喜欢它反对Apache Commons（尽管也非常好），对于Collection支持这样更容易：
// 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);
答案 18 :(得分：1)
Java 8 Native Type
List<Integer> example;
example.add(1);
example.add(2);
example.add(3);
...
example.stream().collect(Collectors.joining(","));
Java 8自定义对象：
List<Person> person;
...
person.stream().map(Person::getAge).collect(Collectors.joining(","));
答案 19 :(得分：1)
使用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"));
}
}
答案 20 :(得分：1)
为什么不用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 ......
编辑：修正了附加顺序。
答案 21 :(得分：1)
您应该使用StringBuilder和append方法来构建结果，但除此之外，这与Java必须提供的解决方案一样好。
答案 22 :(得分：0)
所以你可能会做一些事情来感觉它似乎正在寻找：
1）扩展List类 - 并为其添加join方法。 join方法只是简单地连接和添加分隔符（可能是连接方法的参数）的工作
2）看起来Java 7将向java添加扩展方法 - 这允许您只需将特定方法附加到类：因此您可以编写该连接方法并将其作为扩展方法添加到List甚至收藏。
解决方案1可能是唯一现实的解决方案，但是现在，因为Java 7还没有出来:)但它应该可以正常工作。
要同时使用这两个项目，您只需像往常一样将所有项目添加到列表或集合中，然后调用新的自定义方法以“加入”它们。
答案 23 :(得分：0)
使用Dollar很简单，只需输入：
String joined = $(aCollection).join(",");
注意：它也适用于Array和其他数据类型
在内部，它使用了一个非常巧妙的技巧：
@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();
}
类Separator仅在第一次调用时返回空String，然后返回分隔符：
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;
}
}
}
答案 24 :(得分：0)
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();
}
答案 25 :(得分：0)
//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();
答案 26 :(得分：0)
你让它变得有点复杂。让我们从你的例子的结尾开始：
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();
您还可以在第二个调用中替换“，”，以附加可以设置为任何内容的通用分隔符字符串。如果你有一个你知道需要附加的东西的列表（非条件），你可以把这个代码放在一个带有字符串列表的方法中。
答案 27 :(得分：0)
如果你的代码没有线程化，你应该使用StringBuilder，而不是使用字符串连接，如果是，则应该使用StringBuffer。
答案 28 :(得分：0)
你的方法不是太糟糕，但你应该使用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（）。
答案 29 :(得分：0)
不知道这是否真的更好，但至少它使用的是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");
}
答案 30 :(得分：0)
所以基本上是这样的：
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();
}
}
答案 31 :(得分：0)
修复回答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);
}
答案 32 :(得分：0)
我个人经常使用以下简单的解决方案进行日志记录：
{{1}}
答案 33 :(得分：0)
您可以尝试这样的事情：
StringBuilder sb = new StringBuilder();
if (condition) { sb.append("elementName").append(","); }
if (anotherCondition) { sb.append("anotherElementName").append(","); }
String parameterString = sb.toString();
答案 34 :(得分：0)
如果要在对象属性列表中应用逗号。这是我发现最有用的方法。
此处 getName（）是我试图添加“，”的类的字符串属性。
字符串消息= listName.stream（）。map（list-> list.getName（））。collect（Collectors.joining（“，”））;
答案 35 :(得分：-2)
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();
}