Theory
वह Catalog जिसने 6000 Copies बनाईं
Month-end: BookBridge अपनी पूरी catalog report assemble करता है।
String report = "";
for each book: report = report + line;
Immutability याद रखिए: हर + एक brand-new String बनाता है और old को abandon करता है। 6000 lines का मतलब है roughly 6000 discarded objects, हर एक अपने से पहले सब कुछ copy करते हुए। Garbage collector clean up करता है, पर आपने इसे एक flooded room mop कराई।
एक text की heavy, repeated editing के लिए, Java एक अलग tool offer करता है: एक mutable एक।
Theory
Printed Page बनाम Whiteboard
एक String एक printed page है: एक word बदलने के लिए आप एक पूरा नया page print करते हैं।
एक StringBuffer एक whiteboard है: walk up कीजिए और add कीजिए, squeeze in कीजिए, erase या rewrite कीजिए, और यह SAME whiteboard बना रहता है। Board इस पर लिखे से थोड़ा बड़ा भी है, spare room ताकि small additions को नए board की ज़रूरत न पड़े। वह spare room इसकी capacity है।
Theory
Constructors और Capacity Rule
3 constructors, याद रखने के लिए एक rule:
new StringBuffer(): empty, capacity 16new StringBuffer(50): empty, capacity 50new StringBuffer("Let Us C"): capacity = 16 + length, यहाँ 16 + 8 = 24
2 words अलग रखिए: length() actually stored characters count करता है; capacity() allocated room count करता है। "Let Us C" hold करने वाले एक buffer की length 8 है, capacity 24। Capacity exceed कीजिए और buffer खुद automatically grow करता है; आप इसे कभी overflow नहीं करते।
Practical
In Place Editing
public class CatalogLine {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("Let Us C");
System.out.println(sb.length()); // 8
System.out.println(sb.capacity()); // 24 (16 + 8)
sb.append(" 2nd Ed"); // same object, now longer
sb.insert(0, "* "); // squeeze in at the front
System.out.println(sb); // * Let Us C 2nd Ed
sb.delete(0, 2); // remove indexes 0,1 (end exclusive)
sb.setCharAt(0, 'G'); // the "update" operation
System.out.println(sb); // Get Us C 2nd Ed
}
}
At a glance
String बनाम StringBuffer (Exam Table)
| Aspect | String | StringBuffer |
|---|---|---|
| Mutability | Immutable: हर edit एक नया object बनाता है | Mutable: edits in place होते हैं |
| सबसे अच्छा किसके लिए | Fixed text, comparisons, keys | Repeated building और editing |
| Editing Cost | हर change पर नया object | एक object, ज़रूरत के हिसाब से grow करता है |
| Thread Safety | Unchangeable होने से safe | Safe: इसके methods synchronized हैं |
Quiz
new StringBuffer("Book").capacity() क्या return करता है?
- 16
- 4
- 20
- 0
Show the answer
20
String constructor 16 spare slots PLUS initial content की length allocate करता है: 16 + 4 = 20। Option A new StringBuffer() से एक EMPTY buffer की capacity है। Option B capacity को length() से confuse करता है, जो indeed 4 होगी। Option D का मतलब होगा बिल्कुल कोई room नहीं, जो कोई constructor produce नहीं करता। 16-plus-length formula लगभग हर साल किसी न किसी form में पूछा जाता है।
Think first
Reverse Trace कीजिए
StringBuffer sb = new StringBuffer("Us C"); sb.reverse(); System.out.println(sb); Tap करने से पहले अपने दिमाग़ में इसे character by character flip कीजिए, spaces सहित।
Show the answer
C sU। 4 characters U, s, space, C, C, space, s, U बन जाते हैं। दो चीज़ें notice करने लायक: space बाकी किसी भी character जैसा है और यह भी move करता है; और reverse() ने sb ITSELF change किया, कोई assignment नहीं चाहिए, क्योंकि StringBuffer in place edit करता है। एक String पर same call exist ही नहीं करता: एक String reverse करने के लिए, standard trick है new StringBuffer(s).reverse().toString(), एक favourite 2-mark question।
Watch out
दो Traps, एक Honest Note
Trap 1: String s = "abc"; s.concat("d"); कुछ नहीं बदलता, पर sb.append("d") sb को बदलता है। Students assign-it-back habit को StringBuffer में carry करते हैं या, बदतर, no-assign habit वापस String में।
Trap 2: delete(0, 2) सिर्फ़ indexes 0 और 1 हटाता है: end-exclusive, substring जैसा same convention।
Honest Note: आपका syllabus एक update() method list करता है; updating के लिए StringBuffer के real names setCharAt(index, ch) और replace(start, end, s) हैं। Exam में यही लिखिए।
Theory
Methods Buffer क्यों Return करते हैं
append और insert exactly वही buffer return करते हैं जिस पर आपने इन्हें call किया, तो calls plumbing की तरह chain होते हैं: sb.append(" 2nd Ed").insert(0, "* ").reverse()। Catalog loop बन जाता है: ONE StringBuffer create कीजिए, 6000 lines append कीजिए, आख़िर में एक बार toString() call कीजिए। String version जैसा same output, garbage का एक fraction। और "इसके methods synchronized हैं" file away कीजिए: जब Unit 4 threads introduce करता है, StringBuffer वह string tool है जो पहले से उनके लिए built है।
Summary
Key takeaways
- StringBuffer mutable है: append, insert, delete, setCharAt, replace और reverse एक object को in place edit करते हैं।
- Constructors: empty (capacity 16), sized, या एक String से (capacity 16 + length)।
- length() = stored characters; capacity() = allocated room; buffer ज़रूरत होने पर खुद grow करता है।
- delete और replace end-exclusive हैं, substring जैसा matching।
- Syllabus का update = real StringBuffer vocabulary में setCharAt / replace।
- Fixed text के लिए String इस्तेमाल कीजिए, heavy building के लिए StringBuffer; new StringBuffer(s).reverse().toString() से एक String reverse कीजिए।
- Memory hook: String एक printed page है, StringBuffer एक whiteboard है।