जावा में सीमांकित वस्तुओं की एक स्ट्रिंग बनाने का सबसे अच्छा तरीका क्या है?

Question

एक जावा ऐप में काम करते समय, मुझे हाल ही में मूल्यों के अल्पविराम-सीमांकित सूची को एक अन्य वेब सेवा में पारित करने की आवश्यकता के बिना यह जानने की आवश्यकता थी कि कितने तत्व अग्रिम में होंगे। सबसे अच्छा मैं अपने सिर के ऊपर से उतर सकता था कुछ इस तरह था:

public String appendWithDelimiter( String original, String addition, String delimiter ) {
    if ( original.equals( "" ) ) {
        return addition;
    } else {
        return original + delimiter + addition;
    }
}

String parameterString = "";
if ( condition ) parameterString = appendWithDelimiter( parameterString, "elementName", "," );
if ( anotherCondition ) parameterString = appendWithDelimiter( parameterString, "anotherElementName", "," );

मुझे लगता है कि यह विशेष रूप से कुशल नहीं है, क्योंकि वहाँ तार सभी जगह बनाए जा रहे हैं, लेकिन मैं अनुकूलन से अधिक स्पष्टता के लिए जा रहा था।

रूबी में, मैं इसके बजाय कुछ ऐसा कर सकता हूं, जो बहुत अधिक सुरुचिपूर्ण लगता है:

parameterArray = [];
parameterArray << "elementName" if condition;
parameterArray << "anotherElementName" if anotherCondition;
parameterString = parameterArray.join(",");

लेकिन चूंकि जावा में एक ज्वाइन कमांड की कमी है, इसलिए मैं इसके समकक्ष कुछ भी नहीं समझ सका।

तो, जावा में ऐसा करने का सबसे अच्छा तरीका क्या है?

Comments

स्ट्रिंगबर्बेल जाने का रास्ता है - java.lang.StringBuilder।

— यूसुबोव

जावा 8 के लिए इस उत्तर पर एक नज़र डालें: stackoverflow.com/a/22577623/1115554

— micha

Answer 1

पूर्व जावा 8:

अपाचे के कॉमन्स लैंग आपके मित्र हैं - यह रूबी में आपके द्वारा संदर्भित एक बहुत ही सम्मिलित विधि प्रदान करता है:

StringUtils.join(java.lang.Iterable,char)

---

जावा 8:

जावा 8 के माध्यम से बॉक्स से बाहर में शामिल होने प्रदान करता है StringJoinerऔर String.join()। नीचे दिए गए स्निपेट्स बताते हैं कि आप उनका उपयोग कैसे कर सकते हैं:

StringJoiner

StringJoiner joiner = new StringJoiner(",");
joiner.add("01").add("02").add("03");
String joinedString = joiner.toString(); // "01,02,03"

---

String.join(CharSequence delimiter, CharSequence... elements))

String joinedString = String.join(" - ", "04", "05", "06"); // "04 - 05 - 06"

---

String.join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

List<String> strings = new LinkedList<>();
strings.add("Java");strings.add("is");
strings.add("cool");
String message = String.join(" ", strings);
//message returned is: "Java is cool"

Comments

मैं सोच रहा हूँ - क्या यह ध्यान में रखता है यदि संग्रह में किसी वस्तु के स्ट्रिंग प्रतिनिधित्व में सीमांकक चरित्र ही होता है?

— ग्रीनमीमेनी

वास्तव में मैं क्या देख रहा था: StringUtils.join (java.util.Collection, String) पैकेज से org.apache.commons.lang3.StringUtils, jar फ़ाइल commons-lang3-3.0.1.jar

— उमर

Android पर आप TextUtils.join () का भी उपयोग कर सकते हैं।

— जेम्स वॉल्ड

यह सबसे अच्छा तरीका नहीं है। भले ही संग्रह में ऑब्जेक्ट शून्य / खाली है, भले ही यह चार को जोड़ देगा। इसका अच्छा और साफ लेकिन कभी-कभी यह एक डबल सीमांकक चार प्रिंट करेगा।

— Stephan Schielke

Answer 2

आप एक छोटी जॉइन-शैली उपयोगिता विधि लिख सकते हैं जो java.util.Lists पर काम करती है

public static String join(List<String> list, String delim) {

    StringBuilder sb = new StringBuilder();

    String loopDelim = "";

    for(String s : list) {

        sb.append(loopDelim);
        sb.append(s);            

        loopDelim = delim;
    }

    return sb.toString();
}

फिर इसे इस तरह उपयोग करें:

    List<String> list = new ArrayList<String>();

    if( condition )        list.add("elementName");
    if( anotherCondition ) list.add("anotherElementName");

    join(list, ",");

Comments

अगर आपको कम से कम 2 कार्यान्वयन (अपाचे और अमरूद) पहले से मौजूद हैं तो आपको अपनी विधि क्यों लिखनी चाहिए?

— टिमोफे

यह, उदाहरण के लिए, यदि कोई बाहरी निर्भरता कम करना चाहता है तो उपयोगी हो सकता है।

— थॉमस ज़ुम्ब्रन

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

— वलसेक

क्या आप List<String>अपने इंटेस्टाइज़र में बदलाव नहीं कर सकते हैं Iterator<?>और इसका समान प्रभाव है?

— k_g

@ समय एग अपाचे खाली तारों को नहीं छोड़ता है।

— banterCZ

Answer 3

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

android.text.TextUtils.join(CharSequence delimiter, Iterable tokens)

http://developer.android.com/reference/android/text/TextUtils.html

Answer 4

गूगल के अमरूद पुस्तकालय है com.google.common.base.Joiner वर्ग जो इस तरह के कार्यों को हल करने के लिए मदद करता है।

नमूने:

"My pets are: " + Joiner.on(", ").join(Arrays.asList("rabbit", "parrot", "dog")); 
// returns "My pets are: rabbit, parrot, dog"

Joiner.on(" AND ").join(Arrays.asList("field1=1" , "field2=2", "field3=3"));
// returns "field1=1 AND field2=2 AND field3=3"

Joiner.on(",").skipNulls().join(Arrays.asList("London", "Moscow", null, "New York", null, "Paris"));
// returns "London,Moscow,New York,Paris"

Joiner.on(", ").useForNull("Team held a draw").join(Arrays.asList("FC Barcelona", "FC Bayern", null, null, "Chelsea FC", "AC Milan"));
// returns "FC Barcelona, FC Bayern, Team held a draw, Team held a draw, Chelsea FC, AC Milan"

---

यहाँ अमरूद की स्ट्रिंग उपयोगिताओं के बारे में एक लेख है ।

Answer 5

जावा 8 में आप उपयोग कर सकते हैं String.join():

List<String> list = Arrays.asList("foo", "bar", "baz");
String joined = String.join(" and ", list); // "foo and bar and baz"

स्ट्रीम एपीआई उदाहरण के लिए इस उत्तर पर भी एक नज़र डालें ।

Answer 6

आप इसे सामान्य कर सकते हैं, लेकिन जैसा कि आप अच्छी तरह से कहते हैं, जावा में कोई शामिल नहीं है।

यह बेहतर काम कर सकता है।

public static String join(Iterable<? extends CharSequence> s, String delimiter) {
    Iterator<? extends CharSequence> iter = s.iterator();
    if (!iter.hasNext()) return "";
    StringBuilder buffer = new StringBuilder(iter.next());
    while (iter.hasNext()) buffer.append(delimiter).append(iter.next());
    return buffer.toString();
}

Comments

मैं इस जवाब से सहमत हूं, लेकिन क्या कोई हस्ताक्षर को संपादित कर सकता है ताकि यह AbstractCollection <string> के बजाय संग्रह <string> को स्वीकार करे? बाकी कोड समान होना चाहिए लेकिन मुझे लगता है कि AbstractCollection एक कार्यान्वयन विवरण है जो यहां कोई मायने नहीं रखता है।

— आउटलॉ प्रोग्रामर

बेहतर अभी भी, का उपयोग करें Iterable<String>और बस इस तथ्य का उपयोग करें कि आप उस पर पुनरावृत्ति कर सकते हैं। आपके उदाहरण में आपको संग्रह में वस्तुओं की संख्या की आवश्यकता नहीं है, इसलिए यह और भी सामान्य है।

— जेसन कोहेन

या इससे भी बेहतर, Iterable का उपयोग करें <? विस्तार> और फिर आप StringBuilders और तार और धाराओं और अन्य स्ट्रिंग की तरह चीजों के संग्रह को स्वीकार कर सकते हैं। :)

— जेसन कोहेन

आप StringBuilderइसके बजाय उपयोग करना चाहते हैं । वे समान हैं, सिवाय StringBufferअनावश्यक धागा सुरक्षा प्रदान करते हैं। किसी कृपया इसे संपादित कर सकते हैं!

— केसबश

इस कोड में कई त्रुटियां हैं। 1. CharSequence की एक पूंजी होती है। 2. s.iterator () रिटर्न इटरेटर <? विस्तार> विस्तार>। 3. Iterable में कोई isEmpty()विधि नहीं है , next()इसके बजाय विधि का उपयोग करें

— Casebash

Answer 7

जावा 8 में आप ऐसा कर सकते हैं:

list.stream().map(Object::toString)
        .collect(Collectors.joining(delimiter));

यदि सूची में नल हैं, जिनका आप उपयोग कर सकते हैं:

list.stream().map(String::valueOf)
        .collect(Collectors.joining(delimiter))

यह उपसर्ग और प्रत्यय का भी समर्थन करता है:

list.stream().map(String::valueOf)
        .collect(Collectors.joining(delimiter, prefix, suffix));

Answer 8

के आधार पर एक दृष्टिकोण का उपयोग करें java.lang.StringBuilder! ("वर्णों का एक परस्पर अनुक्रम।")

जैसा कि आपने उल्लेख किया है, उन सभी स्ट्रिंग कॉन्सेप्टन से स्ट्रिंग्स का निर्माण हो रहा है। StringBuilderऐसा नहीं होगा।

StringBuilderइसके बजाय क्यों StringBuffer? से StringBuilderजावाडोक:

जहां संभव हो, यह अनुशंसा की जाती है कि इस वर्ग का उपयोग स्ट्रिंगबफ़र की प्राथमिकता में किया जाए क्योंकि यह अधिकांश कार्यान्वयनों के तहत तेज़ होगा।

Comments

हां। इसके अलावा, StringBuffer धागा सुरक्षित है, जबकि StringBuilder नहीं है।

— जॉन ऑनस्टॉट

Answer 9

मैं Google संग्रह का उपयोग करूंगा। एक अच्छी जॉइन सुविधा है।
http://google-collections.googlecode.com/svn/trunk/javadoc/index.html?com/google/common/base/Join.html

लेकिन अगर मैं इसे अपने दम पर लिखना चाहता था,

package util;

import java.util.ArrayList;
import java.util.Iterable;
import java.util.Collections;
import java.util.Iterator;

public class Utils {
    // accept a collection of objects, since all objects have toString()
    public static String join(String delimiter, Iterable<? extends Object> objs) {
        if (objs.isEmpty()) {
            return "";
        }
        Iterator<? extends Object> iter = objs.iterator();
        StringBuilder buffer = new StringBuilder();
        buffer.append(iter.next());
        while (iter.hasNext()) {
            buffer.append(delimiter).append(iter.next());
        }
        return buffer.toString();
    }

    // for convenience
    public static String join(String delimiter, Object... objs) {
        ArrayList<Object> list = new ArrayList<Object>();
        Collections.addAll(list, objs);
        return join(delimiter, list);
    }
}

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

Answer 10

Apache commons StringUtils वर्ग में एक सम्मिलित विधि है।

Answer 11

जावा 8

stringCollection.stream().collect(Collectors.joining(", "));

Answer 12

आप इसके लिए जावा के StringBuilderप्रकार का उपयोग कर सकते हैं । वहाँ भी है StringBuffer, लेकिन इसमें अतिरिक्त थ्रेड सुरक्षा तर्क है जो अक्सर अनावश्यक होता है।

Answer 13

और एक न्यूनतम एक (यदि आप अपाचे कॉमन्स या गौवा को परियोजना निर्भरता में शामिल नहीं करना चाहते हैं तो केवल तार जुड़ने के लिए)

/**
 *
 * @param delim : String that should be kept in between the parts
 * @param parts : parts that needs to be joined
 * @return  a String that's formed by joining the parts
 */
private static final String join(String delim, String... parts) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < parts.length - 1; i++) {
        builder.append(parts[i]).append(delim);
    }
    if(parts.length > 0){
        builder.append(parts[parts.length - 1]);
    }
    return builder.toString();
}

Comments

File.separator के बजाय delim का उपयोग करें।

— प्रदीप कुमार

Answer 14

StringBuilder और वर्ग का उपयोग करें Separator

StringBuilder buf = new StringBuilder();
Separator sep = new Separator(", ");
for (String each : list) {
    buf.append(sep).append(each);
}

विभाजक एक सीमांकक लपेटता है। सीमांकक विभाजक द्वारा लौटाया जाता हैtoString विधि , जब तक कि पहली कॉल पर जो खाली स्ट्रिंग नहीं लौटाता है!

कक्षा के लिए स्रोत कोड Separator

public class Separator {

    private boolean skipFirst;
    private final String value;

    public Separator() {
        this(", ");
    }

    public Separator(String value) {
        this.value = value;
        this.skipFirst = true;
    }

    public void reset() {
        skipFirst = true;
    }

    public String toString() {
        String sep = skipFirst ? "" : value;
        skipFirst = false;
        return sep;
    }

}

Comments

इसमें संशोधन करने के बारे में क्या Separatorकहा गया है कि यह StringBuilderसहमति देने के बजाय इसका उपयोग करता है Strings?

— मोहम्मद नुउर

@ मोहम्मद Separatorसिर्फ सीमांकक लौटाता है, यह स्ट्रिंग को अपने आप नहीं बदलता है।

— एकुहन

ये कौन सी क्लास है Separator??? क्यों नहीं एक साधारण स्ट्रिंग का उपयोग करें ..?!

— अधिकतम डेक्स

Answer 15

अपनी खुद की ज्वाइन () विधि क्यों नहीं लिखी? यह स्ट्रिंग्स के पैरामीटर संग्रह और एक सीमांकक स्ट्रिंग के रूप में ले जाएगा। संग्रह के बारे में विधि पुनरावृति के भीतर और एक स्ट्रिंगर में अपना परिणाम बनाएँ।

Answer 16

यदि आप स्प्रिंग एमवीसी का उपयोग कर रहे हैं तो आप निम्नलिखित चरणों का प्रयास कर सकते हैं।

import org.springframework.util.StringUtils;

List<String> groupIds = new List<String>;   
groupIds.add("a");    
groupIds.add("b");    
groupIds.add("c");

String csv = StringUtils.arrayToCommaDelimitedString(groupIds.toArray());

इसका परिणाम होगा a,b,c

Answer 17

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

makeString()के Stringसमान एक प्रतिनिधित्व लौटाता है toString()।

इसके तीन रूप हैं

• makeString(start, separator, end)
• makeString(separator) डिफॉल्ट शुरू होते हैं और खाली तारों पर समाप्त होते हैं
• makeString()", "(अल्पविराम और स्थान) के लिए विभाजक को चूकता है

कोड उदाहरण:

MutableList<Integer> list = FastList.newListWith(1, 2, 3);
assertEquals("[1/2/3]", list.makeString("[", "/", "]"));
assertEquals("1/2/3", list.makeString("/"));
assertEquals("1, 2, 3", list.makeString());
assertEquals(list.toString(), list.makeString("[", ", ", "]"));

appendString()के समान है makeString(), लेकिन यह एक Appendable(जैसे StringBuilder) को जोड़ता है और है void। इसके तीन रूप हैं, पहला अतिरिक्त तर्क, परिशिष्ट के साथ।

MutableList<Integer> list = FastList.newListWith(1, 2, 3);
Appendable appendable = new StringBuilder();
list.appendString(appendable, "[", "/", "]");
assertEquals("[1/2/3]", appendable.toString());

यदि आप अपने संग्रह को एक ग्रहण संग्रह प्रकार में परिवर्तित नहीं कर सकते हैं, तो बस इसे संबंधित एडाप्टर के साथ अनुकूलित करें।

List<Object> list = ...;
ListAdapter.adapt(list).makeString(",");

नोट: मैं ग्रहण संग्रहों के लिए एक कमिटेटर हूं।

Answer 18

जावा 8 मूल प्रकार

List<Integer> example;
example.add(1);
example.add(2);
example.add(3);
...
example.stream().collect(Collectors.joining(","));

जावा 8 कस्टम वस्तु:

List<Person> person;
...
person.stream().map(Person::getAge).collect(Collectors.joining(","));

Answer 19

आपको अपना परिणाम बनाने के लिए संभवतः विधि के StringBuilderसाथ उपयोग करना चाहिए append, लेकिन अन्यथा यह एक समाधान के रूप में अच्छा है जैसा कि जावा को पेश करना है।

Answer 20

आप जावा में वही काम क्यों नहीं कर रहे हैं जो आप रूबी में कर रहे हैं, जिससे कि आप सभी टुकड़ों को सरणी में जोड़ देने के बाद ही सीमांकित पृथक स्ट्रिंग बना रहे हैं?

ArrayList<String> parms = new ArrayList<String>();
if (someCondition) parms.add("someString");
if (anotherCondition) parms.add("someOtherString");
// ...
String sep = ""; StringBuffer b = new StringBuffer();
for (String p: parms) {
    b.append(sep);
    b.append(p);
    sep = "yourDelimiter";
}

आप एक अलग सहायक विधि में लूप के लिए इसे स्थानांतरित करना चाहते हैं, और स्ट्रिंगबफ़र के बजाय स्ट्रिंग स्ट्रिंग का उपयोग कर सकते हैं ...

संपादित करें : अपेंडिक्स का क्रम तय किया।

Comments

हां, आप StringBuffer के बजाय StringBuffer का उपयोग क्यों करेंगे (जैसा कि आप Java 1.5+ का उपयोग कर रहे हैं)? आपके पास भी गलत तरीके से अपना एप है।

— टॉम हॉल्टिन -

Answer 21

जावा 5 वैरिएबल आर्ग के साथ, इसलिए आपको अपने सभी स्ट्रिंग्स को एक संग्रह या सरणी में स्पष्ट रूप से रखने की आवश्यकता नहीं है:

import junit.framework.Assert;
import org.junit.Test;

public class StringUtil
{
    public static String join(String delim, String... strings)
    {
        StringBuilder builder = new StringBuilder();

        if (strings != null)
        {
            for (String str : strings)
            {
                if (builder.length() > 0)
                {
                    builder.append(delim).append(" ");
                }
                builder.append(str);
            }
        }           
        return builder.toString();
    }
    @Test
    public void joinTest()
    {
        Assert.assertEquals("", StringUtil.join(",", null));
        Assert.assertEquals("", StringUtil.join(",", ""));
        Assert.assertEquals("", StringUtil.join(",", new String[0]));
        Assert.assertEquals("test", StringUtil.join(",", "test"));
        Assert.assertEquals("foo, bar", StringUtil.join(",", "foo", "bar"));
        Assert.assertEquals("foo, bar, x", StringUtil.join(",", "foo", "bar", "x"));
    }
}

Answer 22

जो लोग स्प्रिंग के संदर्भ में हैं उनके लिए स्ट्रिंग स्ट्रिंग क्लास उपयोगी है:

कई उपयोगी शॉर्टकट हैं जैसे:

• collectionToCommaDelimitedString (संग्रह टक्कर)
• collectionToDelimitedString (संग्रह टकराने, स्ट्रिंग सीम)
• arrayToDelimitedString (ऑब्जेक्ट [] गिरफ्तार, स्ट्रिंग डेलिम)

और बहुत सारे।

यदि आप पहले से ही जावा 8 का उपयोग नहीं कर रहे हैं और आप पहले से ही स्प्रिंग संदर्भ में हैं तो यह मददगार हो सकता है।

मैं इसे संग्रह के समर्थन के लिए अपाचे कॉमन्स (हालांकि बहुत अच्छा) के खिलाफ पसंद करता हूं जो इस तरह से आसान है:

// Encoding Set<String> to String delimited 
String asString = org.springframework.util.StringUtils.collectionToDelimitedString(codes, ";");

// Decoding String delimited to Set
Set<String> collection = org.springframework.util.StringUtils.commaDelimitedListToSet(asString);

Answer 23

आप कुछ इस तरह की कोशिश कर सकते हैं:

StringBuilder sb = new StringBuilder();
if (condition) { sb.append("elementName").append(","); }
if (anotherCondition) { sb.append("anotherElementName").append(","); }
String parameterString = sb.toString();

Comments

ऐसा लगता है कि यह स्ट्रिंग के अंत में एक आवारा अल्पविराम छोड़ देगा, जिससे मैं बचने की उम्मीद करूंगा। (बेशक, जब से आप जानते हैं कि यह वहां है, तब आप इसे ट्रिम कर सकते हैं, लेकिन यह थोड़ा सा भी बदबूदार है।)

— सीन मैकमैन्स

Answer 24

तो मूल रूप से कुछ इस तरह:

public static String appendWithDelimiter(String original, String addition, String delimiter) {

if (original.equals("")) {
    return addition;
} else {
    StringBuilder sb = new StringBuilder(original.length() + addition.length() + delimiter.length());
        sb.append(original);
        sb.append(delimiter);
        sb.append(addition);
        return sb.toString();
    }
}

Comments

यहाँ समस्या यह है कि वह appendWithDelimiter () आबंटन कहते हैं। समाधान के लिए एक और केवल एक स्ट्रिंगर होना चाहिए और उस एकल उदाहरण के साथ काम करना चाहिए।

— स्टु थॉम्पसन

Answer 25

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

नीचे यदि आप किसी पैरामीटर को परिसीमन करने से पहले मापदंडों की सूची बना सकते हैं, तो नीचे एक अधिक सामान्य दृष्टिकोण है।

// Answers real question
public String appendWithDelimiters(String delimiter, String original, String addition) {
    StringBuilder sb = new StringBuilder(original);
    if(sb.length()!=0) {
        sb.append(delimiter).append(addition);
    } else {
        sb.append(addition);
    }
    return sb.toString();
}


// A more generic case.
// ... means a list of indeterminate length of Strings.
public String appendWithDelimitersGeneric(String delimiter, String... strings) {
    StringBuilder sb = new StringBuilder();
    for (String string : strings) {
        if(sb.length()!=0) {
            sb.append(delimiter).append(string);
        } else {
            sb.append(string);
        }
    }

    return sb.toString();
}

public void testAppendWithDelimiters() {
    String string = appendWithDelimitersGeneric(",", "string1", "string2", "string3");
}

Answer 26

आपका दृष्टिकोण बहुत बुरा नहीं है, लेकिन आपको + साइन का उपयोग करने के बजाय एक स्ट्रिंगर का उपयोग करना चाहिए। + के पास बड़ा नुकसान यह है कि प्रत्येक एकल ऑपरेशन के लिए एक नया स्ट्रिंग उदाहरण बनाया जा रहा है। आपका तार जितना लंबा होगा, ओवरहेड उतना ही बड़ा होगा। तो एक StringBuffer का उपयोग सबसे तेज़ तरीका होना चाहिए:

public StringBuffer appendWithDelimiter( StringBuffer original, String addition, String delimiter ) {
        if ( original == null ) {
                StringBuffer buffer = new StringBuffer();
                buffer.append(addition);
                return buffer;
        } else {
                buffer.append(delimiter);
                buffer.append(addition);
                return original;
        }
}

आपके द्वारा अपना स्ट्रिंग बनाने के बाद बस वापस दिए गए StringBuffer पर toString () कॉल करें।

Comments

StringBuffer का उपयोग करना यहाँ बिना किसी अच्छे कारण के इसे धीमा कर देगा। + ऑपरेटर का उपयोग करके तेजी से StringBuilder का आंतरिक रूप से उपयोग किया जाएगा ताकि वह कुछ भी नहीं जीत रहा है, लेकिन इसके बजाय उसे StringBuffer का उपयोग करके थ्रेड सुरक्षा की आवश्यकता नहीं है।

— फ्रेड्रिक

इसके अलावा ... बयान "The + का बड़ा नुकसान है कि प्रत्येक एकल ऑपरेशन के लिए एक नया स्ट्रिंग उदाहरण बनाया जा रहा है" गलत है। संकलक StringBuilder.append () उनमें से कॉल उत्पन्न करेगा।

— फ्रेड्रिक

Answer 27

स्ट्रिंग संघनन का उपयोग करने के बजाय, यदि आपका कोड थ्रेडेड नहीं है, तो StringBuilder का उपयोग करना चाहिए और यदि यह है तो StringBuffer।

Answer 28

आप इसे थोड़ा जटिल बना रहे हैं, जितना कि यह होना चाहिए। चलो अपने उदाहरण के अंत से शुरू करते हैं:

String parameterString = "";
if ( condition ) parameterString = appendWithDelimiter( parameterString, "elementName", "," );
if ( anotherCondition ) parameterString = appendWithDelimiter( parameterString, "anotherElementName", "," );

एक स्ट्रिंग के बजाय स्ट्रिंग स्ट्रिंग का उपयोग करने के छोटे परिवर्तन के साथ, यह बन जाता है:

StringBuilder parameterString = new StringBuilder();
if (condition) parameterString.append("elementName").append(",");
if (anotherCondition) parameterString.append("anotherElementName").append(",");
...

जब आप कर लें (मुझे लगता है कि आपको कुछ अन्य शर्तों को भी जांचना होगा), बस यह सुनिश्चित करें कि आप इसके साथ एक कमांड के साथ टेलिंग कॉमा को हटा दें:

if (parameterString.length() > 0) 
    parameterString.deleteCharAt(parameterString.length() - 1);

और अंत में, वह स्ट्रिंग प्राप्त करें जिसे आप चाहते हैं

parameterString.toString();

आप दूसरी कॉल में "" की जगह ले सकते हैं, जेनेरिक सीमांकक स्ट्रिंग के साथ जोड़ने के लिए जिसे कुछ भी सेट किया जा सकता है। यदि आपके पास उन चीजों की एक सूची है जिन्हें आप जानते हैं कि आपको (गैर-सशर्त रूप से) संलग्न करने की आवश्यकता है, तो आप इस कोड को एक विधि के अंदर रख सकते हैं जो तार की सूची लेता है।

Answer 29

//Note: if you have access to Java5+, 
//use StringBuilder in preference to StringBuffer.  
//All that has to be replaced is the class name.  
//StringBuffer will work in Java 1.4, though.

appendWithDelimiter( StringBuffer buffer, String addition, 
    String delimiter ) {
    if ( buffer.length() == 0) {
        buffer.append(addition);
    } else {
        buffer.append(delimiter);
        buffer.append(addition);
    }
}


StringBuffer parameterBuffer = new StringBuffer();
if ( condition ) { 
    appendWithDelimiter(parameterBuffer, "elementName", "," );
}
if ( anotherCondition ) {
    appendWithDelimiter(parameterBuffer, "anotherElementName", "," );
}

//Finally, to return a string representation, call toString() when returning.
return parameterBuffer.toString(); 

Answer 30

तो कुछ चीजें आप महसूस करने के लिए कर सकते हैं जो ऐसा लगता है जैसे आप देख रहे हैं:

1) सूची वर्ग बढ़ाएँ - और इसमें शामिल होने की विधि जोड़ें। ज्वाइन विधि सरलता से परिसीमन और जोड़ने का काम करेगी (जो कि ज्वाइन विधि के लिए एक सर्वोपरि हो सकती है)

2) ऐसा लग रहा है कि जावा 7 जावा में विस्तार के तरीकों को जोड़ने जा रहा है - जो आपको सिर्फ एक विशिष्ट विधि को कक्षा में संलग्न करने की अनुमति देता है: इसलिए आप लिख सकते हैं कि इस विधि में शामिल हों और इसे विस्तार विधि के रूप में सूची में शामिल करें या यहां तक ​​कि संग्रह।

समाधान 1 शायद एकमात्र यथार्थवादी है, अब, हालांकि जावा 7 अभी तक बाहर नहीं है :) लेकिन यह ठीक काम करना चाहिए।

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