打印出数组中的元素，元素之间使用逗号

Question

I am printing out elements from an ArrayList and want to have a comma after each word except the last word.

Right now, I am doing it like this:

for (String s : arrayListWords) {
    System.out.print(s + ", ");
}

It prints out the words like this:

one, two, three, four,

The problem is the last comma. How do I solve it?

Answer 1

Print the first word on its own if it exists. Then print the pattern as comma first, then the next element.

if (arrayListWords.length >= 1) {
    System.out.print(arrayListWords[0]);
}

// note that i starts at 1, since we already printed the element at index 0
for (int i = 1; i < arrayListWords.length, i++) { 
     System.out.print(", " + arrayListWords[i]);
}

With a List , you're better off using an Iterator

// assume String
Iterator<String> it = arrayListWords.iterator();
if (it.hasNext()) {
    System.out.print(it.next());
}
while (it.hasNext()) {
    System.out.print(", " + it.next());
}

Answer 2

I would write it this way:

String separator = "";  // separator here is your ","

for (String s : arrayListWords) {
    System.out.print(separator + s);
    separator = ",";
}

If arrayListWords has two words, it should print out A,B

Answer 3

使用 Java 8 流：

Stream.of(arrayListWords).collect(Collectors.joining(", "));

Answer 4

StringJoiner str = new StringJoiner(", ");
str.add("Aplha").add("Beta").add("Gamma");

String result = str.toString();
System.out.println("The result is: " + result);

The output: The result is: Aplha, Beta, Gamma

Answer 5

While iterating, you can append the String s to the StringBuilder and at the end, you can delete the last 2 chars which is an extra , and a space ( res.length() -2 )

StringBuilder res = new StringBuilder();
for (String s : arrayListWords) {
    res.append(s).append(", ");
}
System.out.println(res.deleteCharAt(res.length()-2).toString());

Answer 6

With Java 8 it got much easier, no need for 3rd parties -

final List<String> words = Arrays.asList("one", "two", "three", "four");
Optional<String> wordsAsString = words.stream().reduce((w1, w2) -> w1 + "," + w2);
wordsAsString.ifPresent(System.out::println); 

Answer 7

You could use a standard function in the java.util package and remove the block quotes at start and end.

String str = java.util.Arrays.toString(arrayListWords);
str = str.substring(1,str.length()-1);
System.out.println(str);

Answer 8

You can use an Iterator on the List to check whether there are more elements.

You can then append the comma only if the current element is not the last element.

public static void main(String[] args) throws Exception {
    final List<String> words = Arrays.asList(new String[]{"one", "two", "three", "four"});

    final Iterator<String> wordIter = words.iterator();
    final StringBuilder out = new StringBuilder();
    while (wordIter.hasNext()) {
        out.append(wordIter.next());
        if (wordIter.hasNext()) {
            out.append(",");
        }
    }
    System.out.println(out.toString());
}

However it is much easier to use a 3rd party library like Guava to do this for you. The code then becomes:

public static void main(String[] args) throws Exception {
    final List<String> words = Arrays.asList(new String[]{"one", "two", "three", "four"});
    System.out.println(Joiner.on(",").join(words));
}

Answer 9

You can try this

    List<String> listWords= Arrays.asList(arrayListWords); // convert array to List
    StringBuilder sb=new StringBuilder();
    sb.append(listWords);
    System.out.println(sb.toString().replaceAll("\\[|\\]",""));

Answer 10

Just use the toString() method.

String s = arrayListWords.toString();
System.out.println(s);

//This will print it like this: "[one, two, three, four]"
//If you want to remove the brackets you can do so easily. Just change the way you print.

Answer 11

Here is what I come up with:

String join = "";

// solution 1
List<String> strList = Arrays.asList(new String[] {"1", "2", "3"});
for(String s: strList) {
   int idx = strList.indexOf(s);
   join += (idx == strList.size()-1) ? s : s + ",";
}
System.out.println(join);

// solution 2 
join = "";
for(String s: strList) {    
   join += s + ",";
}

join = join.substring(0, join.length()-1);
System.out.println(join);

// solution 3  
join = "";
int count = 0;
for(String s: strList) {    
   join += (count == strlist.size()-1) ? s: s + ",";
   count++;
}

System.out.println(join);

off course we can utalise StringBuilder but of all solutions, I like @Mav answer as it's more efficient and clean.

Answer 12

This might be the most efficient means of comma-delimited string using best practices and no "if" checks, no unfamiliar libraries, and StringBuilder which is best practice for concatenating strings.

Also having a "size" variable reduces the calls to the .size() method.

For those using String[] :

StringBuilder str = new StringBuilder();
String[] strArr = {"one", "two", "three", "four"};
int size = strArr.length;
str.append(strArr[0]);
for (int i = 1; i < size; i++) {
    str.append(",").append(strArr[i]);
}
System.out.println(str.toString());

For those using ArrayList<String> :

StringBuilder str = new StringBuilder();
List<String> strArr = Arrays.asList(new String[]{"one", "two", "three", "four"});
int size = strArr.size();
str.append(strArr.get(0));
for (int i = 1; i < size; i++) {
    str.append(",").append(strArr.get(i));
}
System.out.println(str.toString());

Both yield: one,two,three,four

Answer 13

Since the second-to-top question was wrong, here's a little method I wrote to do this with an array of Integers but converted to array of Strings.

    public static void printArray(String[] arr){
    for(int i = 0;i<arr.length;i++){
        System.out.print(arr[i]);
        if(i<(arr.length-1))
            System.out.print(",");
    }
}

Answer 14

It can also be done using Java 8 static method String.join() , which comes in two flavors.

Returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter .

Both versions expect as the first argument delimiter of type CharSequence , and as the second argument we can provide either varargs of CharSequence or Iterable<? extends CharSequence> Iterable<? extends CharSequence> .

Both methods generate under the hood a byte -array filled byte representations of the provided elements and delimiter according to their encoding and then turn it into the resulting String .

Example with String.join(CharSequence,CharSequence...) :

String[] strings = {"one", "two", "three", "four"};

String joinedStr = String.join(", ", strings); // "one, two, three, four" - resulting String

Example with String.join(CharSequence,Iterable<? extends CharSequence>) :

List<String> strings = List.of("one", "two", "three", "four");

String joinedStr = String.join(", ", strings); // "one, two, three, four" - resulting String