Jaki jest najbardziej przejrzysty sposób rozdzielania listy przecinkami w Javie?

Znam kilka sposobów na zrobienie tego, ale zastanawiam się, jaki jest najlepszy (gdzie „najlepszy” oznacza najwyraźniejszy i / lub najkrótszy, a nie najskuteczniejszy.

Mam listę i chcę ją zapętlić, wypisując każdą wartość. Chcę wydrukować przecinek między każdą pozycją, ale nie po ostatniej (ani przed pierwszą).

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

Przykładowe rozwiązanie 1:

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

Przykładowe rozwiązanie 2 - utwórz podlistę:

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
  }
}

Przykładowe rozwiązanie 3:

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

Te pierwsze traktują specjalnie; można zamiast tego potraktować specjalnie ostatnią osobę.

Nawiasem mówiąc, oto jak List toString jest zaimplementowany (jest dziedziczony z AbstractCollection), w Javie 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(", ");
    }
}

Wcześniej wychodzi z pętli, aby uniknąć przecinka po ostatnim elemencie. Przy okazji: po raz pierwszy widzę „(tę kolekcję)”; oto kod, który to sprowokuje:

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

Z zadowoleniem przyjmuję każde rozwiązanie, nawet jeśli używają nieoczekiwanych bibliotek (regexp?); a także rozwiązania w językach innych niż Java (np myślę Python / Ruby mają przeplatać funkcji - jak to jest , że ? zaimplementowane).

Wyjaśnienie : przez biblioteki mam na myśli standardowe biblioteki Java. W przypadku innych bibliotek rozważam je w innych językach i interesuje mnie, jak są zaimplementowane.

Zestaw narzędzi EDIT wspomniał o podobnym pytaniu: Ostatnia iteracja ulepszonej pętli for w java

I jeszcze: czy ostatni element w pętli zasługuje na osobne potraktowanie?

Java 8 i nowsze

Korzystanie z StringJoinerklasy:

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

Korzystanie Streami Collectors:

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

Java 7 i starsze

Zobacz także # 285523

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

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

Java 8 udostępnia kilka nowych sposobów, aby to zrobić:

• joinMetoda na String.
• joiningKolektor dla strumieni z Collectorsklasą.
• StringJoinerKlasa.

Przykład:

// 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();

Podejście wykorzystujące strumienie zakłada import static java.util.stream.Collectors.joining;.

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

Stolarz .

Jeśli używasz Spring Framework, możesz to zrobić za pomocą StringUtils :

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)

Na podstawie implementacji List toString w Javie:

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

Używa gramatyki takiej jak ta:

List --> (Item , )* Item

Opierając się na ostatniej zamiast na pierwszej, może sprawdzić, czy nie ma przecinka z pominięciem tego samego testu, aby sprawdzić koniec listy. Myślę, że ten jest bardzo elegancki, ale nie jestem pewien co do przejrzystości.

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

Jest na to ładny sposób za pomocą Java 8:

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);

Jedną z opcji pętli foreach jest:

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());
}

Aktualizacja : Jak wspomniał Dave Webb w komentarzach, może to nie dawać poprawnych wyników, jeśli pierwsze pozycje na liście to puste ciągi.

Zwykle robię to:

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()); }

Chociaż myślę, że od teraz będę sprawdzał to zgodnie z implementacją Java;)

Jeśli możesz użyć Groovy (który działa na JVM):

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

(Skopiuj moją własną odpowiedź stąd .) Wiele z opisanych tutaj rozwiązań jest nieco przesadzonych, IMHO, zwłaszcza te, które opierają się na bibliotekach zewnętrznych. Istnieje ładny, przejrzysty idiom do tworzenia listy oddzielonej przecinkami, którego zawsze używałem. Opiera się na operatorze warunkowym (?):

Edycja : Oryginalne rozwiązanie poprawne, ale według komentarzy nieoptymalne. Próbuję po raz drugi:

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

Proszę bardzo, w 4 wierszach kodu, w tym deklaracja tablicy i StringBuilder.

2. edycja : Jeśli masz do czynienia z Iteratorem:

    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() ? "," : "");

Zwykle używam czegoś podobnego do wersji 3. Działa dobrze c / c ++ / bash / ...: P

Nie skompilowałem tego ... ale powinno działać (lub być blisko pracy).

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());
}

To jest bardzo krótkie, bardzo jasne, ale daje mojej wrażliwości pełzające okropności. Trochę niewygodne jest również dostosowanie się do różnych ograniczników, zwłaszcza jeśli jest to ciąg (nie znak).

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

Zainspirowany: Ostatnia iteracja ulepszonej pętli for w Javie

StringBuffer sb = new StringBuffer();

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

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

Trochę mi się podoba to podejście, które jakiś czas temu znalazłem na blogu. Niestety nie pamiętam nazwy / adresu URL bloga.

Możesz utworzyć klasę narzędziową / pomocniczą, która wygląda następująco:

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;
    }
}

Korzystanie z klasy pomocnika jest proste:

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

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

Ponieważ separatorem jest „”, możesz użyć dowolnego z poniższych:

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;}
    }
}

Jeśli Twoim ogranicznikiem jest Cokolwiek innego, to nie zadziała.

Podoba mi się to rozwiązanie:

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

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

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

Zakładam, że może też wykorzystać StringBuilder.

Moim zdaniem najłatwiej to przeczytać i zrozumieć:

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

W Pythonie jest to łatwe

„,”. dołącz (twoja lista)

W języku C # w klasie String istnieje metoda statyczna

String.Join (",", yourlistofstrings)

Przepraszam, nie jestem pewien co do Javy, ale pomyślałem, że spytam, gdy pytasz o inne języki. Jestem pewien, że coś podobnego byłoby w Javie.

Możesz także bezwarunkowo dodać ciąg separatora, a po pętli usunąć dodatkowy separator na końcu. Wtedy „jeśli lista jest pusta, to zwróć ten ciąg” na początku pozwoli ci uniknąć sprawdzania na końcu (ponieważ nie możesz usunąć znaków z pustej listy)

Więc tak naprawdę pytanie brzmi:

„Biorąc pod uwagę pętlę i„ jeśli ”, jak myślisz, jaki jest najlepszy sposób na połączenie tych elementów?

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]);

Oparty na najjaśniejszym sposobie rozdzielania listy przecinkami (Java)?

Posługując się tym pomysłem: czy ostatni element w pętli zasługuje na osobne potraktowanie?

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();
}

Żadna z odpowiedzi nie używa dotychczas rekursji ...

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(",", "");
}

metoda

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();
}

Stosowanie

Biorąc pod uwagę tablicę [1, 2, 3]

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