Remove Last Comma

Question

I want to join strings together, but when doing this it often happens that there is a comma too many, and therefore I need to remove that comma. In this code, I use the substring to delete the two last characters.

How can this become more elegant?

List<String> paramList = new ArrayList<String>( );
paramList.add( "param1" );
paramList.add( "param2" );

StringBuilder result = new StringBuilder();
for ( String p : paramList )
{
  result.append( p ).append( ", " );
}

String withoutLastComma = result.substring( 0, result.length( ) - ", ".length( ) );
System.err.println( withoutLastComma );

Answer 1

One may use string utility methods such as StringUtil.join to concatenate elements in an array or a collection object. Consult the StringUtil API's StringUtil.join entry.

For example:

StringUtils.join(["a", "b", "c"], "--")  // => "a--b--c"

Answer 2

for ( String p : paramList )
{
  if (result.length() > 0) result.append( ", " );
  result.append( p );
}

Answer 3

Java 8 provides a String.join() method, so you can do it without depending on an external library.

List<String> paramList = new ArrayList<String>();
paramList.add("param1");
paramList.add("param2");

String withoutLastComma = String.join(", ", paramList);

Answer 4

I believe it's better to know how to write it and then use a library. I usually prefer to make a check before the loop, thus avoiding to have to check every time in the loop:

int size = paramList.size();
if (size > 0) {
    result.append(paramList.get(0));
    for (int i = 1; i < size; ++i) {
        result.append(", ").append(paramList.get(i));
    }
}

Answer 5

One of possible ways is a using Joiner from Google Guava library:

result = Joiner.on(", ").join(paramList);

Answer 6

That's strange that nobody has mentioned iterator-wise approach so far.

So here it goes:

public static <E> String join(Iterable<E> iterable, String delim) {
    Iterator<E> iterator = iterable.iterator();
    if (!iterator.hasNext()) {
        return "";
    }

    StringBuilder builder = new StringBuilder(iterator.next().toString());
    while (iterator.hasNext()) {
        builder.append(delim).append(iterator.next().toString());
    }

    return builder.toString();
}

No messing with indexes, substringing, etc, etc.

And let's use it:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
System.out.println(join(list, ", "));

Update: NPE-safe approach would be avoid using toString() on next() (thanks @David Harkness):

public static <E> String join(Iterable<E> iterable, String delim) {
    Iterator<E> iterator = iterable.iterator();
    if (!iterator.hasNext()) {
        return "";
    }

    StringBuilder builder = new StringBuilder(iterator.next());
    while (iterator.hasNext()) {
        builder.append(delim).append(iterator.next());
    }

    return builder.toString();
}

Answer 7

What I use is a variable that I initialize as empty and then set inside the loop.

List<String> paramList = new ArrayList<String>( );
paramList.add("param1");
paramList.add("param2");

String separator = "";

StringBuilder result = new StringBuilder();
for (String p : paramList)
{
    result.append(separator)
    result.append(p);
    separator = ", ";
}

System.err.println(result.toString());

Answer 8

A couple of alternate options here - any of such can simply only resolve to making the intentions clear, although it's hardly an issue.

It might be a little clearer, albeit not much, using lastIndexOf:

String withoutLastComma = result.substring(0, result.lastIndexOf(","));

Or just refactor a little, which could be more explanatory:

StringBuilder result = new StringBuilder();
for (int i = 0; i < paramList.size(); i++)
{           
    result.append(paramList.get(i));
    if (i + 1 != paramList.size())
        result.append(", ");
}
System.err.println(result);

Or, lastly, use a string utility library as linked in other answers provided; though, the thought of doing so brings the term 'sledgehammer to crack a nut' to mind, but it might well be justified depending on what other operations you require to carry out.

Answer 9

I like this technique:

private String join(Iterable<?> items, String sep) {
    Iterator<?> iter = items.iterator();
    if (!iter.hasNext()) {
        return "";
    }

    StringBuilder builder = new StringBuilder();
    builder.append(iter.next());
    while (iter.hasNext()) {
        builder.append(sep).append(iter.next());
    }

    return builder.toString();
}

What I like about it is there is no wasted if condition inside the loop.

Here are some unit tests to go with it:

@Test
public void testEmptyCollection() {
    Assert.assertTrue(join(Collections.emptyList(), ", ").isEmpty());
}

@Test
public void testJoinSingleItem() {
    String item = "hello";
    Assert.assertEquals(item, join(Collections.singletonList(item), ", "));
}

@Test
public void testJoinTwoItems() {
    Integer item1 = 4;
    Integer item2 = 9;
    String sep = ", ";
    String expected = item1 + sep + item2;
    Assert.assertEquals(expected, join(Arrays.asList(item1, item2), sep));
}

Answer 10

String listString = Arrays.toString(paramList.toArray());
System.err.println( listString );

Will return:

[param1, param2]

This has the added benefit of using the String.valueOf(object) method which will print 'null' in the case of null objects. The Arrays.toString() method is also pretty straight forward if you just want to reimplement it. Removing the brackets:

    int iMax = paramList.size() - 1;
    if (iMax == -1) {
      return "";
    }
    String[] params = paramList.toArray();
    StringBuilder b = new StringBuilder();
    for (int i = 0; ; i++) {
      String param = params[i];
      b.append(param);
      if (i == iMax) {
        return b.toString();
      }
      b.append(", ");
    }

Answer 11

Surprised no one has contributed a unit test specification:

• a useful result should contain max(0, paramList.length() - 1) commas.
• a robust solution should not throw IndexOutOfBoundsException if the list is empty.
• an efficient solution would provide a realistic StringBuilder capacity estimate.

The result can be misleading or useless if any parameter contains a comma. Java8 String.join should be redesigned to flag this "delimiter collision" possibility at compile time, and only accept strings to be joined that can be split again afterwards because they have already been escaped or quoted or do not or cannot contain the delimiter.

Answer 12

If you are using java 8, you can use StringJoiner like;

StringJoiner sj = new StringJoiner(",");
for ( String p : paramList )
{
  sj.add(p);
}

Answer 13

When we use stream we do have more flexibility, like
map ⟶ convert any array object to string
filter ⟶ remove when it is empty
join ⟶ add joining character

    //Deduplicate the comma character in the input string
    String[] splits = input.split("\\s*,\\s*");
    return Arrays.stream(splits).filter(StringUtils::isNotBlank).collect(Collectors.joining(", "));

Answer 14

As an alternative of manually going through the loop to construct the comma-separated contents of the List, you can take advantage of the List's toString() method alongside with substring method of String.

String contents = paramList.toString(); //returns [param 1, param2]

//remove `[` and `]`
System.out.println(contents.substring(1, contents.length()-1));

Answer 15

Here's a more efficient alternative to the delete method, which just breaks the StringBuilder without asking for chars or positions:

@Test
public void appendTest (){
    final String comma = ", ";

    List<String> paramList = new ArrayList<>();
    paramList.add( "param1" );
    paramList.add( "param2" );

    StringBuilder result = new StringBuilder();
    for (String s : paramList) {
        result.append(s).append(comma);
    }
    if (!paramList.isEmpty()){
        result.setLength(result.length() - comma.length());
    }

    System.out.println(result);

}