Was ist der klarste Weg, eine Liste in Java durch Kommas zu trennen?

Ich kenne verschiedene Möglichkeiten, aber ich frage mich, was der beste Weg ist (wobei "am besten" am klarsten und / oder am kürzesten bedeutet, nicht am effizientesten.

Ich habe eine Liste und möchte sie durchlaufen und jeden Wert drucken. Ich möchte zwischen jedem Element ein Komma drucken, aber nicht nach dem letzten (noch vor dem ersten).

List --> Item ( , Item ) *
List --> ( Item , ) * Item

Probenlösung 1:

boolean isFirst = true;
for (Item i : list) {
  if (isFirst) {
    System.out.print(i);        // no comma
    isFirst = false;
  } else {
    System.out.print(", "+i);   // comma
  }
}

Beispiellösung 2 - Erstellen Sie eine Unterliste:

if (list.size()>0) {
  System.out.print(list.get(0));   // no comma
  List theRest = list.subList(1, list.size());
  for (Item i : theRest) {
    System.out.print(", "+i);   // comma
  }
}

Probenlösung 3:

  Iterator<Item> i = list.iterator();
  if (i.hasNext()) {
    System.out.print(i.next());
    while (i.hasNext())
      System.out.print(", "+i.next());
  }

Diese behandeln den ersten Gegenstand besonders; man könnte stattdessen den letzten speziell behandeln.

Im übrigen ist hier, wie List toString wird umgesetzt (es ist geerbt von AbstractCollection), in Java 1.6:

public String toString() {
    Iterator<E> i = iterator();
    if (! i.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = i.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! i.hasNext())
            return sb.append(']').toString();
        sb.append(", ");
    }
}

Es verlässt die Schleife vorzeitig, um das Komma nach dem letzten Element zu vermeiden. Übrigens: Dies ist das erste Mal, dass ich mich erinnere, "(diese Sammlung)" gesehen zu haben. Hier ist der Code, um es zu provozieren:

List l = new LinkedList();
l.add(l);
System.out.println(l);

Ich begrüße jede Lösung, auch wenn sie unerwartete Bibliotheken verwenden (regulärer Ausdruck?); und auch Lösungen in anderen Sprachen als Java (z. B. denke ich, dass Python / Ruby eine Intersperse- Funktion haben - wie ist das implementiert?).

Klarstellung : Mit Bibliotheken meine ich die Standard-Java-Bibliotheken. Für andere Bibliotheken betrachte ich sie mit anderen Sprachen und bin daran interessiert zu wissen, wie sie implementiert sind.

Das EDIT- Toolkit erwähnte eine ähnliche Frage: Letzte Iteration der erweiterten for-Schleife in Java

Und noch eines: Verdient das letzte Element in einer Schleife eine separate Behandlung?

Java 8 und höher

Mit StringJoinerKlasse:

StringJoiner joiner = new StringJoiner(",");
for (Item item : list) {
    joiner.add(item.toString());
}
return joiner.toString();

Verwenden von Streamund Collectors:

return list.stream().
       map(Object::toString).
       collect(Collectors.joining(",")).toString();

Java 7 und früher

Siehe auch # 285523

String delim = "";
for (Item i : list) {
    sb.append(delim).append(i);
    delim = ",";
}

org.apache.commons.lang3.StringUtils.join(list,",");

Java 8 bietet dazu mehrere neue Möglichkeiten:

• Die joinMethode auf String.
• Ein joiningSammler für Streams aus der CollectorsKlasse.
• Die StringJoinerKlasse.

Beispiel:

// Util method for strings and other char sequences
List<String> strs = Arrays.asList("1", "2", "3");
String listStr1 = String.join(",", strs);

// For any type using streams and collectors
List<Object> objs = Arrays.asList(1, 2, 3);
String listStr2 = objs.stream()
    .map(Object::toString)
    .collect(joining(",", "[", "]"));

// Using the new StringJoiner class
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("<empty>");
for (Integer i : objs) {
  joiner.add(i.toString());
}
String listStr3 = joiner.toString();

Der Ansatz mit Streams setzt voraus import static java.util.stream.Collectors.joining;.

Joiner.on(",").join(myList)

Tischler .

Wenn Sie das Spring Framework verwenden, können Sie dies mit StringUtils tun :

public static String arrayToDelimitedString(Object[] arr)
public static String arrayToDelimitedString(Object[] arr, String delim)
public static String collectionToCommaDelimitedString(Collection coll)
public static String collectionToCommaDelimitedString(Collection coll, String delim)

Basierend auf der Implementierung von Java List toString:

Iterator i = list.iterator();
for (;;) {
  sb.append(i.next());
  if (! i.hasNext()) break;
  ab.append(", ");
}

Es verwendet eine Grammatik wie diese:

List --> (Item , )* Item

Wenn es auf der letzten statt auf der ersten Basis basiert, kann es mit demselben Test nach Überspringkomma suchen, um nach dem Ende der Liste zu suchen. Ich finde diesen sehr elegant, bin mir aber bei der Klarheit nicht sicher.

String delimiter = ",";
StringBuilder sb = new StringBuilder();
for (Item i : list) {
    sb.append(delimiter).append(i);
}
sb.toString().replaceFirst(delimiter, "");

Es gibt eine schöne Möglichkeit, dies mit Java 8 zu erreichen:

List<String> list = Arrays.asList(array);
String joinedString = String.join(",", list);

for(int i=0, length=list.size(); i<length; i++)
  result+=(i==0?"":", ") + list.get(i);

Eine Option für die foreach-Schleife ist:

StringBuilder sb = new StringBuilder();
for(String s:list){
  if (sb.length()>0) sb.append(",");
  sb.append(s);
}

StringBuffer result = new StringBuffer();
for(Iterator it=list.iterator; it.hasNext(); ) {
  if (result.length()>0)
    result.append(", ");
  result.append(it.next());
}

Update : Wie Dave Webb in den Kommentaren erwähnt hat, führt dies möglicherweise nicht zu korrekten Ergebnissen, wenn die ersten Elemente in der Liste leere Zeichenfolgen sind.

Normalerweise mache ich das:

StringBuffer sb = new StringBuffer();
Iterator it = myList.iterator();
if (it.hasNext()) { sb.append(it.next().toString()); }
while (it.hasNext()) { sb.append(",").append(it.next().toString()); }

Obwohl ich denke, dass ich diese Überprüfung von nun an gemäß der Java-Implementierung durchführen werde;)

Wenn Sie Groovy verwenden können (das auf der JVM ausgeführt wird):

def list = ['a', 'b', 'c', 'd']
println list.join(',')

(Kopieren und Einfügen meiner eigenen Antwort von hier .) Viele der hier beschriebenen Lösungen sind meiner Meinung nach etwas übertrieben, insbesondere diejenigen, die auf externen Bibliotheken basieren. Es gibt eine schöne, saubere und klare Sprache, um eine durch Kommas getrennte Liste zu erhalten, die ich immer verwendet habe. Es basiert auf dem bedingten (?) Operator:

Bearbeiten : Ursprüngliche Lösung korrekt, aber laut Kommentaren nicht optimal. Ein zweites Mal versuchen:

int[] array = {1, 2, 3};
StringBuilder builder = new StringBuilder();
for (int i = 0 ;  i < array.length; i++)
       builder.append(i == 0 ? "" : ",").append(array[i]);

Los geht's in 4 Codezeilen, einschließlich der Deklaration des Arrays und des StringBuilder.

2. Bearbeitung : Wenn Sie es mit einem Iterator zu tun haben:

    List<Integer> list = Arrays.asList(1, 2, 3);
    StringBuilder builder = new StringBuilder();
    for (Iterator it = list.iterator(); it.hasNext();)
        builder.append(it.next()).append(it.hasNext() ? "," : "");

Normalerweise benutze ich etwas ähnliches wie Version 3. Es funktioniert gut c / c ++ / bash / ...: P.

Ich habe es nicht kompiliert ... sollte aber funktionieren (oder kurz vor der Arbeit stehen).

public static <T> String toString(final List<T> list, 
                                  final String delim)
{
    final StringBuilder builder;

    builder = new StringBuilder();

    for(final T item : list)
    {
        builder.append(item);
        builder.append(delim);
    }

    // kill the last delim
    builder.setLength(builder.length() - delim.length());

    return (builder.toString());
}

Das ist sehr kurz, sehr klar, aber es gibt meiner Sensibilität die schleichenden Schrecken. Es ist auch etwas umständlich, sich an verschiedene Trennzeichen anzupassen, insbesondere wenn es sich um einen String (nicht char) handelt.

for (Item i : list)
  sb.append(',').append(i);
if (sb.charAt(0)==',') sb.deleteCharAt(0);

Inspiriert von: Letzte Iteration der erweiterten for-Schleife in Java

StringBuffer sb = new StringBuffer();

for (int i = 0; i < myList.size(); i++)
{ 
    if (i > 0) 
    {
        sb.append(", ");
    }

    sb.append(myList.get(i)); 
}

Ich mag diesen Ansatz, den ich vor einiger Zeit in einem Blog gefunden habe. Leider erinnere ich mich nicht an den Namen / die URL des Blogs.

Sie können eine Dienstprogramm- / Hilfsklasse erstellen, die folgendermaßen aussieht:

private class Delimiter
{
    private final String delimiter;
    private boolean first = true;

    public Delimiter(String delimiter)
    {
        this.delimiter = delimiter;
    }

    @Override
    public String toString()
    {
        if (first) {
            first = false;
            return "";
        }

        return delimiter;
    }
}

Die Verwendung der Hilfsklasse ist so einfach:

StringBuilder sb = new StringBuilder();
Delimiter delimiter = new Delimiter(", ");

for (String item : list) {
    sb.append(delimiter);
    sb.append(item);
}

Da Ihr Trennzeichen "" ist, können Sie Folgendes verwenden:

public class StringDelim {

    public static void removeBrackets(String string) {
        System.out.println(string.substring(1, string.length() - 1));
    }

    public static void main(String... args) {
        // Array.toString() example
        String [] arr = {"Hi" , "My", "name", "is", "br3nt"};
        String string = Arrays.toString(arr);
        removeBrackets(string);

        // List#toString() example
        List<String> list = new ArrayList<String>();
        list.add("Hi");
        list.add("My");
        list.add("name");
        list.add("is");
        list.add("br3nt");
        string = list.toString();
        removeBrackets(string);

        // Map#values().toString() example
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("1", "Hi");
        map.put("2", "My");
        map.put("3", "name");
        map.put("4", "is");
        map.put("5", "br3nt");
        System.out.println(map.values().toString());
        removeBrackets(string);

        // Enum#toString() example
        EnumSet<Days> set = EnumSet.allOf(Days.class);
        string = set.toString();
        removeBrackets(string);
    }

    public enum Days {
        MON("Monday"),
        TUE("Tuesday"),
        WED("Wednesday"),
        THU("Thursday"),
        FRI("Friday"),
        SAT("Saturday"),
        SUN("Sunday");

        private final String day;

        Days(String day) {this.day = day;}
        public String toString() {return this.day;}
    }
}

Wenn Ihr Trennzeichen etwas anderes ist, funktioniert dies für Sie nicht.

Ich mag diese Lösung:

String delim = " - ", string = "";

for (String item : myCollection)
    string += delim + item;

string = string.substring(delim.length());

Ich gehe davon aus, dass es auch StringBuilder verwenden kann.

Meiner Meinung nach ist dies am einfachsten zu lesen und zu verstehen:

StringBuilder sb = new StringBuilder();
for(String string : strings) {
    sb.append(string).append(',');
}
sb.setLength(sb.length() - 1);
String result = sb.toString();

In Python ist es einfach

",". beitreten (Ihre Liste)

In C # gibt es eine statische Methode für die String-Klasse

String.Join (",", yourlistofstrings)

Entschuldigung, ich bin mir bei Java nicht sicher, dachte aber, ich würde mich melden, als Sie nach anderen Sprachen fragten. Ich bin mir sicher, dass es in Java etwas Ähnliches geben würde.

Sie können die Trennzeichenfolge auch bedingungslos hinzufügen und nach der Schleife das zusätzliche Trennzeichen am Ende entfernen. Wenn Sie am Anfang eine "Wenn die Liste leer ist, geben Sie diese Zeichenfolge zurück" verwenden, können Sie die Prüfung am Ende vermeiden (da Sie keine Zeichen aus einer leeren Liste entfernen können).

Die Frage ist also wirklich:

"Was ist Ihrer Meinung nach angesichts einer Schleife und eines Wenn der klarste Weg, diese zusammen zu haben?"

public static String join (List<String> list, String separator) {
  String listToString = "";

  if (list == null || list.isEmpty()) {
   return listToString;
  }

  for (String element : list) {
   listToString += element + separator;
  }

  listToString = listToString.substring(0, separator.length());

  return listToString;
}

if (array.length>0)          // edited in response Joachim's comment
  sb.append(array[i]);
for (int i=1; i<array.length; i++)
  sb.append(",").append(array[i]);

Basierend auf dem klarsten Weg, eine Liste durch Kommas zu trennen (Java)?

Mit dieser Idee: Verdient das letzte Element in einer Schleife eine separate Behandlung?

public String toString(List<Item> items)
{
    StringBuilder sb = new StringBuilder("[");

    for (Item item : items)
    {
        sb.append(item).append(", ");
    }

    if (sb.length() >= 2)
    {
        //looks cleaner in C# sb.Length -= 2;
        sb.setLength(sb.length() - 2);
    }

    sb.append("]");

    return sb.toString();
}

Keine der Antworten verwendet bisher Rekursion ...

public class Main {

    public static String toString(List<String> list, char d) {
        int n = list.size();
        if(n==0) return "";
        return n > 1 ? Main.toString(list.subList(0, n - 1), d) + d
                  + list.get(n - 1) : list.get(0);
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList(new String[]{"1","2","3"});
        System.out.println(Main.toString(list, ','));
    }

}

private String betweenComma(ArrayList<String> strings) {
    String united = "";
    for (String string : strings) {
        united = united + "," + string;
    }
    return united.replaceFirst(",", "");
}

Methode

String join(List<Object> collection, String delimiter){
    StringBuilder stringBuilder = new StringBuilder();
    int size = collection.size();
    for (Object value : collection) {
        size --;
        if(size > 0){
            stringBuilder.append(value).append(delimiter);
        }
    }

    return stringBuilder.toString();
}

Verwendung

Angesichts der Anordnung von [1,2,3]

join(myArray, ",") // 1,2,3