Saya punya ArrayListyang ingin saya hasilkan sepenuhnya sebagai String. Pada dasarnya saya ingin menampilkannya dengan menggunakan toStringmasing-masing elemen yang dipisahkan oleh tab. Apakah ada cara cepat untuk melakukan ini? Anda dapat mengulanginya (atau menghapus setiap elemen) dan menggabungkannya ke sebuah String tetapi saya pikir ini akan sangat lambat.

Pada dasarnya, menggunakan loop untuk beralih di atas ArrayListadalah satu-satunya pilihan:

JANGAN gunakan kode ini, lanjutkan membaca di bagian bawah jawaban ini untuk melihat mengapa itu tidak diinginkan, dan kode mana yang harus digunakan sebagai gantinya:

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

Bahkan, rangkaian string akan baik-baik saja, karena javackompiler akan mengoptimalkan rangkaian string sebagai serangkaian appendoperasi pada StringBuilderpokoknya. Berikut adalah bagian dari pembongkaran bytecode dari forloop dari program di atas:

   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;

Seperti yang dapat dilihat, kompiler mengoptimalkan loop itu dengan menggunakan StringBuilder, jadi kinerja seharusnya tidak menjadi perhatian besar.

(OK, pada pandangan kedua, StringBuildersedang dipakai pada setiap iterasi dari loop, jadi itu mungkin bukan bytecode paling efisien. Instantiating dan menggunakan eksplisit StringBuildermungkin akan menghasilkan kinerja yang lebih baik.)

Bahkan, saya berpikir bahwa memiliki segala jenis output (baik itu ke disk atau ke layar) akan setidaknya urutan besarnya lebih lambat daripada harus khawatir tentang kinerja rangkaian string.

Sunting: Seperti yang ditunjukkan dalam komentar, optimisasi kompiler di atas memang membuat contoh baru StringBuilderpada setiap iterasi. (Yang telah saya catat sebelumnya.)

Teknik yang paling optimal untuk digunakan akan menjadi respons oleh Paul Tomblin , karena hanya instantiate satu StringBuilderobjek di luar forloop.

Menulis ulang kode di atas ke:

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

Hanya akan membuat instantiate di StringBuilderluar loop, dan hanya membuat dua panggilan ke appendmetode di dalam loop, seperti dibuktikan dalam bytecode ini (yang menunjukkan instantiation StringBuilderdan loop):

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

Jadi, memang optimasi tangan harus berkinerja lebih baik, karena bagian dalam forloop lebih pendek dan tidak perlu instantiate StringBuilderpada setiap iterasi.

Di Java 8 atau lebih baru:

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

Jika listbukan tipe String, kolektor gabungan dapat digunakan:

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

Jika Anda kebetulan melakukan ini di Android, ada utilitas bagus untuk ini yang disebut TextUtils yang memiliki .join(String delimiter, Iterable)metode.

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

Jelas tidak banyak digunakan di luar Android, tetapi saya pikir saya akan menambahkannya ke utas ini ...

Unduh Apache Commons Lang dan gunakan metode ini

 StringUtils.join(list)

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

Anda dapat mengimplementasikannya sendiri, tentu saja, tetapi kode mereka sepenuhnya diuji dan mungkin merupakan implementasi terbaik.

Saya penggemar berat perpustakaan Apache Commons dan saya juga berpikir itu merupakan tambahan yang bagus untuk Java Standard Library.

Ini adalah pertanyaan yang cukup lama, tetapi saya pikir saya mungkin juga menambahkan jawaban yang lebih modern - gunakan Joinerkelas dari Guava :

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

Mengubah Daftar menjadi String yang dapat dibaca dan bermakna adalah pertanyaan umum yang mungkin dihadapi setiap orang.

Kasus 1 . Jika Anda memiliki StringUtils apache di jalur kelas Anda (seperti dari rogerdpack dan Ravi Wallau):

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

Kasus 2 . Jika Anda hanya ingin menggunakan cara dari JDK (7):

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

Hanya tidak pernah membuat roda sendiri, jangan gunakan lingkaran untuk tugas satu baris ini.

Jika Anda mencari one-liner cepat, pada Java 5 Anda dapat melakukan ini:

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

Selain itu, jika tujuan Anda hanya untuk mencetak konten dan kurang peduli tentang "\ t", Anda dapat melakukan ini:

myList.toString()

yang mengembalikan string seperti

[str1, str2, str3]

Jika Anda memiliki Array (bukan ArrayList) maka Anda dapat melakukan hal yang sama seperti ini:

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

Loop melalui itu dan panggil toString. Tidak ada cara ajaib, dan jika ada, menurut Anda apa yang akan dilakukannya di balik selimut selain mengulanginya? Tentang satu-satunya optimasi mikro adalah menggunakan StringBuilder, bukan String, dan bahkan itu bukan kemenangan besar - string gabungan berubah menjadi StringBuilder di bawah selimut, tetapi setidaknya jika Anda menulisnya dengan cara itu Anda dapat melihat apa yang terjadi.

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

Sebagian besar proyek Java sering memiliki apache-commons lang tersedia. Metode StringUtils.join () sangat bagus dan memiliki beberapa rasa untuk memenuhi hampir setiap kebutuhan.

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

Parameter:

koleksi - Koleksi nilai untuk bergabung bersama, mungkin nol

separator - karakter pemisah yang digunakan

Pengembalian : String yang bergabung, input iterator nol jika nol

Sejak: 2.3

Android memiliki kelas TextUtil, Anda dapat menggunakan http://developer.android.com/reference/android/text/TextUtils.html

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

Untuk kasus penggunaan sederhana ini, Anda dapat dengan mudah menggabungkan string dengan koma. Jika Anda menggunakan Java 8:

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

jika tidak commons-lang memiliki metode join ():

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

Cara yang elegan untuk berurusan dengan karakter pemisahan yang tertinggal adalah dengan menggunakan Pemisah Kelas

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

Metode toString dari Class Separator mengembalikan separater, kecuali untuk panggilan pertama. Jadi kami mencetak daftar tanpa tertinggal (atau dalam hal ini) pemisah terkemuka.

Di Java 8 itu sederhana. Lihat contoh untuk daftar bilangan bulat:

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

Atau versi multiline (yang lebih mudah dibaca):

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

Perbarui - versi yang lebih pendek

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

Ini adalah O(n)algoritma yang baik (kecuali Anda melakukan beberapa solusi multi-threaded di mana Anda memecah daftar menjadi beberapa sublists, tapi saya tidak berpikir itu yang Anda minta).

Gunakan saja StringBuilderseperti di bawah ini:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

The StringBuilderakan jauh lebih cepat daripada Rangkaian string karena Anda tidak akan kembali instantiating Stringobjek pada setiap rangkaian.

Jika Anda kebetulan menggunakan Android dan Anda belum menggunakan Jack (mis. Karena masih kurang dukungan untuk Instant Run), dan jika Anda ingin lebih mengontrol format string yang dihasilkan (mis. Anda ingin menggunakan karakter baris baru sebagai pembagi elemen), dan kebetulan menggunakan / ingin menggunakan pustaka StreamSupport (untuk menggunakan stream di Java 7 atau versi sebelumnya dari kompiler), Anda dapat menggunakan sesuatu seperti ini (saya meletakkan metode ini di kelas ListUtils saya):

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

Dan tentu saja, pastikan untuk mengimplementasikan toString () pada kelas objek daftar Anda.

Jika Anda tidak ingin yang terakhir setelah elemen terakhir, Anda harus menggunakan indeks untuk memeriksa, tetapi ingat bahwa ini hanya "berfungsi" (yaitu O (n)) ketika daftar mengimplementasikan RandomAccess.

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

Kode di bawah ini dapat membantu Anda,

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

Keluaran:

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

Mungkin bukan cara terbaik, tapi cara yang elegan.

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

Keluaran

[Tes, Test2]

Apakah yang berikut ini ada gunanya:

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

Jika Anda menggunakan Eclipse Collections , Anda dapat menggunakan makeString()metode ini.

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

Jika Anda dapat mengonversi ArrayListke FastList, Anda dapat menyingkirkan adaptor.

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

Catatan: Saya pengendara untuk Eclipse Collections.

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

Anda meneruskan ke new StringJoinerurutan char yang ingin Anda gunakan sebagai pemisah. Jika Anda ingin melakukan CSV:new StringJoiner(", ");

Dalam satu Baris: Dari [12,0,1,78,12] menjadi 12 0 1 78 12

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

Untuk memisahkan menggunakan tab daripada menggunakan println Anda dapat menggunakan 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");
}

Saya melihat beberapa contoh yang tergantung pada sumber daya tambahan, tetapi sepertinya ini akan menjadi solusi paling sederhana: (yang saya gunakan dalam proyek saya sendiri) yang pada dasarnya hanya mengkonversi dari ArrayList ke Array dan kemudian ke Daftar .

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

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

Ini adalah percakapan yang cukup lama sekarang dan apache commons sekarang menggunakan StringBuilder secara internal: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Ini akan seperti yang kita ketahui meningkatkan kinerja, tetapi jika kinerja sangat penting maka metode yang digunakan mungkin agak tidak efisien. Sedangkan antarmuka fleksibel dan akan memungkinkan untuk perilaku yang konsisten di berbagai jenis Koleksi itu agak tidak efisien untuk Daftar, yang merupakan jenis Koleksi dalam pertanyaan awal.

Saya mendasarkan ini di bahwa kita mengeluarkan beberapa overhead yang kita akan hindari dengan hanya mengulangi elemen-elemen dalam tradisional untuk loop. Sebaliknya ada beberapa hal tambahan yang terjadi di belakang layar memeriksa modifikasi bersamaan, panggilan metode dll. Peningkatan loop akan di sisi lain menghasilkan overhead yang sama karena iterator digunakan pada objek Iterable (Daftar).

Anda dapat menggunakan Regex untuk ini. Ini singkat seperti yang didapat

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

Bagaimana dengan fungsi ini:

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

ini bekerja untuk semua jenis koleksi ...