ArrayList को एक स्ट्रिंग में बदलने का सबसे अच्छा तरीका


353

मेरे पास एक ऐसा है ArrayListजिसे मैं पूरी तरह से एक स्ट्रिंग के रूप में आउटपुट करना चाहता हूं। मूल रूप से मैं toStringटैब द्वारा अलग किए गए प्रत्येक तत्व का उपयोग करके इसे आउटपुट करना चाहता हूं । क्या ऐसा करने का कोई तेज़ तरीका है? आप इसके माध्यम से लूप कर सकते हैं (या प्रत्येक तत्व को हटा सकते हैं) और इसे एक स्ट्रिंग तक पहुंचा सकते हैं लेकिन मुझे लगता है कि यह बहुत धीमा होगा।


4
या प्रत्येक तत्व को निकालें सावधान रहें, एरियर सूची से तत्वों को हटाना एक बड़ा NO-NO है, क्योंकि शिफ्टिंग तत्वों (बशर्ते कि आप पहले से अंतिम तत्व तक पहुंचते हैं) के कारण आपका "लूप" द्विघात समय लेगा।
दिमित्री के

संग्रह के लिए समान: stackoverflow.com/questions/395401/…
Ciro Santilli 郝海东 over over over 病

जवाबों:


329

मूल रूप से, एक लूप का उपयोग करने से अधिक उस पर पुनरावृति ArrayListकरना एकमात्र विकल्प है:

इस कोड का उपयोग न करें, इस उत्तर की तह तक पढ़ना जारी रखें कि यह वांछनीय क्यों नहीं है, और इसके बजाय किस कोड का उपयोग किया जाना चाहिए:

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

वास्तव में, एक स्ट्रिंग संघनन बस ठीक होने वाला है, क्योंकि javacसंकलक appendकिसी StringBuilderभी तरह से संचालन की एक श्रृंखला के रूप में स्ट्रिंग संघनन का अनुकूलन करेगा । यहाँ forउपरोक्त कार्यक्रम से लूप से बाईटेकोड के डिस्सैम्ड का एक हिस्सा है :

   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;

जैसा कि देखा जा सकता है, कंपाइलर उस लूप का उपयोग करके अनुकूलन करता है StringBuilder , इसलिए प्रदर्शन को एक बड़ी चिंता नहीं होनी चाहिए।

(ठीक है, दूसरी नज़र में, StringBuilderलूप के प्रत्येक पुनरावृत्ति पर त्वरित किया जा रहा है, इसलिए यह सबसे अधिक बाइटकोड नहीं हो सकता है। झटपट और स्पष्ट का उपयोग करना।StringBuilder संभवतः बेहतर प्रदर्शन होगा।)

वास्तव में, मुझे लगता है कि किसी भी तरह का आउटपुट होना (डिस्क या स्क्रीन पर होना) कम से कम एक परिमाण धीमे का क्रम होगा, ताकि स्ट्रिंग के संघनन के प्रदर्शन की चिंता हो।

संपादित करें: जैसा कि टिप्पणियों में बताया गया है, उपरोक्त संकलक अनुकूलन वास्तव में StringBuilderप्रत्येक पुनरावृत्ति पर एक नया उदाहरण बना रहा है । (जो मैंने पहले नोट किया है।)

उपयोग करने के लिए सबसे अधिक अनुकूलित तकनीक पॉल टॉम्बलिन द्वारा प्रतिक्रिया होगी , क्योंकि यह केवल लूप के StringBuilderबाहर एक ही वस्तु को forइंस्टेंट करता है।

उपरोक्त कोड के लिए:

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

केवल StringBuilderलूप के बाहर एक बार इंस्टेंट कर देगा , और केवल दो कॉल को appendलूप के अंदर की विधि में कर देगा, जैसा कि इस बाइटकोड (जो StringBuilderऔर लूप की तात्कालिकता को दर्शाता है ) में स्पष्ट है :

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

तो, वास्तव में हाथ का अनुकूलन बेहतर प्रदर्शन होना चाहिए, क्योंकि forलूप के अंदर का हिस्सा छोटा होता है और StringBuilderप्रत्येक पुनरावृत्ति पर तुरंत संकेत देने की आवश्यकता नहीं होती है ।


8
प्रदर्शन कारणों के लिए, केवल तार जोड़ने के बजाय एक StringBuilder वर्ग का उपयोग करने पर विचार करें।
जेरेमी

5
यह संकलक स्ट्रिंग संघनन का अनुकूलन करेगा लेकिन आप हर बार लूप निष्पादित होने पर एक नया स्ट्रिंगबुलस्ट ऑब्जेक्ट बना रहे होंगे।
पेड्रो हेनरिक्स

4
-1 के उपयोग के लिए + =, इस मामले में यह एक प्रदर्शन हत्यारा है। स्ट्रिंग को बार-बार जोड़ने के लिए हमेशा स्ट्रिंगबर्ल का उपयोग करें।
starblue

10
यह समाधान स्ट्रिंग के अंत में एक अतिरिक्त "\ t" जोड़ता है, जो अक्सर अवांछित होता है, खासकर जब आप अल्पविराम से अलग सूची या समान बनाना चाहते हैं। मुझे लगता है कि अपाचे कॉमन्स या अमरूद का उपयोग करने वाले अन्य समाधान यहां बेहतर हैं।
पीटर गोएत्ज़

3
यह सबसे अच्छा जवाब नहीं है। नीचे दिए गए विटाली के लिए Javaया जिवाक्स के लिए देखेंAndroid
जिबोल्ट

895

जावा 8 या उसके बाद में:

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

मामले listमें प्रकार स्ट्रिंग का नहीं है, एक शामिल होने वाले कलेक्टर का उपयोग किया जा सकता है:

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

144
मुझे विश्वास नहीं हो रहा है कि इसे जोड़ने के लिए जावा 8 तक लिया गया है।
पॉल

45
यह उत्तर अधिक मतदान होना चाहिए! न कोई हैक, न कोई लाइब्रेरी और न कोई लूप।
सांगो

4
ओपी ने जो कहा उसके लिए यह काम नहीं करता है। String.join दूसरा तर्क मानता है <? विस्तार>। तो यह काम करता है अगर आपके पास एक सूची है <string> जिसे आप प्रदर्शित करना चाहते हैं, लेकिन यदि आपके पास List <MyObject> है, तो वह इसे toString () नहीं
कहेगा जैसा

3
नरक यह पहला (और स्वीकृत) उत्तर क्यों नहीं है .. मुझे हमेशा नीचे स्क्रॉल करना होगा जब तक कि मुझे पता नहीं है कि यह सुरुचिपूर्ण और संक्षिप्त है
जैक


391

यदि आप एंड्रॉइड पर ऐसा कर रहे हैं, तो इसके लिए एक अच्छी उपयोगिता है जिसे TextUtils कहा जाता है जिसमें एक .join(String delimiter, Iterable)विधि है।

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

स्पष्ट रूप से एंड्रॉइड के बाहर ज्यादा उपयोग नहीं किया गया है, लेकिन लगा कि मैं इसे इस धागे से जोड़ूंगा ...


1
के बाद से TextUtils.joinएक लेता है Object[], मुझे लगता है कि यह कॉल कर रहा है मान होता toString()प्रत्येक टोकन पर। PatientDetailsलागू करता है toString()? यदि वह समस्या का समाधान नहीं करता है, तो आप Separatorकक्षा के साथ कुछ कर सकते हैं ।
जे जे गेवाक्स

5
org.apache.lang3.StringUtilsवस्तुतः वही करता है, इसलिए आपका उत्तर बिल्कुल Android के बाहर मेरे लिए बहुत उपयोगी था :)
पैट्रिक

1
इस उत्तर की लोकप्रियता (वर्तमान में सबसे ज्यादा मतदान किया गया है) आपको दिखाता है कि कई जावा प्रश्न एंड्रॉइड विकास से
उपजा है

1
मैं शर्त लगा सकता हूं कि आपको मेरी समस्या हल करने के लिए इस धरती पर भेजा गया था :)
kofoworola

1
तुमने मेरी जान बचाई। <3
प्रतीक बुटानी

234

Apache Commons Lang डाउनलोड करें और विधि का उपयोग करें

 StringUtils.join(list)

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

आप इसे खुद से लागू कर सकते हैं, निश्चित रूप से, लेकिन उनके कोड का पूरी तरह से परीक्षण किया गया है और संभवतः सबसे अच्छा संभव कार्यान्वयन है।

मैं अपाचे कॉमन्स लाइब्रेरी का बहुत बड़ा प्रशंसक हूं और मुझे भी लगता है कि यह जावा मानक लाइब्रेरी के लिए एक बढ़िया अतिरिक्त है।


63
दुर्भाग्य से, एसओ के डेनिज़ेन व्हील को सुदृढ़ करना पसंद करते हैं।
skaffman

33
अपाचे कॉमन्स लैंग में भी। उपयोग की तरह दिखेगाStringUtils.join(list.toArray(),"\t")
Muhd

33
यह विशेष पहिया शायद ही एक अतिरिक्त निर्भरता के लायक है।
सेवा अलेक्सेयेव

25
@SevaAlekseyev मुझे लगता है कि यह बहस का मुद्दा है। यदि आप इस निर्भरता को तुरंत जोड़ते हैं, तो आप इसकी कक्षाओं का उपयोग अधिक से अधिक बार करेंगे। इसके बजाय "अगर स्ट्रिंग! = Null && string.trim ()! =" "का उपयोग करने के बजाय आप StringUtils.isNotEmpty का उपयोग करेंगे ... आप ObjectUtils.equals () का उपयोग करेंगे ताकि आपको हर जगह नल की जांच न करनी पड़े। लेकिन यदि आप एक निर्भरता के लिए इंतजार है कि इन पुस्तकालयों का उपयोग कर सही ठहराते हैं, आप वास्तव में उन्हें इस्तेमाल कभी नहीं हो सकता है।
रवि Wallau

6
यह भी अच्छा है कि यह अंत में एक अतिरिक्त टैब नहीं जोड़ेगा!
केयूएलजे

139

यह एक बहुत पुराना सवाल है, लेकिन मुझे लगता है कि मैं एक और आधुनिक उत्तर जोड़ सकता हूं - अमरूदJoiner से कक्षा का उपयोग करें :

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

2
यह मेरा पसंदीदा उपाय है। : - अमरूद के लिए +1।
सीएसकेक

साथ ही अमरूद के लिए Ctrl + F'd। धन्यवाद!
प्रिड्यू नीमरे

सूची <स्ट्रिंग> सूची = नया एरियर सूची <स्ट्रिंग> (); list.add ( "हैलो"); list.add ( "हाई"); list.add ( "हाय"); System.out.println (list.toString ()। सबस्ट्रिंग (1, list.toString (); लंबाई) () - 1) .replaceAll (",", "\ t"));
लोवा चित्तमुरी

86

एक पठनीय और सार्थक स्ट्रिंग में सूची बदलना वास्तव में एक सामान्य प्रश्न है जिसका सामना हर व्यक्ति कर सकता है।

केस 1 । यदि आपके पास अपने क्लास पथ (जैसे कि रेजरडैक और रवि वालौ से Apache's StringUtils) हैं:

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

केस 2 । यदि आप केवल JDK (7) से तरीकों का उपयोग करना चाहते हैं:

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

बस अपने आप से कभी पहियों का निर्माण न करें, न ही इस एक-पंक्ति कार्य के लिए लूप का उपयोग करें।


1
मैंने अपना केस पोस्ट करने से पहले अपने केस 2 के समाधान पर ध्यान नहीं दिया। तुम्हारा वास्तव में बहुत बेहतर है और अतिरिक्त कदम बचाता है। मैं निश्चित रूप से अतिरिक्त उपकरणों की आवश्यकता वाले कुछ उत्तरों पर यह निश्चित रूप से सुझाऊंगा।
एलियनडर

5
Arrays.toString(myList.toArray())- सबसे आसान और सबसे सरल उपाय
Ondrej Bozek

मुझे लगता है कि इसे सबसे अच्छा और सबसे कुशल समाधान माना जाना चाहिए
Morey

Arrays.toString(list.toArray())लिखना आसान है, लेकिन अत्यधिक अक्षम है।
मैथ्यू

60

यदि आप एक त्वरित-लाइनर की तलाश में थे, तो जावा 5 के अनुसार आप यह कर सकते हैं:

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

इसके अतिरिक्त, यदि आपका उद्देश्य केवल सामग्री को प्रिंट करना है और "\" के बारे में कम चिंतित हैं, तो आप बस ऐसा कर सकते हैं:

myList.toString()

जो एक स्ट्रिंग लौटाता है

[str1, str2, str3]

यदि आपके पास एक ऐरे (ArrayList नहीं) है, तो आप इसे इस तरह पूरा कर सकते हैं:

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

3
मुझे लगता है कि यह वास्तव में अधिक कुशल है कि ऊपर पोस्ट किए गए तरीके। इस तरह के एक शर्म की बात है कि यह नीचे दिखाया गया है। यह सुरुचिपूर्ण नहीं हो सकता है, लेकिन मेरा दृढ़ता से मानना ​​है कि आपका समाधान ओ (एन) चलाता है, जबकि अन्य सैद्धांतिक रूप से ओ (एन ^ 2) में चलते हैं (क्योंकि जावा स्ट्रिंग्स अपरिवर्तनीय हैं क्योंकि आप मूल रूप से हर मर्ज पर एक नया स्ट्रिंग बनाते हैं, और यह खराब हो जाता है परिणामी स्ट्रिंग बड़ी हो जाती है)
user3790827

यदि आपका पाठ बहुत बड़ा है तो आप अपने कंप्यूटर संसाधनों को समाप्त करते हैं।
user3790827

यह विधि StringBuilder का उपयोग करने की तुलना में 7-8 गुना अधिक धीमी है।
ज़ोका

@ user3790827 आप बहुत सतही स्तर पर देख रहे हैं। अगर मैं आपको राज्यों mमें nशहरों में घरों में किसी व्यक्ति की खोज करने के लिए कहता हूं x, तो आप कहेंगे कि यह O(mnx)या O(n^3), लेकिन मैं इसे "इस देश में इस व्यक्ति की तलाश" कहने के लिए इसे फिर से लिख सकता हूं, और आप तुरंत मुझे बताएंगे O(n)। उसके शीर्ष पर O(n), यहां सभी एल्गोरिदम आम तौर पर हैं , लूप के भीतर कोई लूपिंग नहीं है ।
जय

39

इसके माध्यम से लूप करें और स्ट्रिंग को कॉल करें। कोई जादू का रास्ता नहीं है, और अगर वहाँ थे, तो आपको क्या लगता है कि यह लूपिंग के अलावा अन्य कवर के तहत कर रहा होगा? केवल माइक्रो-ऑप्टिमाइजेशन के बारे में स्ट्रिंग के बजाय स्ट्रिंगबर्ल का उपयोग करना होगा, और यहां तक ​​कि एक बड़ी जीत नहीं है - कंक्रीटिंग स्ट्रिंग्स को कवर के नीचे स्ट्रिंगब्यूलर में बदल जाता है, लेकिन कम से कम यदि आप इसे इस तरह से लिखते हैं कि आप देख सकते हैं कि क्या चल रहा है।

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

धन्यवाद! यह वही है जो मैं कर रहा हूं :)
जुआन बेसा

4
बड़े सरणियों के लिए यह निश्चित रूप से सूक्ष्म-अनुकूलन नहीं है। StringBuilder का उपयोग करने के लिए स्वचालित रूपांतरण प्रत्येक स्ट्रिंग संघनन के लिए अलग से किया जाता है, जो लूप के मामले में मदद नहीं करता है। यदि आप एक अभिव्यक्ति में बड़ी संख्या में तत्वों को एकत्र करते हैं, तो यह ठीक है।
starblue

1
यदि आप सहमति दे रहे हैं तो StringBuilder का उपयोग करना एक बड़ी बात है, मान लें कि 50 000 स्ट्रिंग्स ~ 1 एमबी परिणाम स्ट्रिंग बनाते हैं - यह 1 मिनट के निष्पादन समय की तुलना में 1 मिनट का अंतर हो सकता है।
श्री नेपिक

36

अधिकांश जावा परियोजनाओं में अक्सर अपाचे-कॉमन्स लैंग उपलब्ध होते हैं। StringUtils.join () तरीके बहुत अच्छे हैं और लगभग हर ज़रूरत को पूरा करने के लिए कई स्वाद हैं।

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

पैरामीटर:

संग्रह - एक साथ जुड़ने के लिए मूल्यों का संग्रह, शून्य हो सकता है

विभाजक - विभाजक चरित्र का उपयोग करने के लिए

रिटर्न : स्ट्रिंग में शामिल हो गया, अशक्त अगर अशक्त इटरेटर इनपुट

चूंकि: 2.3


2
यह बहुत अच्छा है क्योंकि join(...)विधि में सरणियों और संग्रह दोनों के लिए भिन्न रूप हैं।
वाइकिंगस्टेव

मुझे रैंडम नंबरों के साथ शायद ही आबादी वाले तत्वों के साथ तार के संग्रह बनाने की आवश्यकता थी। अंत में मुझे एक स्ट्रिंग की आवश्यकता थी, स्ट्रिंग के लिए सरणी नहीं। यह मेरा कोड है: कलेक्शंस.शफल (एल); StringBuilder sb = new StringBuilder (); L.forEach (e -> sb.append (e)); रिटर्न sb.toString ();
dobrivoje


14

इस सरल उपयोग के मामले के लिए, आप बस कॉमा के साथ तार में शामिल हो सकते हैं। यदि आप जावा 8 का उपयोग करते हैं:

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

अन्यथा कॉमन्स-लैंग में एक सम्मिलित () विधि है:

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

13

अनुगामी पृथक्करण वर्णों से निपटने का एक सुंदर तरीका है क्लास सेपरेटर का उपयोग करना

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

प्रथम पृथक्करण को छोड़कर , क्लास सेपरेटर की स्टर्लिंग विधि विभाजक लौटाती है । इस प्रकार हम सूची को अलग किए बिना (या इस मामले में) प्रमुख विभाजक को छापते हैं।


8

Java 8 में यह सरल है। पूर्णांक की सूची के लिए उदाहरण देखें:

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

या बहुस्तरीय संस्करण (जो पढ़ने में सरल है):

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

अद्यतन - एक छोटा संस्करण

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

2
यह केवल कोड की एक पंक्ति हो सकती है, लेकिन मेरे लिए जो सरल नहीं लगती है। मेरे लिए सूची को ट्रेस करना और स्ट्रिंग में इसके तत्वों को पार्स करना इससे आसान है।
बार्टजिला

1
यह मेरी पहली धारणा भी थी। लेकिन जब मुझे इसकी आदत हो जाती है तो मुझे यह बहुत अच्छा लगता है। उदाहरण के लिए आप जैसे संचालन जोड़ सकते हैं filter। अंत में मेरे लिए कोड पढ़ना बहुत आसान है।
अमरा

3
जावा 8 में: String.join ("\ t", सरणी)
टॉमस

अंतिम टिप्पणी केवल तभी काम करती है जब सामग्री एक Stringअच्छी तरह से हो। यदि इसकी सूची Integerआपके लिए एक समस्या है
LeO

उन सभी 3 को Android पर API स्तर 24 की आवश्यकता होती है।
Asad35Waheed

6

यह एक O(n) तरह से एल्गोरिथ्म है (जब तक कि आपने कुछ मल्टी-थ्रेडेड सॉल्यूशन नहीं किया था, जहां आपने सूची को कई सब्लिस्ट में तोड़ दिया था, लेकिन मुझे नहीं लगता कि आप जो पूछ रहे हैं)।

बस StringBuilderनीचे दिए अनुसार उपयोग करें:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

StringBuilderस्ट्रिंग संयोजन की तुलना में बहुत तेजी से हो सकता है क्योंकि आप फिर से instantiating एक नहीं होंगी Stringप्रत्येक संयोजन पर वस्तु।


5

यदि आप एंड्रॉइड पर होते हैं और आप अभी तक जैक का उपयोग नहीं कर रहे हैं (जैसे कि यह अभी भी इंस्टेंट रन के लिए समर्थन की कमी है), और यदि आप परिणामी स्ट्रिंग के प्रारूपण पर अधिक नियंत्रण चाहते हैं (जैसे आप न्यूलाइन वर्ण का उपयोग करना चाहेंगे तत्वों का विभक्त), और स्ट्रीमसुपोर्ट लाइब्रेरी (कंपाइलर के जावा 7 या पूर्व संस्करणों पर धाराओं का उपयोग करने के लिए) का उपयोग / करना चाहते हैं, आप इस तरह से कुछ का उपयोग कर सकते हैं (मैंने इस विधि को अपने ListUtils वर्ग में रखा है:

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

और हां, अपनी सूची ऑब्जेक्ट्स की कक्षा पर toString () को लागू करना सुनिश्चित करें।


1
reduceस्ट्रिंग संघनन के लिए उपयोग करना बेहद अक्षम है। आपको इसे जावा 8 तरीके से करना चाहिए return StreamSupport.stream(list).map(Object::toString).collect(joining("\n"))जो आंतरिक रूप से उपयोग करता है StringJoiner। ऐसा कोई कारण नहीं है कि आप स्ट्रीम स्ट्रीमपोर्ट के साथ भी ऐसा नहीं कर सकते ।
स्टीफन ज़ॉबेल

एक और बात यह है कि यदि आपका कोड Optional#getखाली सूची से गुजर जाता है, तो आपका कोड बुरी तरह से विफल हो जाएगा ।
स्टीफन ज़ॉबेल

@StefanZobel दक्षता और बढ़त मामले के मुद्दों को इंगित करने के लिए धन्यवाद। कोड को संशोधित किया।
जावेद सादिक़ज़ादेह

3

यदि आप अंतिम तत्व के बाद last \ t नहीं चाहते हैं, तो आपको जाँच करने के लिए अनुक्रमणिका का उपयोग करना होगा, लेकिन याद रखें कि यह केवल "काम करता है" (यानी O (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());

3

नीचे दिया गया कोड आपकी मदद कर सकता है,

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

आउटपुट:

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

3

सबसे अच्छा तरीका नहीं हो सकता है, लेकिन सुरुचिपूर्ण तरीका है।

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

उत्पादन

[टेस्ट, टेस्ट २]


1
मुझे लगता है कि यह सबसे अच्छा तरीका है अगर "सर्वश्रेष्ठ" का मतलब कोड पठनीयता है। मैंने कोड को नहीं देखा है, लेकिन यह शायद स्ट्रिंगब्यूलर पद्धति की तरह ही कुशल है (यह शायद हुड के नीचे स्ट्रिंग स्ट्रिंग का उपयोग करता है), हालांकि आउटपुट में अनुकूलन योग्य नहीं है।
माइक मिलर

3

निम्नलिखित कोई अच्छा होगा:

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

3

यदि आप ग्रहण संग्रह का उपयोग कर रहे हैं , तो आप makeString()विधि का उपयोग कर सकते हैं ।

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

यदि आप अपने ArrayListको a में बदल सकते हैं FastList, तो आप एडॉप्टर से छुटकारा पा सकते हैं।

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

नोट: मैं एक्लिप्स कलेक्शंस के लिए कमिट हूं।


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

आप new StringJoinerचार अनुक्रम के पास से गुजरते हैं जिसे आप विभाजक के रूप में उपयोग करना चाहते हैं। यदि आप एक सीएसवी करना चाहते हैं:new StringJoiner(", ");


3

एक पंक्ति में: [१२,०,१, Line 12,१२] से १२ ० १। [१२ तक

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

2
1) इस तरह कोड का उपयोग करने का कोई कारण नहीं है (जैसा कि 4 साल पहले!)। 2) यह उत्तर प्रश्नोत्तर में कुछ भी नहीं जोड़ता है।
रेडिओडफ

एक लाइन में 5 स्टार। बहुत बहुत धन्यवाद।
पूर्वे फ़ारूक

यह पूरी तरह से काम करता है। अल्पविराम से अलग किए गए स्ट्रिंग उपयोग के लिए: स्ट्रिंग srt = list.toString ()। ReplaceAll ("\ _ \ _" "," ");
Asad35Waheed

2

टैब का उपयोग कर अलग करने के बजाय का उपयोग कर के लिए println आप उपयोग कर सकते हैं प्रिंट

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

1

मुझे काफी कुछ उदाहरण दिखाई देते हैं जो अतिरिक्त संसाधनों पर निर्भर करते हैं, लेकिन ऐसा लगता है कि यह सबसे सरल समाधान होगा: (जो कि मैंने अपने प्रोजेक्ट में उपयोग किया है) जो मूल रूप से एक ArrayList से Array और फिर एक List में परिवर्तित हो रहा है ।

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

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

0

यह अब तक काफी पुरानी बातचीत है और अपाचे कॉमन्स अब आंतरिक रूप से एक स्ट्रिंगब्यूलर का उपयोग कर रहे हैं: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StuUtils.html#line। 3045

जैसा कि हम जानते हैं कि प्रदर्शन में सुधार होगा, लेकिन यदि प्रदर्शन महत्वपूर्ण है, तो उपयोग की जाने वाली विधि कुछ हद तक अक्षम हो सकती है। जबकि इंटरफ़ेस लचीला है और विभिन्न संग्रह प्रकारों में लगातार व्यवहार के लिए अनुमति देगा यह सूचियों के लिए कुछ हद तक अक्षम है, जो मूल प्रश्न में संग्रह का प्रकार है।

मैं इसमें यह आधार देता हूं कि हम कुछ ओवरहेड कर रहे हैं जिसे हम लूप के लिए पारंपरिक रूप से तत्वों के माध्यम से पुनरावृत्त होने से बचाएंगे। इसके बजाय समवर्ती संशोधनों, विधि कॉल आदि के लिए जाँच करने वाले पर्दे के पीछे कुछ अतिरिक्त चीजें हो रही हैं। लूप के लिए संवर्धित परिणाम उसी ओवरहेड में होगा जिसके बाद से इटरेटर का उपयोग Iterable ऑब्जेक्ट (सूची) पर किया जाता है।


0

आप इसके लिए एक Regex का उपयोग कर सकते हैं। यह उतना ही संक्षिप्त है जितना इसे मिलता है

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

-1

इस समारोह के बारे में कैसे:

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

यह किसी भी प्रकार के संग्रह के लिए काम करता है ...

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.