What is the best method for converting List<String> to String [duplicate]

check Joiner on guava

    String s= Joiner.on(",").join(lists);

Check below output test

    List<String> lists=new ArrayList<String>();
    lists.add("a1");
    lists.add("a2");
    lists.add("a3");
    lists.add("a4");
    String s = Joiner.on(",").join(lists);
    System.out.println(s);

ouput:

a1,a2,a3,a4

Apache's commons lang, just appends

 StringUtils.join(list);

or separate by characters.

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

Java 8.0 onwards, first argument is to separate elements

String joined = String.join("", list);

Function A is preferable since it is using only one instance of StringBuilder while code from Function B executed in loop

str += s + ", ";

is equivalent of

str = new StringBuilder(str).append(s).append(", ").toString();

so in each iteration you have to:

• create new StringBuilder
• copy content of current string to this StringBuilder
• now you can add ", " and s
• create and return new String based on current content of StringBuilder

(so in each iteration your need to read entire string again, and again, and again...) while in scenario B you just focus on adding new characters to single StringBuilder

Anyway since Java 8 you don't need to focus this much on writing methods which can concatenate collection of strings. You can simply use StringJoiner class or simpler just invoke
join(CharSequence delimiter, Iterable<? extends CharSequence> elements) method from String class which will use StringJoiner for you. Code of this method looks like:

public static String join(CharSequence delimiter,
        Iterable<? extends CharSequence> elements) {
    Objects.requireNonNull(delimiter);
    Objects.requireNonNull(elements);
    StringJoiner joiner = new StringJoiner(delimiter);
    for (CharSequence cs: elements) {
        joiner.add(cs);
    }
    return joiner.toString();
}

Note that Objects.requireNonNull(delimiter); will throw NPE in case of null, so if you want to avoid it you can write your own version of this method and replace this tests with something more like

if (delimiter==null || elements==null) return "";

or if you would like to allow delimiter to be null

if (elements==null) return "";
if (delimiter == null) delimiter = "";//use empty string as delimiter 

Besides using libraries you could use

(the pattern I've seen most often)

public static String listToString(List<String> list) {
    StringBuilder sb = new StringBuilder();
    boolean first = true;
    for (String string : list) {
        if (first)
            first = false;
        else
            sb.append(", ");
        sb.append(string);
    }
    return sb.toString();
}

(also quite common)

public static String listToString(List<String> list) {
    StringBuilder sb = new StringBuilder();
    String separator = "";
    for (String string : list) {
        sb.append(separator).append(string);
        separator = ", ";
    }
    return sb.toString();
}

(shortest, bit hard to read)

public static String listToString(List<String> list) {
    StringBuilder sb = new StringBuilder();
    for (Iterator<String> iterator = list.iterator(); iterator.hasNext();)
        sb.append(iterator.next()).append(iterator.hasNext() ? ", " : "");
    return sb.toString();
}

(could be the fastest since no extra conditional jumps in the loops)

public static String listToString(List<String> list) {
    StringBuilder sb = new StringBuilder();
    Iterator<String> iterator = list.iterator();
    if (iterator.hasNext()) {
        sb.append(iterator.next());
        while (iterator.hasNext())
            sb.append(", ").append(iterator.next());
    }
    return sb.toString();
}

Or something else that is readable & short like B but uses a StringBuilder. What you don't want to have is + string concatenation in a loop. That creates temporary objects.