Tôi có một ArrayListcái mà tôi muốn xuất hoàn toàn dưới dạng Chuỗi. Về cơ bản tôi muốn xuất nó theo thứ tự bằng cách sử dụng toStringtừng phần tử được phân tách bằng các tab. Có cách nào nhanh chóng để làm điều này? Bạn có thể lặp qua nó (hoặc loại bỏ từng phần tử) và ghép nó thành Chuỗi nhưng tôi nghĩ điều này sẽ rất chậm.

Về cơ bản, sử dụng vòng lặp để lặp lại ArrayListlà tùy chọn duy nhất:

KHÔNG sử dụng mã này, tiếp tục đọc đến cuối câu trả lời này để xem tại sao nó không được mong muốn và thay vào đó nên sử dụng mã nào:

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

Trong thực tế, việc nối chuỗi sẽ trở nên tốt đẹp, vì javactrình biên dịch sẽ tối ưu hóa việc nối chuỗi như một chuỗi các appendthao tác trên StringBuildermọi cách. Đây là một phần của quá trình tháo gỡ mã byte khỏi forvòng lặp từ chương trình trên:

   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;

Có thể thấy, trình biên dịch tối ưu hóa vòng lặp đó bằng cách sử dụng một StringBuilder , vì vậy hiệu suất không phải là một mối quan tâm lớn.

(OK, trong cái nhìn thứ hai, StringBuildernó đang được khởi tạo trên mỗi lần lặp của vòng lặp, vì vậy nó có thể không phải là mã byte hiệu quả nhất. Khởi tạo và sử dụng một tường minhStringBuilder có thể mang lại hiệu suất tốt hơn.)

Trong thực tế, tôi nghĩ rằng có bất kỳ loại đầu ra nào (có thể là vào đĩa hoặc trên màn hình) sẽ có tốc độ chậm hơn so với việc phải lo lắng về hiệu suất của chuỗi nối.

Chỉnh sửa: Như đã chỉ ra trong các nhận xét, tối ưu hóa trình biên dịch ở trên thực sự đang tạo ra một phiên bản mới củaStringBuilder mỗi lần lặp. (Điều mà tôi đã lưu ý trước đây.)

Kỹ thuật được tối ưu hóa nhất để sử dụng sẽ là phản hồi của Paul Tomblin , vì nó chỉ khởi tạo một StringBuilderđối tượng duy nhất bên ngoàifor vòng lặp.

Viết lại mã trên để:

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

Sẽ chỉ khởi tạo StringBuildermột lần bên ngoài vòng lặp và chỉ thực hiện hai cuộc gọi đến appendphương thức bên trong vòng lặp, như được chứng minh trong mã byte này (hiển thị khởi tạo StringBuildervà vòng lặp):

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

Vì vậy, thực sự tối ưu hóa tay nên được thực hiện tốt hơn, vì bên trong forvòng lặp ngắn hơn và không cần phải khởi tạo a StringBuildertrên mỗi lần lặp.

Trong Java 8 trở lên:

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

Trong trường hợp listkhông phải là kiểu String, có thể sử dụng bộ sưu tập nối:

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

Nếu bạn tình cờ làm điều này trên Android, có một tiện ích tuyệt vời cho cái này được gọi là TextUtils có một .join(String delimiter, Iterable)phương thức.

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

Rõ ràng là không sử dụng nhiều bên ngoài Android, nhưng hình dung tôi sẽ thêm nó vào chủ đề này ...

Tải xuống Apache Commons Lang và sử dụng phương thức

 StringUtils.join(list)

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

Tất nhiên, bạn có thể tự thực hiện nó, nhưng mã của họ đã được kiểm tra đầy đủ và có lẽ là triển khai tốt nhất có thể.

Tôi là một fan hâm mộ lớn của thư viện Apache Commons và tôi cũng nghĩ rằng đó là một bổ sung tuyệt vời cho Thư viện tiêu chuẩn Java.

Đây là một câu hỏi khá cũ, nhưng tôi cho rằng tôi cũng có thể thêm một câu trả lời hiện đại hơn - sử dụng Joinerlớp từ Guava :

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

Thay đổi Danh sách thành Chuỗi có thể đọc và có ý nghĩa thực sự là một câu hỏi phổ biến mà mọi người đều có thể gặp phải.

Trường hợp 1 . Nếu bạn có StringUtils của apache trong đường dẫn lớp của bạn (như từ rogerdpack và Ravi Wallau):

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

Trường hợp 2 . Nếu bạn chỉ muốn sử dụng các cách từ JDK (7):

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

Không bao giờ tự mình xây dựng bánh xe, không sử dụng vòng lặp cho nhiệm vụ một dòng này.

Nếu bạn đang tìm kiếm một lớp lót nhanh, kể từ Java 5, bạn có thể làm điều này:

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

Ngoài ra, nếu mục đích của bạn chỉ là in ra nội dung và ít quan tâm đến "\ t", bạn chỉ cần làm điều này:

myList.toString()

trong đó trả về một chuỗi như

[str1, str2, str3]

Nếu bạn có một Array (không phải ArrayList) thì bạn có thể thực hiện tương tự như thế này:

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

Vòng qua nó và gọi toString. Không có một cách kỳ diệu, và nếu có, bạn nghĩ nó sẽ làm gì dưới vỏ bọc ngoài việc lặp đi lặp lại? Về tối ưu hóa vi mô duy nhất sẽ là sử dụng StringBuilder thay vì String và thậm chí đó không phải là một chiến thắng lớn - các chuỗi kết nối biến thành StringBuilder dưới vỏ bọc, nhưng ít nhất nếu bạn viết nó theo cách bạn có thể thấy những gì đang diễn ra.

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

Hầu hết các dự án Java thường có sẵn apache-commons. Các phương thức StringUtils.join () rất hay và có nhiều hương vị để đáp ứng hầu hết mọi nhu cầu.

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

Thông số:

bộ sưu tập - Bộ sưu tập các giá trị để kết hợp với nhau, có thể là null

dấu phân cách - ký tự phân cách sử dụng

Trả về : chuỗi đã tham gia, null nếu đầu vào null iterator

Từ: 2.3

Android có lớp TextUtil, bạn có thể sử dụng http://developer.android.com/reference/android/text/TextUtils.html

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

Đối với trường hợp sử dụng đơn giản này, bạn có thể chỉ cần nối các chuỗi bằng dấu phẩy. Nếu bạn sử dụng Java 8:

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

mặt khác, commons-lang có phương thức nối ():

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

Một cách thanh lịch để đối phó với các ký tự phân tách dấu là sử dụng Trình phân tách lớp

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

Phương thức toString của Trình phân tách lớp trả về dấu phân cách, ngoại trừ cuộc gọi đầu tiên. Do đó, chúng tôi in danh sách mà không có dấu phân cách (hoặc trong trường hợp này) dấu phân cách hàng đầu.

Trong Java 8, nó đơn giản. Xem ví dụ cho danh sách các số nguyên:

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

Hoặc phiên bản đa dòng (đơn giản hơn để đọc):

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

Cập nhật - phiên bản ngắn hơn

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

Đó là một O(n) thuật toán (trừ khi bạn đã thực hiện một số giải pháp đa luồng trong đó bạn chia danh sách thành nhiều danh sách phụ, nhưng tôi không nghĩ đó là những gì bạn đang yêu cầu).

Chỉ cần sử dụng StringBuildernhư dưới đây:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

Nó StringBuildersẽ nhanh hơn rất nhiều so với nối chuỗi bởi vì bạn sẽ không khởi tạo lại một Stringđối tượng trên mỗi nối.

Trong trường hợp bạn tình cờ có mặt trên Android và bạn chưa sử dụng Jack (ví dụ: vì nó vẫn thiếu hỗ trợ cho Instant Run) và nếu bạn muốn kiểm soát nhiều hơn về định dạng của chuỗi kết quả (ví dụ: bạn muốn sử dụng ký tự dòng mới như bộ chia các phần tử) và tình cờ sử dụng / muốn sử dụng thư viện StreamSupport (để sử dụng các luồng trên Java 7 hoặc các phiên bản trước đó của trình biên dịch), bạn có thể sử dụng một cái gì đó như thế này (tôi đặt phương thức này trong lớp ListUtils của tôi):

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

Và tất nhiên, hãy đảm bảo triển khai toString () trên lớp đối tượng danh sách của bạn.

Nếu bạn không muốn phần cuối cùng sau phần tử cuối cùng, bạn phải sử dụng chỉ mục để kiểm tra, nhưng hãy nhớ rằng điều này chỉ "hoạt động" (tức là O (n)) khi danh sách thực hiện 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());

Các mã dưới đây có thể giúp bạn,

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

Đầu ra:

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

Có thể không phải là cách tốt nhất, nhưng cách thanh lịch.

Arrays.deepToString (Arrays.asList ("Kiểm tra", "Test2")

import java.util.Arrays;

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

Đầu ra

[Kiểm tra, Test2]

Điều sau đây sẽ tốt chứ:

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

Nếu bạn đang sử dụng Bộ sưu tập Eclipse , bạn có thể sử dụng makeString()phương thức này.

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

Nếu bạn có thể chuyển đổi ArrayListthành a FastList, bạn có thể thoát khỏi bộ chuyển đổi.

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

Lưu ý: Tôi là người đi làm cho Bộ sưu tập Eclipse.

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

Bạn chuyển đến new StringJoinerchuỗi char bạn muốn được sử dụng làm dấu phân cách. Nếu bạn muốn làm một CSV:new StringJoiner(", ");

Trong một dòng: Từ [12,0,1,78,12] đến 12 0 1 78 12

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

Để phân tách bằng các tab thay vì sử dụng println, bạn có thể sử dụng in

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

Tôi thấy khá nhiều ví dụ phụ thuộc vào các tài nguyên bổ sung, nhưng có vẻ như đây sẽ là giải pháp đơn giản nhất: (đó là những gì tôi đã sử dụng trong dự án của riêng mình), về cơ bản chỉ là chuyển đổi từ ArrayList sang Array và sau đó thành Danh sách .

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

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

Đây là một cuộc trò chuyện khá cũ và hiện tại apache commons đang sử dụng StringBuilder trong nội bộ: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Điều này sẽ như chúng ta biết cải thiện hiệu suất, nhưng nếu hiệu suất là quan trọng thì phương pháp được sử dụng có thể không hiệu quả. Trong khi giao diện linh hoạt và sẽ cho phép hành vi nhất quán trên các loại Bộ sưu tập khác nhau, thì phần nào đó không hiệu quả đối với Danh sách, đây là loại Bộ sưu tập trong câu hỏi ban đầu.

Tôi dựa trên cơ sở này rằng chúng ta đang phải gánh chịu một số chi phí mà chúng ta sẽ tránh bằng cách lặp qua các phần tử trong một vòng lặp truyền thống. Thay vào đó, có một số điều bổ sung xảy ra đằng sau các cảnh kiểm tra sửa đổi đồng thời, gọi phương thức, v.v. Vòng lặp for được tăng cường sẽ dẫn đến cùng một chi phí kể từ khi iterator được sử dụng trên đối tượng Iterable (Danh sách).

Bạn có thể sử dụng Regex cho việc này. Điều này là ngắn gọn như nó được

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

Làm thế nào về chức năng này:

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

nó hoạt động cho bất kỳ loại bộ sưu tập ...