जावा: StringBuilder का उपयोग उदाहरण के लिए, शुरुआत

Question

मैं केवल स्ट्रिंग के साथ ऐसा कर सकता है पर डालने के लिए:

String str=""; 
for(int i=0;i<100;i++){ 
    str=i+str; 
} 

वहाँ StringBuilder साथ इस लक्ष्य को हासिल करने के लिए एक तरीका है? धन्यवाद।

Answer 1

StringBuilder sb = new StringBuilder(); 
for(int i=0;i<100;i++){ 
    sb.insert(0, Integer.toString(i)); 
} 

चेतावनी:यह StringBuilder के प्रयोजन को हरा देता है, लेकिन यह आप क्या पूछा करता है।

---

बेहतर तकनीक (हालांकि अभी भी आदर्श नहीं):

1. रिवर्स प्रत्येक स्ट्रिंग आप सम्मिलित करना चाहते।
2. प्रत्येक स्ट्रिंग को पर संलग्न करें।
3. पूरेStringBuilder को पूरा करने पर रिवर्स करें।

यह एक हे हो जाएगा (n ²) हे में समाधान (n)।

Answer 2

आप उपयोग कर सकते strbuilder.insert(0,i);

Answer 3

शायद मैं कुछ याद कर रहा हूँ, लेकिन आप एक स्ट्रिंग है कि इस तरह दिखता है, "999897969594...", सही के साथ समाप्त करना चाहते हैं?

StringBuilder sb = new StringBuilder(); 
for(int i=99;i>=0;i--){ 
    sb.append(String.valueOf(i)); 
} 

Answer 4

यह धागा काफी पुराना है, लेकिन आप भी एक पुनरावर्ती समाधान StringBuilder को भरने के लिए गुजर के बारे में सोच सकता है। यह किसी भी रिवर्स प्रोसेसिंग इत्यादि को रोकने की इजाजत देता है। बस अपने पुनरावृत्ति के साथ अपने पुनरावृत्ति को डिजाइन करने की आवश्यकता है और सावधानीपूर्वक बाहर निकलने की स्थिति का फैसला करें।

public class Test { 

    public static void main(String[] args) { 
     StringBuilder sb = new StringBuilder(); 
     doRecursive(sb, 100, 0); 
     System.out.println(sb.toString()); 
    } 

    public static void doRecursive(StringBuilder sb, int limit, int index) { 
     if (index < limit) { 
      doRecursive(sb, limit, index + 1); 
      sb.append(Integer.toString(index)); 
     } 
    } 
} 

Answer 5

कोई वैकल्पिक समाधान आप सभी स्ट्रिंग्स स्टोर करने के लिए एक LIFO संरचना (एक ढेर की तरह) का उपयोग कर सकते हैं और जब आप समाप्त कर सिर्फ उन सब को बाहर ले जाना और उन्हें StringBuilder में डाल दिया है। यह स्वाभाविक रूप से इसमें रखे गए सामान (तार) के क्रम को उलट देता है।

Stack<String> textStack = new Stack<String>(); 
// push the strings to the stack 
while(!isReadingTextDone()) { 
    String text = readText(); 
    textStack.push(text); 
} 
// pop the strings and add to the text builder 
String builder = new StringBuilder(); 
while (!textStack.empty()) { 
     builder.append(textStack.pop()); 
} 
// get the final string 
String finalText = builder.toString(); 

Answer 6

जब मैंने इस पोस्ट पर ठोकर खाई तो मुझे भी इसी तरह की आवश्यकता थी। मैं एक स्ट्रिंग बनाने का एक तेज़ तरीका चाहता था जो दोनों तरफ से बढ़ सकता है यानी। सामने के साथ-साथ मनमाने ढंग से नए अक्षरों को जोड़ें। मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन इसने मुझे स्ट्रिंग बनाने के कुछ तरीकों का प्रयास करने के लिए प्रेरित किया और मैंने सोचा कि मैं अपने निष्कर्ष साझा करूंगा। मैं भी इस में कुछ जावा 8 निर्माणों, जो मामलों 4 में गति के लिए अनुकूलित किया जा सकता था और 5.

https://gist.github.com/SidWagz/e41e836dec65ff24f78afdf8669e6420

सार ऊपर विस्तृत कोड है कि किसी को चला सकते हैं का उपयोग कर रहा हूँ। मैंने इसमें तारों को बढ़ाने के कुछ तरीके लिया; 1) स्ट्रिंगबिल्डर में शामिल हों, 2) स्ट्रिंगबिल्डर के सामने डालें जैसा कि @ मेहरदाद द्वारा दिखाया गया है, 3) आंशिक रूप से स्ट्रिंगबिल्डर के सामने और साथ ही आंशिक रूप से डालें, 4) अंत से जोड़ने के लिए एक सूची का उपयोग करके, 5) एक डेक का उपयोग करना सामने से संलग्न करें।

// Case 2  
StringBuilder build3 = new StringBuilder(); 
IntStream.range(0, MAX_STR) 
        .sequential() 
        .forEach(i -> { 
         if (i%2 == 0) build3.append(Integer.toString(i)); else build3.insert(0, Integer.toString(i)); 
        }); 
String build3Out = build3.toString(); 


//Case 5 
Deque<String> deque = new ArrayDeque<>(); 
IntStream.range(0, MAX_STR) 
       .sequential() 
       .forEach(i -> { 
        if (i%2 == 0) deque.addLast(Integer.toString(i)); else deque.addFirst(Integer.toString(i)); 
       }); 

String dequeOut = deque.stream().collect(Collectors.joining("")); 

मैं केवल सामने के मामलों में ध्यान केंद्रित करूंगा यानी। केस 2 और मामला 5. स्ट्रिंगबिल्डर का कार्यान्वयन आंतरिक रूप से तय करता है कि आंतरिक बफर कैसे बढ़ता है, जो आगे बढ़ने के मामले में सभी बफर को बाएं से दाएं स्थानांतरित करने के अलावा गति को सीमित करता है। स्ट्रिंगबिल्डर के सामने सीधे डालने पर लिया गया समय वास्तव में उच्च मानों के साथ बढ़ता है, जैसा कि @ मेहरदाद द्वारा दिखाया गया है, यदि आवश्यकता केवल 90k वर्णों से कम लंबाई की स्ट्रिंग है (जो अभी भी बहुत कुछ है), तो फ्रंट डालने एक ही समय में एक स्ट्रिंग का निर्माण करें क्योंकि अंत में जोड़कर उसी लंबाई की एक स्ट्रिंग बनाने में लगेगा। मैं जो कह रहा हूं वह यह है कि समय-समय पर जुर्माना वास्तव में किक करता है और बड़ा होता है, लेकिन केवल तभी जब आपको वास्तव में भारी तार बनाना पड़ता है। एक उदाहरण के रूप में दिखाया गया है कि एक डेक का उपयोग कर अंत में तारों में शामिल हो सकता है। लेकिन स्ट्रिंगबिल्डर पढ़ने और कोड के लिए थोड़ा अधिक सहज है, और जुर्माना छोटे तारों के लिए कोई फर्क नहीं पड़ता।

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