Java'da bir listeyi virgülle sınırlandırmanın en net yolu nedir?

Bunu yapmanın birkaç yolunu biliyorum, ancak en iyi yolun ne olduğunu merak ediyorum (burada "en iyi", en verimli değil, en net ve / veya en kısa anlamına gelir.

Bir listem var ve her bir değeri yazdırarak üzerinde döngü yapmak istiyorum. Her öğe arasına virgül yazdırmak istiyorum, ancak sonuncudan sonra değil (veya ilkinden önce).

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

Örnek çözüm 1:

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

Örnek çözüm 2 - bir alt liste oluşturun:

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

Örnek çözüm 3:

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

Bunlar ilk öğeyi özel olarak ele alır; bunun yerine sonuncusuna özel olarak davranılabilir.

Bu arada, burada nasıl List toString olduğu (o devralınan uygulanan AbstractCollectionJava 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(", ");
    }
}

Son öğeden sonra virgülden kaçınmak için döngüden erken çıkar. BTW: "(bu Koleksiyon)" u gördüğümü ilk kez hatırlıyorum; işte onu kışkırtacak kod:

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

Beklenmedik kitaplıklar kullansalar bile (regexp?) Herhangi bir çözümü memnuniyetle karşılıyorum; ve Java dışındaki dillerde de çözümler (örneğin Python / Ruby bir var serpmek fonksiyonu - nasıl olduğunu ? uygulanmaktadır).

Açıklama : kütüphaneler derken standart Java kütüphanelerini kastediyorum. Diğer kütüphaneler için, onları diğer dillerle birlikte değerlendiriyorum ve nasıl uygulandıklarını öğrenmekle ilgileniyorum.

DÜZENLEME araç seti benzer bir sorudan bahsetti: Java'da geliştirilmiş for döngüsünün son yinelemesi

Ve bir diğeri: Bir döngüdeki son öğe ayrı bir muameleyi hak ediyor mu?

Java 8 ve üstü

StringJoinerSınıfı kullanma :

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

Kullanılması Streamve Collectors:

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

Java 7 ve öncesi

Ayrıca bkz. # 285523

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

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

Java 8, bunu yapmanın birkaç yeni yolunu sunar:

• joinİlgili bir yöntem String.
• Sınıftaki joiningakışlar için bir toplayıcı Collectors.
• StringJoinerSınıfı.

Misal:

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

Akışları kullanan yaklaşım varsayılır import static java.util.stream.Collectors.joining;.

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

Marangoz .

Spring Framework kullanıyorsanız, bunu StringUtils ile yapabilirsiniz :

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)

Java'nın List toString uygulamasına göre:

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

Bunun gibi bir dilbilgisi kullanır:

List --> (Item , )* Item

İlk temelli yerine son temelli olarak, listenin sonunu kontrol etmek için aynı testle atlama virgülünü kontrol edebilir. Bunun çok zarif olduğunu düşünüyorum ama netlik konusunda emin değilim.

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

Java 8 kullanarak bunu başarmanın güzel bir yolu var:

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

Foreach döngüsü için bir seçenek şudur:

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

Güncelleme : Dave Webb'in yorumlarda belirtildiği gibi, listedeki ilk öğeler boş dizeler ise bu doğru sonuçlar vermeyebilir.

Genellikle bunu yaparım:

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

Java uygulamasına göre bundan sonra bu kontrolü yapacağımı düşünüyorum;)

Groovy'yi kullanabiliyorsanız (JVM'de çalışır):

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

(Kendi cevabımı buradan kopyalayıp yapıştırın .) Burada açıklanan çözümlerin birçoğu, özellikle dış kitaplıklara dayananlar, IMHO'nun biraz üzerinde. Her zaman kullandığım virgülle ayrılmış bir liste elde etmek için güzel, temiz ve anlaşılır bir deyim var. Koşullu (?) Operatöre dayanır:

Düzenleme : Orijinal çözüm doğru, ancak yorumlara göre optimal değil. İkinci kez denemek:

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

İşte dizi ve StringBuilder'ın bildirimi dahil olmak üzere 4 kod satırında gidiyorsunuz.

2. Düzenleme : Bir Yineleyici ile uğraşıyorsanız:

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

Genellikle sürüm 3'e benzer bir şey kullanırım. İyi çalışıyor c / c ++ / bash / ...: P

Derlemedim ... ama çalışmalı (veya çalışmaya yakın olmalı).

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

Bu çok kısa, çok açık, ancak duyarlılıklarıma ürpertici dehşet veriyor. Ayrıca, özellikle bir String (char değil) ise, farklı sınırlayıcılara uyum sağlamak biraz garip.

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

İlham veren: Java'da geliştirilmiş for döngüsünün son yinelemesi

StringBuffer sb = new StringBuffer();

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

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

Bir süre önce bir blogda bulduğum bu yaklaşımı biraz beğendim. Maalesef blogun adını / URL'sini hatırlamıyorum.

Şuna benzeyen bir yardımcı / yardımcı sınıf oluşturabilirsiniz:

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

Helper sınıfını kullanmak şu kadar basittir:

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

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

Sınırlayıcınız "" olduğundan, aşağıdakilerden herhangi birini kullanabilirsiniz:

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

Sınırlayıcınız HERHANGİ BİR ŞEY ise, bu sizin için işe yaramayacaktır.

Bu çözümü beğendim:

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

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

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

StringBuilder'ı da kullanabileceğini varsayıyorum.

Bence okumak ve anlamak en kolay olanı:

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

Python'da çok kolay

",". katılın (listeniz)

C # 'da String sınıfında statik bir yöntem vardır

String.Join (",", dizinizin dizeleri)

Maalesef Java hakkında emin değilim ama diğer diller hakkında sorduğun gibi ağzımı açacağımı düşündüm. Eminim Java'da da buna benzer bir şey olacaktır.

Sınırlayıcı dizeyi koşulsuz olarak ekleyebilir ve döngüden sonra sondaki fazla sınırlayıcıyı kaldırabilirsiniz. Daha sonra, başlangıçta bir "eğer liste boşsa ve sonra bu dizeyi döndür", sondaki kontrolden kaçınmanıza izin verecektir (boş bir listeden karakterleri kaldıramayacağınız için)

Yani asıl soru şu:

"Bir döngü ve bir eğer verildiğinde, bunları bir araya getirmenin en net yolu sizce nedir?"

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

Dayanarak virgülle sınırlamayı listesi (Java) için En Temiz yolu?

Bu fikri kullanarak: Bir döngüdeki son öğe ayrı bir muameleyi hak ediyor mu?

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

Şu ana kadar cevapların hiçbiri özyineleme kullanmıyor ...

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

Yöntem

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

Kullanım

[1,2,3] dizisi verildiğinde

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