Ben ArrayListtamamen bir dize olarak çıktı istiyorum bir var. Aslında toStringsekmelerle ayrılmış her öğenin kullanarak sırayla çıktı istiyorum . Bunu yapmanın hızlı bir yolu var mı? Eğer döngü (ya da her öğeyi kaldırmak) ve bir Dize bitiştirmek olabilir ama bu çok yavaş olacağını düşünüyorum.

Temel olarak, ArrayListtek seçenek üzerinde bir döngü kullanmak tek seçenektir:

Bu kodu KULLANMAYIN, neden istenmediğini ve bunun yerine hangi kodun kullanılması gerektiğini görmek için bu cevabın altına okumaya devam edin:

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

String listString = "";

for (String s : list)
{
    listString += s + "\t";
}

System.out.println(listString);

Aslında, javacderleyici dize birleştirmeyi yine de bir dizi appendişlem olarak optimize edeceğinden , bir dize birleştirmesi gayet iyi olacaktır StringBuilder. forYukarıdaki programdan bayt kodunun döngüden sökülmesinin bir kısmı :

   61:  new #13; //class java/lang/StringBuilder
   64:  dup
   65:  invokespecial   #14; //Method java/lang/StringBuilder."<init>":()V
   68:  aload_2
   69:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  aload   4
   74:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   77:  ldc #16; //String \t
   79:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   82:  invokevirtual   #17; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;

Görüldüğü gibi, derleyici bu döngüyü a kullanarak optimize eder StringBuilder, bu nedenle performans büyük bir endişe olmamalıdır.

(Tamam, ikinci bakışta, StringBuilderdöngü her yinelemesinde somutlaştırılıyor, bu yüzden en verimli bayt kodu olmayabilir. Açık bir örnek oluşturmak ve kullanmak StringBuildermuhtemelen daha iyi performans sağlar.)

Aslında, herhangi bir çıktıya sahip olmanın (diske veya ekrana) en azından dize birleşimlerinin performansı hakkında endişelenmekten daha yavaş bir büyüklük sırası olacağını düşünüyorum.

Düzenleme: Yorumlarda belirtildiği gibi, yukarıdaki derleyici optimizasyonu gerçekten de StringBuilderher yinelemenin yeni bir örneğini yaratıyor . (Daha önce de belirttiğim gibi.)

Kullanılacak en optimize edilmiş teknik, Paul Tomblin'in yanıtıdır , çünkü sadece döngü StringBuilderdışında tek bir nesneyi başlatır for.

Yukarıdaki koda yeniden yazmak için:

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder();
for (String s : list)
{
    sb.append(s);
    sb.append("\t");
}

System.out.println(sb.toString());

StringBuilderDöngünün dışında yalnızca bir kez örnek oluşturur ve appendbu bayt kodunda ( StringBuilderdöngünün örneğini ve döngüyü gösterir) gösterildiği gibi, döngü içindeki yönteme yalnızca iki çağrı yapar :

   // Instantiation of the StringBuilder outside loop:
   33:  new #8; //class java/lang/StringBuilder
   36:  dup
   37:  invokespecial   #9; //Method java/lang/StringBuilder."<init>":()V
   40:  astore_2

   // [snip a few lines for initializing the loop]
   // Loading the StringBuilder inside the loop, then append:
   66:  aload_2
   67:  aload   4
   69:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  pop
   73:  aload_2
   74:  ldc #15; //String \t
   76:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   79:  pop

Bu nedenle, ilmenin içi fordaha kısa olduğundan ve StringBuilderher bir yinelemede bir somutlaştırmaya gerek olmadığından, el optimizasyonu daha iyi performans göstermelidir .

Java 8 veya sonraki sürümlerde:

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

Durumda listtürü String, bir birleştirme toplayıcı kullanılabilir değildir:

String listString = list.stream().map(Object::toString)
                        .collect(Collectors.joining(", "));

Bunu Android'de yapıyorsanız, bunun için TextUtils adı verilen güzel bir yardımcı program var .join(String delimiter, Iterable).

List<String> list = new ArrayList<String>();
list.add("Item 1");
list.add("Item 2");
String joined = TextUtils.join(", ", list);

Açıkçası çok fazla Android dışında kullanmak, ama düşündüm ki bu konuya eklemek istiyorum ...

Apache Commons Lang'ı indirin ve yöntemi kullanın

 StringUtils.join(list)

 StringUtils.join(list, ", ") // 2nd param is the separator.

Elbette kendiniz uygulayabilirsiniz, ancak kodları tamamen test edilmiştir ve muhtemelen mümkün olan en iyi uygulamadır.

Apache Commons kütüphanesinin büyük bir hayranıyım ve bunun Java Standart Kütüphanesine büyük bir katkı olduğunu düşünüyorum.

Bu oldukça eski bir soru, ama daha modern bir cevap da ekleyebilirim - Guava'danJoiner sınıfı kullanın :

String joined = Joiner.on("\t").join(list);

Değişen Listesini okunabilir ve anlamlı etmek dize gerçekten her biri karşılaşabileceğinizi ortak bir sorudur.

Durum 1 . Sınıf yolunuzda (rogerdpack ve Ravi Wallau gibi) apache'nin StringUtils'i varsa:

import org.apache.commons.lang3.StringUtils;
String str = StringUtils.join(myList);

Durum 2 . Yalnızca JDK (7) 'nin yollarını kullanmak istiyorsanız:

import java.util.Arrays;
String str = Arrays.toString(myList.toArray()); 

Sadece kendi başınıza tekerlek yapmayın, bu tek satırlık görev için döngü kullanmayın.

Hızlı bir tek astar arıyorsanız, Java 5'ten itibaren bunu yapabilirsiniz:

myList.toString().replaceAll("\\[|\\]", "").replaceAll(", ","\t")

Ayrıca, amacınız yalnızca içeriği yazdırmaksa ve "\ t" hakkında daha az endişeleniyorsanız, bunu yapmanız yeterlidir:

myList.toString()

hangi gibi bir dize döndürür

[str1, str2, str3]

Eğer bir Array (ArrayList değil) varsa, aynı şeyi şu şekilde yapabilirsiniz:

 Arrays.toString(myList).replaceAll("\\[|\\]", "").replaceAll(", ","\t")

İçinden geçirin ve çağrı yapın. Sihirli bir yol yoktur ve eğer olsaydı, bunun altından geçmekten başka örtünün altında ne yapacağını düşünüyorsunuz? Tek mikro optimizasyon hakkında String yerine StringBuilder kullanmak olurdu ve bu bile büyük bir kazanç değil - dizeleri birleştirmek kapakların altında StringBuilder'e dönüşür, ancak en azından bu şekilde yazdığınızda neler olduğunu görebilirsiniz.

StringBuilder out = new StringBuilder();
for (Object o : list)
{
  out.append(o.toString());
  out.append("\t");
}
return out.toString();

Çoğu Java projesinde genellikle apache-commons lang bulunur. StringUtils.join () yöntemleri çok güzel ve neredeyse her ihtiyacı karşılamak için çeşitli tatlar var.

public static java.lang.String join(java.util.Collection collection,
                                    char separator)


public static String join(Iterator iterator, String separator) {
    // handle null, zero and one elements before building a buffer 
    Object first = iterator.next();
    if (!iterator.hasNext()) {
        return ObjectUtils.toString(first);
    }
    // two or more elements 
    StringBuffer buf = 
        new StringBuffer(256); // Java default is 16, probably too small 
    if (first != null) {
        buf.append(first);
    }
    while (iterator.hasNext()) {
        if (separator != null) {
            buf.append(separator);
        }
        Object obj = iterator.next();
        if (obj != null) {
            buf.append(obj);
        }
    }
    return buf.toString();
}

Parametreler:

Toplamak - Bir araya getirilecek değerlerin boş olabilir

separator - kullanılacak ayırıcı karakter

İadeler : birleştirilmiş Dize, null yineleyici girdisi ise null

Bu tarihten beri: 2.3

Android'de http://developer.android.com/reference/android/text/TextUtils.html kullanabileceğiniz bir TextUtil sınıfı vardır

String implode = TextUtils.join("\t", list);

Bu basit kullanım durumunda, dizeleri virgülle birleştirebilirsiniz. Java 8 kullanıyorsanız:

String csv = String.join("\t", yourArray);

aksi takdirde commons-lang bir join () yöntemine sahiptir:

String csv = org.apache.commons.lang3.StringUtils.join(yourArray, "\t");

Sondaki ayırma karakterleriyle baş etmenin zarif bir yolu Sınıf Ayırıcı kullanmaktır

StringBuilder buf = new StringBuilder();
Separator sep = new Separator("\t");
for (String each: list) buf.append(sep).append(each);
String s = buf.toString();

Sınıf Ayırıcı'nın toString yöntemi , ilk çağrı hariç ayırıcıyı döndürür . Bu nedenle listeyi iz bırakmadan (veya bu durumda) önde gelen ayırıcılar olmadan yazdırırız.

Java 8'de bu basit. Tamsayıların listesi için örneğe bakın:

String result = Arrays.asList(1,2,3).stream().map(Object::toString).reduce((t, u) -> t + "\t" + u).orElse("");

Veya çok satırlı sürüm (daha kolay okunur):

String result = Arrays.asList(1,2,3).stream()
    .map(Object::toString)
    .reduce((t, u) -> t + "\t" + u)
    .orElse("");

Güncelleme - daha kısa bir versiyon

String result = Arrays.asList(1,2,3).stream()
                .map(Object::toString)
                .collect(Collectors.joining("\t"));

Her O(n)iki şekilde de bir algoritma (listeyi birden fazla alt listeye kırdığınız çok iş parçacıklı bir çözüm yapmadıysanız, ancak bunu istediğinizi sanmıyorum).

Sadece a'yı StringBuilderaşağıdaki gibi kullanın :

StringBuilder sb = new StringBuilder();

for (Object obj : list) {
  sb.append(obj.toString());
  sb.append("\t");
}

String finalString = sb.toString();

StringBuilderEğer yeniden başlatmasını bir olmayacak çünkü çok daha hızlı dizisi birleştirme daha olacak Stringher birleştirme nesneyi.

Android'de olmanız ve henüz Jack'i kullanmamanız durumunda (örneğin, Anında Çalıştırma için hala desteğe sahip olmadığı için) ve elde edilen dizenin biçimlendirmesi üzerinde daha fazla kontrol istiyorsanız (örneğin, yeni satır karakterini şu şekilde kullanmak istersiniz) öğelerin bölücüsü) ve StreamSupport kitaplığını (derleyici Java 7 veya önceki sürümlerinde akışları kullanmak için) kullanmak / kullanmak istiyorsanız, böyle bir şey kullanabilirsiniz (Bu yöntemi ListUtils sınıfıma koydum):

public static <T> String asString(List<T> list) {
    return StreamSupport.stream(list)
            .map(Object::toString)
            .collect(Collectors.joining("\n"));
}

Ve elbette, liste nesnelerinizin sınıfına toString () yöntemini uyguladığınızdan emin olun.

Son öğeden sonra son \ t istemiyorsanız, kontrol etmek için dizini kullanmanız gerekir, ancak listeler RandomAccess'i uyguladığında bunun yalnızca "çalıştığını" (yani O (n)) unutmayın.

List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder(list.size() * apprAvg); // every apprAvg > 1 is better than none
for (int i = 0; i < list.size(); i++) {
    sb.append(list.get(i));
    if (i < list.size() - 1) {
        sb.append("\t");
    }
}
System.out.println(sb.toString());

Aşağıdaki kod size yardımcı olabilir,

List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
String str = list.toString();
System.out.println("Step-1 : " + str);
str = str.replaceAll("[\\[\\]]", "");
System.out.println("Step-2 : " + str);

Çıktı:

Step-1 : [1, 2, 3]
Step-2 : 1, 2, 3

En iyi yol değil, zarif yol olabilir.

Arrays.deepToString (Arrays.asList ("Test", "Test2")

import java.util.Arrays;

    public class Test {
        public static void main(String[] args) {
            System.out.println(Arrays.deepToString(Arrays.asList("Test", "Test2").toArray()));
        }
    }

Çıktı

[Test, Test2]

Aşağıdakiler iyi olur:

List<String> streamValues = new ArrayList<>();
Arrays.deepToString(streamValues.toArray()));   

Eğer kullanıyorsanız Eclipse Koleksiyonlar kullanabileceğiniz makeString()yöntemi.

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

Assert.assertEquals(
    "one\ttwo\tthree",
    ArrayListAdapter.adapt(list).makeString("\t"));

İstemiyorsun, mutfakta annene dönüştürebilirsiniz Eğer ArrayListbir etmek FastList, bağdaştırıcı kurtulabilirsiniz.

Assert.assertEquals(
    "one\ttwo\tthree",
    FastList.newListWith("one", "two", "three").makeString("\t"));

Not: Eclipse Collections için bir komisyoncuyum.

List<String> stringList = getMyListOfStrings();
StringJoiner sj = new StringJoiner(" ");
stringList.stream().forEach(e -> sj.add(e));
String spaceSeparated = sj.toString()

new StringJoinerAyırıcı olarak kullanmak istediğiniz karakter dizisine geçersiniz . CSV yapmak istiyorsanız:new StringJoiner(", ");

Bir Satırda: [12,0,1,78,12] ila 12 0 1 78 12

String srt= list.toString().replaceAll("\\[|\\]|,","");

Println yerine sekmeleri kullanarak ayırmak için print

ArrayList<String> mylist = new ArrayList<String>();

mylist.add("C Programming");
mylist.add("Java");
mylist.add("C++");
mylist.add("Perl");
mylist.add("Python");

for (String each : mylist)
{       
    System.out.print(each);
    System.out.print("\t");
}

Ek kaynaklara bağlı olan birkaç örnek görüyorum, ancak en basit çözüm bu gibi görünüyor: .

    List<Account> accounts = new ArrayList<>();

   public String accountList() 
   {
      Account[] listingArray = accounts.toArray(new Account[accounts.size()]);
      String listingString = Arrays.toString(listingArray);
      return listingString;
   }

Bu şimdiye kadar oldukça eski bir konuşma ve apache müşterileri artık dahili olarak bir StringBuilder kullanıyor: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Bu, bildiğimiz gibi performansı geliştirir, ancak performans kritikse, kullanılan yöntem biraz verimsiz olabilir. Arayüz esnektir ve farklı Koleksiyon türlerinde tutarlı davranışa izin verirken, orijinal sorudaki Koleksiyon türü olan Listeler için bir miktar verimsizdir.

Bunu, geleneksel bir döngüdeki unsurları basitçe yineleyerek önleyeceğimiz bir yük oluşturduğumuza dayandırıyorum. Bunun yerine, eşzamanlı modifikasyonları, yöntem çağrılarını vb. Kontrol eden sahne arkasında bazı ek şeyler olur.

Bunun için bir Regex kullanabilirsiniz. Bu olabildiğince özlü

System.out.println(yourArrayList.toString().replaceAll("\\[|\\]|[,][ ]","\t"));

Bu fonksiyon hakkında:

public static String toString(final Collection<?> collection) {
    final StringBuilder sb = new StringBuilder("{");
    boolean isFirst = true;
    for (final Object object : collection) {
        if (!isFirst)
            sb.append(',');
        else
            isFirst = false;
        sb.append(object);
    }
    sb.append('}');
    return sb.toString();
}

her türlü koleksiyon için çalışır ...