अल्पविराम का सबसे आसान तरीका एक सूची है?

Question

जावा में एक सूची बनाने के लिए सबसे स्पष्ट तरीका क्या है?

मैं इसे करने के कई तरीकों को जानता हूं, लेकिन मैं सोच रहा हूं कि सबसे अच्छा तरीका क्या है (जहां "सबसे अच्छा" का मतलब सबसे स्पष्ट और / या सबसे छोटा है, सबसे कुशल नहीं है।

मेरे पास एक सूची है और मैं इसके ऊपर लूप करना चाहता हूं, प्रत्येक मूल्य को प्रिंट करना। मैं प्रत्येक आइटम के बीच अल्पविराम मुद्रित करना चाहता हूं, लेकिन पिछले एक के बाद (न ही पहले वाले से पहले)।

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

नमूना समाधान 1:

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

नमूना समाधान 2 - एक सबलिस्ट बनाएं:

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

नमूना समाधान 3:

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

ये पहले आइटम को विशेष रूप से मानते हैं; इसके बजाय पिछले एक विशेष रूप से इलाज कर सकता है।

संयोग से, यहाँ कैसे है List toString है कार्यान्वित (यह से विरासत में मिली है AbstractCollection), जावा 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(", ");
    }
}

यह अंतिम आइटम के बाद अल्पविराम से बचने के लिए लूप को जल्दी से बाहर निकालता है। BTW: यह पहली बार है जब मुझे याद आया "(यह संग्रह)"; इसे भड़काने के लिए यहाँ कोड है:

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

मैं किसी भी समाधान का स्वागत करता हूं, भले ही वे अप्रत्याशित पुस्तकालयों का उपयोग करें (regexp?); और यह भी जावा अलावा अन्य भाषाओं में समाधान (जैसे मुझे लगता है कि अजगर / रूबी एक है बिखेरना समारोह - कैसे है कि ? कार्यान्वित)।

स्पष्टीकरण : पुस्तकालयों द्वारा, मेरा मतलब मानक जावा पुस्तकालयों से है। अन्य पुस्तकालयों के लिए, मैं उन्हें अन्य भाषाओं के साथ विचार करता हूं, और यह जानने के लिए दिलचस्पी रखता हूं कि वे कैसे लागू होते हैं।

EDIT टूलकिट ने एक समान प्रश्न का उल्लेख किया: जावा में लूप के लिए बढ़ाया का अंतिम पुनरावृत्ति

और दूसरा: क्या एक लूप में अंतिम तत्व एक अलग उपचार के लायक है?

Comments

के संभावित डुप्लिकेट सबसे अच्छा तरीका क्या जावा में सीमांकित मदों की एक स्ट्रिंग के निर्माण के लिए है?

— राएडवल्ड

Answer 1

जावा 8 और बाद में

StringJoinerवर्ग का उपयोग करना :

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

उपयोग करना Stream, और Collectors:

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

जावा 7 और पहले

# 285523 भी देखें

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

Comments

राज्य को स्टोर करने का एक बहुत ही आश्चर्यजनक तरीका! यह लगभग OO बहुरूपी है। मुझे हर लूप में अनावश्यक असाइनमेंट पसंद नहीं है, लेकिन मुझे यकीन है कि यह एक से अधिक कुशल है। अधिकांश समाधान एक परीक्षण को दोहराते हैं जो हम जानते हैं कि यह सच नहीं होगा - हालांकि अक्षम है, वे संभवतः सबसे स्पष्ट हैं। लिंक के लिए धन्यवाद!

— 13

मुझे यह पसंद है, लेकिन क्योंकि यह चतुर और आश्चर्य की बात है, मैंने सोचा कि इसका उपयोग करना उचित नहीं होगा (आश्चर्य अच्छा नहीं है!)। हालाँकि, मैं अपनी मदद नहीं कर सका। मैं अभी भी इसके बारे में निश्चित नहीं हूं; हालाँकि, यह इतना कम है कि यह काम करना आसान है, बशर्ते आपको टिप देने के लिए कोई टिप्पणी हो।

— 13

@ 13ren: आपको और चाचा बॉब को कोड के बारे में बात करने की ज़रूरत है जो "चतुर और आश्चर्यजनक है।"

— स्टीफन केंडल

मुझे ऐसा लग रहा है कि मैं बरसों से इसे नहीं जानता हूं ^ ^;

— लेक

जावा को ऐसे कार्य को बदसूरत कोड में बदलने की आवश्यकता क्यों है?

— एडुआर्डो

Answer 2

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

Comments

स्रोत मिला: svn.apache.org/viewvc/commons/proper/lang/trunk/src/java/org/… जॉइन विधि में 9 ओवरलोडिंग हैं। पुनरावृति-आधारित "नमूना समाधान 3" की तरह हैं; इंडेक्स-आधारित वाले उपयोग करते हैं: if (i> startIndex) {<add विभाजक>}

— 13ren

मैं वास्तव में कार्यान्वयन के बाद कर रहा हूँ। इसे एक फ़ंक्शन में लपेटना एक अच्छा विचार है, लेकिन व्यवहार में, मेरा सीमांकक कभी-कभी एक नई रेखा होता है, और प्रत्येक पंक्ति कुछ निर्दिष्ट गहराई तक भी होती है। जब तक ... शामिल न हों (सूची, "\ n" + इंडेंट) ... क्या वह हमेशा काम करेगा? क्षमा करें, बस जोर से सोच।

— 13

मेरी राय में, यह सबसे छोटा और सबसे छोटा उपाय है

— जेसपर रॉन-जेनसन

शायद, list.iterator ()?

— वानुआन

Answer 3

जावा 8 ऐसा करने के लिए कई नए तरीके प्रदान करता है:

• joinपर विधि String।
• कक्षा joiningसे धाराओं के लिए एक कलेक्टर Collectors।
• StringJoinerवर्ग।

उदाहरण:

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

धाराओं का उपयोग करने वाला दृष्टिकोण मानता है import static java.util.stream.Collectors.joining;।

Comments

यह IMHO है, यदि आप जावा 8 का उपयोग कर रहे हैं, तो सबसे अच्छा जवाब।

— स्क्रेवी

Answer 4

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

जुड़ने वाला ।

Comments

मैं यहां कुछ ऐसी चीज की तलाश में आया था जो ऐसा करती है। धन्यवाद! +1

— javamonkey79

वही। इसके लिए धन्यवाद। अंत में, कोई समझदार।

— TWR कोल

Answer 5

यदि आप स्प्रिंग फ्रेमवर्क का उपयोग करते हैं, तो आप इसे स्ट्रिंगट्रिल्स के साथ कर सकते हैं :

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)

Comments

धन्यवाद, लेकिन इसे कैसे लागू किया जाता है?

— 13ren

Answer 6

जावा की सूची के आधार पर कार्यान्वयन कार्यान्वयन:

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

यह इस तरह एक व्याकरण का उपयोग करता है:

List --> (Item , )* Item

पहले-आधारित के बजाय अंतिम-आधारित होने से, यह एंड-ऑफ़-लिस्ट की जांच करने के लिए उसी टेस्ट के साथ स्किप-कॉमा की जांच कर सकता है। मुझे लगता है कि यह बहुत ही सुंदर है, लेकिन मैं स्पष्टता के बारे में निश्चित नहीं हूं।

Answer 7

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

Answer 8

जावा 8 का उपयोग करके इसे प्राप्त करने का एक सुंदर तरीका है:

List<String> list = Arrays.asList(array);
String joinedString = String.join(",", list);

Comments

TextUtils.join (",", सूची);

— अरुल पांडियन

Answer 9

for(int i=0, length=list.size(); i<length; i++)
  result+=(i==0?"":", ") + list.get(i);

Comments

हाँ, यह थोड़ा गूढ़ है, लेकिन जो पहले से ही पोस्ट किया गया है, उसके लिए एक विकल्प।

— चेरोविम

मुझे लगता है कि कोड ठीक है, IMHO अपने अन्य उत्तर की तुलना में अधिक सुंदर है और इसकी शायद ही 'गुप्त' है। Join और अपने हँसने नामक विधि में इसे लपेटें, फिर भी मैं उम्मीद करूंगा कि भाषा को हल करने का एक बेहतर तरीका होगा जो वास्तव में एक आम समस्या है।

— तारण

@ टार्टन: आपको लगता है कि यह अच्छा लग रहा है क्योंकि आपके पास पायथन / पर्ल बैकग्राउंड है;) मुझे यह पसंद है

— चेरोविम

Answer 10

फॉरच लूप का एक विकल्प है:

StringBuilder sb = new StringBuilder();
for(String s:list){
  if (sb.length()>0) sb.append(",");
  sb.append(s);
}

Answer 11

StringBuffer result = new StringBuffer();
for(Iterator it=list.iterator; it.hasNext(); ) {
  if (result.length()>0)
    result.append(", ");
  result.append(it.next());
}

अपडेट : जैसा कि डेव वेब ने टिप्पणियों में उल्लेख किया है, यह सही परिणाम नहीं दे सकता है यदि सूची में पहले आइटम खाली तार हैं।

Comments

meh .. अभी भी अगर लूप में है।

— एसफोसन

इसे छोटा बनाने के लिए आप एक फ़ॉरच लूप का उपयोग कर सकते हैं।

— पीटर लॉरी

यदि सूची का पहला आइटम खाली स्ट्रिंग है तो यह काम नहीं करेगा।

— डेव वेब

@ वेब वेब: हाँ, धन्यवाद। प्रश्न की हालांकि ऐसी आवश्यकता नहीं है।

— चेरोविम

@चेरोवियम: प्रश्न यह नहीं कहता कि कोई भी वस्तु खाली स्ट्रिंग नहीं होगी, इसलिए यह एक अंतर्निहित आवश्यकता है। यदि आप CSV फ़ाइल बना रहे हैं, तो खाली फ़ील्ड बहुत सामान्य हो सकते हैं।

— डेव वेब

Answer 12

मैं आमतौर पर ऐसा करता हूं:

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

हालांकि मुझे लगता है कि मैं जावा कार्यान्वयन के अनुसार अब से इस चेक को देखूंगा;)

Comments

यह नमूना 3 के समान तर्क है, मुझे यह पसंद है क्योंकि यह अनावश्यक कुछ भी नहीं करता है। हालांकि, मुझे नहीं पता कि यह सबसे साफ है। BTW: यह थोड़ा और अधिक कुशल है अगर आप सूची के खाली होने पर दो परीक्षणों से बचकर, अगर अंदर रखते हैं। यह मेरे लिए यह भी स्पष्ट रूप से स्पष्ट कर देता है।

— 13ren

स्वर्ग की खातिर,

— बजे

Answer 13

यदि आप ग्रूवी का उपयोग कर सकते हैं (जो JVM पर चलता है):

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

Comments

धन्यवाद, लेकिन मुझे कार्यान्वयन में दिलचस्पी है। इसे कैसे लागू किया जाता है?

— 13

Answer 14

( यहाँ से मेरे अपने जवाब की कॉपी पेस्ट करें ।) यहाँ वर्णित समाधानों में से कई शीर्ष, IMHO, विशेष रूप से बाहरी पुस्तकालयों पर भरोसा करने वाले लोगों से थोड़ा अधिक हैं। अल्पविराम से अलग की गई सूची को प्राप्त करने के लिए एक अच्छा साफ, स्पष्ट मुहावरा है जिसका मैंने हमेशा उपयोग किया है। यह सशर्त (?) ऑपरेटर पर निर्भर करता है:

संपादित करें : मूल समाधान सही है, लेकिन टिप्पणियों के अनुसार गैर-इष्टतम है। दूसरी बार कोशिश कर रहा है:

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

वहां आप कोड की 4 लाइनों में जाते हैं, जिसमें ऐरे और स्ट्रींगबर्ल की घोषणा शामिल है।

2 संपादित करें : यदि आप एक Iterator के साथ काम कर रहे हैं:

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

Comments

यह और stackoverflow.com/questions/668952/… ऊपर समान हैं। यह छोटा और स्पष्ट है, लेकिन यदि आपके पास केवल एक पुनरावृत्ति है, तो आपको पहले परिवर्तित करना होगा। अक्षम, लेकिन शायद इस दृष्टिकोण की स्पष्टता के लिए इसके लायक है?

— 13

ऊँ, स्ट्रिंग संघनन एक स्ट्रिंग स्ट्रिंग के उपयोग के भीतर एक अस्थायी स्ट्रिंगबर्ल बना रहा है। अक्षम। बेहतर (जावा के अधिक पसंद, लेकिन बेहतर चलने वाला कोड) "if (i> 0) {build.der.append (',');}" उसके बाद build.append (सरणी [i]) होगा;

— एडी

हां, यदि आप बाईटकोड में देखते हैं, तो आप सही हैं। मैं विश्वास नहीं कर सकता कि इतना सरल प्रश्न इतना जटिल हो सकता है। मुझे आश्चर्य है कि अगर कंपाइलर यहां अनुकूलन कर सकता है।

— जुलिएन चास्टांग

बशर्ते, उम्मीद है कि बेहतर समाधान हो।

— जुलिएन चास्तांग

उन्हें विभाजित करने के लिए बेहतर हो सकता है (ताकि लोग एक या दूसरे पर वोट कर सकें)।

— 13ren

Answer 15

मैं आमतौर पर संस्करण 3 के समान कुछ का उपयोग करता हूं। यह अच्छी तरह से काम करता है c / c ++ / bash / ...: P

Answer 16

मैंने इसे संकलित नहीं किया ... लेकिन काम करना चाहिए (या काम करने के करीब होना चाहिए)।

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

Comments

मुझे यह पसंद है, मैं सिर्फ एक अन्य स्वरूपण पसंद करूंगा। लेकिन एक छोटे से फिक्स का उल्लेख करने के लिए: यदि सूची खाली है, तो यह IndexOutOfBounds अपवाद को फेंक देगा। तो, या तो setLength से पहले एक जांच करें, या Math.max (0, ...) का उपयोग करें

— tb-

Answer 17

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

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

द्वारा प्रेरित: जावा में लूप के लिए बढ़ाया का अंतिम पुनरावृत्ति

Answer 18

StringBuffer sb = new StringBuffer();

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

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

Comments

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

— जोकिम एच। स्कीई

यह कुछ इस तरह प्रदान करेगा:Item1Item2, Item3, Item4,

स्वर्ग की खातिर,

— बजे

Answer 19

मुझे कुछ हद तक यह दृष्टिकोण पसंद है, जो मुझे कुछ समय पहले एक ब्लॉग पर मिला था। दुर्भाग्य से मुझे ब्लॉग का नाम / URL याद नहीं है।

आप एक उपयोगिता / सहायक वर्ग बना सकते हैं जो इस तरह दिखता है:

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

सहायक वर्ग का उपयोग करना इस प्रकार सरल है:

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

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

Comments

बस एक ध्यान दें: यह "सीमांकक" होना चाहिए, "परिधि" नहीं।

— माइकल मायर्स

Answer 20

क्योंकि आपका परिसीमन "," आप निम्नलिखित में से किसी का उपयोग कर सकते हैं:

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

यदि आपका सीमांकक कुछ भी है तो यह आपके लिए काम करने वाला नहीं है।

Answer 21

मुझे यह समाधान पसंद है:

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

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

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

मुझे लगता है कि यह StringBuilder का उपयोग भी कर सकता है।

Answer 22

मेरी राय में, यह पढ़ने और समझने में सबसे सरल है:

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

Answer 23

पायथन में इसकी आसान

"," शामिल हों (आपकी सूची)

C # में String class पर एक static तरीका है

String.Join (",", आपकी सूची)

क्षमा करें, जावा के बारे में निश्चित नहीं है, लेकिन मैंने सोचा था कि आप अन्य भाषाओं के बारे में पूछेंगे। मुझे यकीन है कि जावा में भी कुछ ऐसा ही होगा।

Comments

IIRC, आपको .Net संस्करण में एक अनुगामी मिलता है। :-(

बस परीक्षण किया है, में नेट या अजगर कोई अनुगामी सीमांकक

— टार्न

धन्यवाद! मुझे इसके लिए स्रोत मिला: svn.python.org/view/python/branches/release22-branch/Objects/… "कैटेनैट एवरीथिंग" की खोज करें। यह अंतिम आइटम के लिए विभाजक को छोड़ देता है।

— 13ren

@ 13ren अच्छी तरह से किया! क्या इसने सहायता की? मेरे पास एक ताला था और जल्दी से याद आया कि मैं इन दिनों C में प्रोग्राम क्यों नहीं चुनता: P

— tarn

@tarn, हाँ, यह एक दिलचस्प उदाहरण है क्योंकि यह केवल कॉम को जोड़ता है यदि यह अंतिम आइटम नहीं है: यदि (i <seqlen - 1) {<add विभाजक>}

— 13ren

Answer 24

आप बिना शर्त डिमाइटर स्ट्रिंग भी जोड़ सकते हैं, और लूप के बाद अंत में अतिरिक्त सीमांकक हटा सकते हैं। फिर "यदि सूची खाली है, तो इस स्ट्रिंग को वापस लौटाएँ" शुरुआत में आपको अंत में चेक से बचने की अनुमति देगा (जैसा कि आप खाली सूची से वर्ण नहीं निकाल सकते हैं)

तो सवाल वास्तव में है:

"एक लूप और अगर, आपको क्या लगता है कि ये एक साथ होने का सबसे स्पष्ट तरीका है?"

Answer 25

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

Comments

मुझे लगता है कि आपका कहने का मतलब हैlistToString.substring(0, listToString.length()-separator.length());

— 13ren

Answer 26

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

अल्पविराम के आधार पर एक सूची (जावा) का परिसीमन करें?

इस विचार का उपयोग करना: क्या एक लूप में अंतिम तत्व एक अलग उपचार के लायक है?

Comments

यह काम करने के लिए, आपको यह जानना होगा कि सूची में कम से कम 1 तत्व है, अन्यथा आपका पहला-लूप एक IndexOutOfBoundsException के साथ क्रैश हो जाएगा।

— जोकिम एच। स्कीई

@ जोशिम धन्यवाद, तुम बिल्कुल सही हो। क्या एक बदसूरत समाधान मैंने लिखा था! मैं बदल देंगे for (int i=0; i<1; i++)करने के लिए if (array.length>0)।

— 13ren

Answer 27

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

Comments

बस देखा कि यह जवाब के समान है TofuBeer दिया

— eblis

Answer 28

कोई भी उत्तर अब तक पुनरावृत्ति का उपयोग नहीं करता है ...

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

}

Answer 29

private String betweenComma(ArrayList<String> strings) {
    String united = "";
    for (String string : strings) {
        united = united + "," + string;
    }
    return united.replaceFirst(",", "");
}

Answer 30

तरीका

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

प्रयोग

[1,2,3] के सरणी को देखते हुए

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