☕ Java Programming — Easy Notes

StringBuilder & StringBuffer

Mutable Strings + User Input in Java
Whiteboard Analogy • All Methods • Performance Proof • Scanner • nextLine() Trap • Interview Prep

🇮🇳 Hinglish Notes — Buffer Analogy | Method Cards | Memory Diagrams | Scanner

Traps | Easy Language

📦 PART 1 — Mutable String Kya Hota Hai?

Pichle notes mein padha tha — String immutable hai. Iska matlab: ek baar bana, badal nahi sakta.
Lekin kabhi kabhi hume String modify karna hota hai — jaise loop mein build karna. Iske liye Java ne
do special classes di hain:

📌 Mutable StringBuilder — Mutable (badal sakta hai), FAST, single-thread ke liye

String
StringBuffer — Mutable (badal sakta hai), Thread-safe (synchronized), thoda slow
Classes

Dono immutable String se ZYADA efficient hain jab baar baar modify karna ho!
Dono mein almost same methods hain — fark sirf thread-safety ka hai.

String = Patthar par likha — nahi badlta. StringBuilder = Whiteboard — jitna chaho erase karo,
dobara likho — fast! StringBuffer = Bank ka shared whiteboard — lock lagake likhna padta hai
(slow, lekin safe in multi-thread).

Problem — String + Operator Loop Mein Slow Kyun?

String s = s + i; → Har iteration mein NAYA String object banta hai!

📦 STACK (problem): HEAP:

s = "" + 0 → new obj 0xA001: ""
s = "0" + 1 → new obj 0xA002: "0" ← naya
s = "01" + 2→ new obj 0xA003: "01" ← naya
0xA004: "012" ← naya
5000 loops = 0xA005: "0123" ← naya
5000 naye objects! 😱 ...
GC ko bahut kaam — slow!

// Performance comparison — String vs StringBuilder in loop

// ❌ SLOW — String + loop
 long t1 = [Link]();
String slow = "";
for (int i = 0; i < 50000; i++) {
slow = slow + i; // Har iteration mein NAYA String object!
}
[Link]("String + loop: " + ([Link]()-t1) +
"ms");
// String + loop: ~3000ms ← VERY SLOW!

// ✅ FAST — StringBuilder
long t2 = [Link]();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 50000; i++) {
[Link](i); // Same object modify — naya nahi bana!
}
String fast = [Link]();
[Link]("StringBuilder: " + ([Link]()-t2) +
"ms");
// StringBuilder: ~10ms ← 300x FASTER!

📦 PART 2 — StringBuilder — Fast Mutable

String

🔷 StringBuilder — Basics aur Create Karna

StringBuilder ek mutable character sequence hai. Internally ek char[] buffer maintain karta hai —
seedha us buffer ko modify karta hai. Naya object nahi banta!

StringBuilder sb — Ek Buffer mein sab kuch — naya object nahi banta!

📦 STACK: HEAP:
sb → 0xB100 0xB100: StringBuilder
buffer: ['H','e','l','l','o']
(reference) length: 5
capacity: 21

[Link](" World")
buffer: ['H','e','l','l','o',
' ','W','o','r','l','d']
length: 11 ← SAME OBJ!

// StringBuilder create karna — 3 ways

// ── 3 tarike se StringBuilder banana ──
 // Way 1: Empty — default capacity 16
StringBuilder sb1 = new StringBuilder();
[Link]([Link]()); // 16
[Link]([Link]()); // 0

// Way 2: Initial capacity deke — better performance jab size pata ho

StringBuilder sb2 = new StringBuilder(100); // 100 char capacity

// Way 3: Initial String se

StringBuilder sb3 = new StringBuilder("Hello");
[Link](sb3); // Hello
[Link]([Link]()); // 5
[Link]([Link]()); // 21 (5 + 16 default extra)

// Capacity auto-grow bhi hoti hai — capacity full ho toh double+2 ho jaata
hai

🔷 StringBuilder Methods — Ek Ek Karke

Samjho
Method 1 — append() — End Mein Jodo
append — [Link](value)

Kuch bhi end mein add karo — String, int, char, boolean, float — sab!
StringBuilder sb = new StringBuilder("Hello"); [Link]("
").append("Java").append("!").append(42);
→ sb = "Hello Java!42" (method chaining!)

// append() — har type add karo, chaining bhi

StringBuilder sb = new StringBuilder();

// Alag alag types append kar sakte ho:

[Link]("Name: "); // String
[Link]("Rakesh"); // String
[Link]("\n"); // newline character
[Link]("Marks: ");
[Link](85); // int — auto convert to String
[Link]("\n");
[Link]("Passed: ");
[Link](true); // boolean
[Link]("\n");
 [Link]('A'); // char

[Link]([Link]());
// Name: Rakesh
// Marks: 85
// Passed: true
// A

// ── Method chaining — ek line mein sab ──

StringBuilder result = new StringBuilder()
.append("[")
.append("Rakesh")
.append(", ")
.append(92)
.append(", ")
.append("Patna")
.append("]");
[Link](result); // [Rakesh, 92, Patna]

Method 2 — insert() — Beech Mein Ghusa Do

insert — [Link](int index, value)

Specific index par kuch insert karo — baaki sab right shift ho jaata hai
StringBuilder sb = new StringBuilder("Hello World"); [Link](5, ", Java");
→ sb = "Hello, Java World"

// insert() — index par kuch ghusao

StringBuilder sb = new StringBuilder("Hello World");
[Link](sb); // Hello World

// Index 5 par ", Java" insert karo

[Link](5, ", Java");
[Link](sb); // Hello, Java World

// Start mein insert karo (index 0)

[Link](0, ">>> ");
[Link](sb); // >>> Hello, Java World

// End mein insert = append jaisa

[Link]([Link](), " <<<");
[Link](sb); // >>> Hello, Java World <<<

// Char insert karo:

 StringBuilder name = new StringBuilder("RakshKumar");
[Link](5, 'e'); // 'e' beech mein
[Link](name); // RakeshKumar

Method 3 — delete() aur deleteCharAt()

delete — [Link](int start, int end)

Index start to end-1 tak ke characters hata do — end EXCLUSIVE

StringBuilder sb = new StringBuilder("Hello Java World"); [Link](6, 11);
→ sb = "Hello World" (index 6 to 10 removed)

// delete() aur deleteCharAt() — characters hataao

StringBuilder sb = new StringBuilder("Hello Java World");
// 0123456789...

// delete(start, end) — start to end-1

[Link](6, 11); // 'Java ' remove (index 6,7,8,9,10)
[Link](sb); // Hello World

// deleteCharAt(index) — ek hi char remove karo

[Link](5); // space remove (index 5)
[Link](sb); // HelloWorld

// ── Practical: Last character hataao (trailing comma) ──

StringBuilder csv = new StringBuilder();
String[] fruits = {"Mango", "Apple", "Banana"};
for (String f : fruits) {
[Link](f).append(",");
}
// Ab last comma hataao:
[Link]([Link]() - 1);
[Link](csv); // Mango,Apple,Banana ← no trailing comma!

Method 4 — replace() — Range Replace Karo

replace — [Link](int start, int end, String str)

Index start to end-1 ko naye str se replace karo

StringBuilder sb = new StringBuilder("Hello Java"); [Link](6, 10, "World");
→ sb = "Hello World"
 // replace() — range ko naye string se replace karo
StringBuilder sb = new StringBuilder("Hello Java");

// 'Java' (index 6-9) ko 'World' se replace karo

[Link](6, 10, "Hello World".length() > 5 ? "World" : "Java");
[Link](6, 10, "World");
[Link](sb); // Hello World

// Shorter replacement — baaki compress ho jaata hai

StringBuilder s2 = new StringBuilder("Hello Beautiful World");
[Link](6, 16, "Java"); // 'Beautiful' (10 chars) → 'Java' (4 chars)
[Link](s2); // Hello Java World

// Longer replacement — baaki expand ho jaata hai

StringBuilder s3 = new StringBuilder("Hi Java");
[Link](0, 2, "Hello"); // 'Hi' (2) → 'Hello' (5)
[Link](s3); // Hello Java

Method 5 — reverse() — Ulta Karo

reverse — [Link]()

Poore StringBuilder ko reverse karo — interview mein bahut aata hai!

StringBuilder sb = new StringBuilder("Hello"); [Link]();
→ sb = "olleH"

// reverse() — palindrome check aur word reverse

// ── Basic reverse ──
StringBuilder sb = new StringBuilder("Hello Java");
[Link]();
[Link](sb); // avaJ olleH

// ── Palindrome check — interview question! ──

String word = "racecar";
String reversed = new StringBuilder(word).reverse().toString();
if ([Link](reversed)) {
[Link](word + " is a palindrome!"); // racecar is a
palindrome!
} else {
[Link](word + " is NOT a palindrome.");
}

// ── String reverse — cleanest way ──

String original = "Rakesh";
 String rev = new StringBuilder(original).reverse().toString();
[Link](rev); // hsekeR

// ── Reverse words in sentence ──

String sentence = "Java is awesome";
String[] words = [Link](" ");
StringBuilder sb2 = new StringBuilder();
for (int i = [Link] - 1; i >= 0; i--) {
[Link](words[i]);
if (i > 0) [Link](" ");
}
[Link](sb2); // awesome is Java

Method 6 — charAt(), setCharAt(), indexOf(), substring()

// charAt, setCharAt, indexOf, substring, capacity
StringBuilder sb = new StringBuilder("Hello Java World");

// ── charAt() — ek char padho ──

[Link]([Link](6)); // J

// ── setCharAt() — ek char badlo (String mein yeh possible nahi!) ──

[Link](6, 'j'); // 'J' → 'j'
[Link](sb); // Hello java World

// ── indexOf() ──
[Link]([Link]("java")); // 6
[Link]([Link]("Python")); // -1

// ── substring() — part nikalo ──

[Link]([Link](6)); // java World
[Link]([Link](6, 10)); // java

// ── length() aur capacity() ──

[Link]([Link]()); // 16 (actual characters)
[Link]([Link]()); // 32 (buffer size — auto grown)

// ── ensureCapacity() — performance ke liye ──

StringBuilder sb2 = new StringBuilder();
[Link](1000); // Pehle se 1000 capacity reserve karo
// Ab 1000 chars tak bina reallocation ke add kar sakte ho

// ── toString() — final mein String banao ──

 String result = [Link](); // StringBuilder → String
[Link]([Link]().getSimpleName()); // String

StringBuilder — All Methods Quick Reference

Method Syntax Use / Result

append(x) [Link]("Hi").append(42 End mein jodo — chaining

)

insert(i, x) [Link](3, "Java") Index 3 par insert

delete(s,e) [Link](2, 5) Index 2 to 4 remove

deleteCharAt(i) [Link](0) Index 0 ka char remove

replace(s,e,str) [Link](0,5,"Hi") Range replace

reverse() [Link]() Palindrome check!

charAt(i) [Link](2) Char at index

setCharAt(i,ch) [Link](0,'h') Char set — String mein nahi!

indexOf(str) [Link]("Java") First index ya -1

substring(b) [Link](5) Index 5 se end

substring(b,e) [Link](2, 7) Index 2 to 6

length() [Link]() Current length

capacity() [Link]() Buffer size

ensureCapacity(n) [Link](100) Min capacity ensure karo

toString() [Link]() String mein convert

📦 PART 3 — StringBuffer — Thread-Safe

Version

🔷 StringBuffer — Kab aur Kyun Use Karo?

StringBuffer bhi StringBuilder jaisi hi hai — almost same methods hain. Ek bada fark: StringBuffer ke
methods synchronized hain — matlab ek waqt mein sirf ek thread access kar sakta hai.

StringBuffer = ATM machine. Ek waqt mein sirf ek aadmi andar ja sakta hai — door lock hoti hai.
Safe hai — lekin slow bhi. StringBuilder = Ghar ka drawer — koi lock nahi — fast! Multi-thread mein
StringBuffer safe hai.
 Feature StringBuilder StringBuffer

Mutable? ✅ Haan ✅ Haan

Thread-safe? ❌ Nahi ✅ Haan (synchronized)

Performance 🚀 Fast 🐢 Slower (sync overhead)

Use karo jab Single thread Multiple threads

Java version Java 5+ Java 1.0+

Methods Same methods Same methods

reverse() ✅ Hai ✅ Hai

Memory Thoda kam Thoda zyada (sync metadata)

// StringBuffer — syntax same, thread-safe alag

// StringBuffer — StringBuilder jaisi hi syntax!
StringBuffer sbf = new StringBuffer();
[Link]("Hello");
[Link](" World");
[Link](5, ",");
[Link]();
[Link]([Link]()); // dlroW ,olleH

// ── Thread-safety demo ──
// Multiple threads ek saath StringBuffer modify karein — safe!
StringBuffer shared = new StringBuffer();

// Thread 1 (synchronized — lock milega tab likhega):

// [Link]("Thread1 data");

// Thread 2 (wait karega agar Thread1 ne lock le rakha hai):

// [Link]("Thread2 data");

// StringBuilder ke saath yeh unsafe hoga — data corrupt ho sakta!

// ── Kab use karo? ──

// Single thread → ALWAYS StringBuilder (faster!)
// Multi-thread → StringBuffer (safe!)
// In doubt → StringBuilder — zyada baar single thread hota hai
📊 String vs StringBuilder vs StringBuffer —
Complete Comparison
Feature String StringBuilder StringBuffer

Mutability ❌ Immutable ✅ Mutable ✅ Mutable

Thread-safe ✅ Yes (immutable) ❌ No ✅ Yes (sync)

Performance Slowest (new obj) 🚀 Fastest Medium

Memory (loop) Bahut zyada Efficient Efficient

String Pool ✅ Use karta ❌ Nahi ❌ Nahi

+ operator New obj banata N/A (append()) N/A (append())

setCharAt() ❌ Nahi ✅ Hai ✅ Hai

reverse() ❌ Nahi ✅ Hai ✅ Hai

Use case Fixed value Single-thread build Multi-thread build

Package [Link] [Link] [Link]

der er

📦 PART 4 — User Input — Scanner Class

🔷 Scanner — Console se Input Lena

Java mein user se input lene ke liye Scanner class use karte hain — [Link] package mein
hai. [Link] se keyboard ka input padhta hai.

Scanner = Cashier at counter. Customer (user) kuch bolta hai — cashier (Scanner) sun ke note kar
leta hai. nextLine() = poori baat suno. next() = ek word suno. nextInt() = sirf number suno.

// Scanner basics — import, create, nextLine, nextInt

// ── Scanner import karo ──
import [Link];

// ── Scanner object banana ──

Scanner sc = new Scanner([Link]);
// ↑ [Link] = keyboard (stdin)

// ── Basic input ──
[Link]("Apna naam batao: ");
String name = [Link](); // Poori line padhta hai
 [Link]("Hello, " + name + "!");

[Link]("Apni umar batao: ");

int age = [Link](); // Integer padhta hai
[Link]("Umar: " + age);

[Link]("Height (meters): ");

double height = [Link](); // Decimal padhta hai
[Link]("Height: " + height + "m");

// ── Scanner band karo ──

[Link](); // Resource free karo!

Method Example Kya karta hai / Return

nextLine() [Link]() Poori line padhta hai (spaces ke saath) → String
next() [Link]() Ek word padhta hai (space tak) → String
nextInt() [Link]() Ek integer padhta hai → int
nextDouble() [Link]() Ek decimal padhta hai → double
nextFloat() [Link]() Ek float padhta hai → float
nextLong() [Link]() Ek long padhta hai → long
nextBoolean() [Link]() true/false padhta hai → boolean
nextLine() after [Link](); [Link]() Newline consume karo — buffer clear!
nextInt()

hasNext() [Link]() Aur input hai? → boolean

close() [Link]() Scanner band karo — resource free

⚠️MOST IMPORTANT — nextInt() ke baad nextLine() Trap!

🪤 The PROBLEM: jab nextInt() (ya nextDouble()) ke baad nextLine() call karo — toh khaali
nextLine() String milti hai!
Trap

KYUN? nextInt() sirf number padhta hai — baad mein jo \n (Enter) press hua tha
woh BUFFER mein reh jaata hai.
Jab nextLine() call karo — woh buffer ka \n consume kar leta hai — actual line nahi
padhta!

FIX: nextInt() ke baad ek extra [Link]() call karo — buffer clear karne ke liye.

// nextLine() trap — problem aur 2 fixes

// ⚠️ TRAP — nextInt() ke baad nextLine()
 Scanner sc = new Scanner([Link]);

[Link]("Roll number: ");

int roll = [Link](); // User ne '101' type kiya aur ENTER dabaaya
// Buffer mein: '\n' bacha hai! (Enter ka newline)

[Link]("Naam batao: ");

String name = [Link](); // ❌ PROBLEM! Buffer ka \n consume ho gaya
// name = "" ← khaali string! User ka naam nahi mila!

[Link]("Name: '" + name + "'"); // Name: '' ← GALAT!

// ════════════════════════════════════
// ✅ FIX — ek extra nextLine() baad mein
// ════════════════════════════════════
Scanner sc2 = new Scanner([Link]);

[Link]("Roll number: ");

int roll2 = [Link]();
[Link](); // ✅ Buffer clear! \n consume kar do

[Link]("Naam batao: ");

String name2 = [Link](); // ✅ Ab sahi naam milega!
[Link]("Roll: " + roll2 + ", Name: " + name2);

// ── Alternative Fix: [Link]() ──

Scanner sc3 = new Scanner([Link]);
[Link]("Roll number: ");
int roll3 = [Link]([Link]()); // nextLine se lo, parseInt se
convert
[Link]("Naam batao: ");
String name3 = [Link](); // ✅ Koi trap nahi — sab nextLine!

Multiple Inputs — Alag Alag Types

// Multiple inputs — int, String, loop input, no traps
import [Link];

public class MultiInput {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]);

// ── Multiple values same line se ──

 [Link]("3 numbers ek line mein likho (e.g. 10 20 30):");
int a = [Link]();
int b = [Link]();
int c = [Link]();
[Link]("Sum: " + (a+b+c));
[Link](); // Buffer clear

// ── String input ──
[Link]("Full name: ");
String fullName = [Link](); // Spaces ke saath

// ── Email input aur validate ──

[Link]("Email: ");
String email = [Link]().trim().toLowerCase();
boolean valid = [Link]("[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]
{2,}");
[Link]("Email valid: " + valid);

// ── Loop se multiple students ──

[Link]("Kitne students? ");
int n = [Link]();
[Link](); // ← Buffer clear!

String[] names = new String[n];

int[] marks = new int[n];

for (int i = 0; i < n; i++) {

[Link]("Student " + (i+1) + " naam: ");
names[i] = [Link]();
[Link]("Student " + (i+1) + " marks: ");
marks[i] = [Link]([Link]()); // No trap!
}

// ── Print report ──
[Link]("\n=== Report ===");
for (int i = 0; i < n; i++) {
[Link]("%-15s : %d%n", names[i], marks[i]);
}

[Link]();
}
}
Scanner — File aur String se bhi Input Le Sakte Ho!
// Scanner — String aur File se bhi input, hasNext() loop
import [Link];
import [Link];

// ── String se input ──
String data = "Rakesh 85 Patna";
Scanner strSc = new Scanner(data);
String name = [Link](); // Rakesh
int marks = [Link](); // 85
String city = [Link](); // Patna
[Link](name + " scored " + marks + " in " + city);
[Link]();

// ── File se input (basic) ──

// try {
// Scanner fileSc = new Scanner(new File("[Link]"));
// while ([Link]()) {
// String line = [Link]();
// [Link]("Read: " + line);
// }
// [Link]();
// } catch (Exception e) {
// [Link]("File nahi mili: " + [Link]());
// }

// ── hasNext() se safe input ──

Scanner sc = new Scanner([Link]);
[Link]("Numbers type karo (Ctrl+D se band karo):");
int sum = 0, count = 0;
while ([Link]()) {
sum += [Link]();
count++;
}
[Link]("Sum: " + sum + ", Count: " + count);
if (count > 0) [Link]("Average: %.2f%n", (double)sum/count);

Complete Project — Student Registration

System
StringBuilder, StringBuffer, Scanner — sab ek saath use karte hain:
// Complete project — StringBuilder report + StringBuffer log + Scanner input
// Student Registration System
// StringBuilder + StringBuffer + Scanner + String methods
import [Link];

public class RegistrationSystem {

// StringBuilder se report banao (single thread — fast)

static String buildReport(String[] names, int[] marks) {
StringBuilder sb = new StringBuilder();
[Link]("\n╔══════════════════════════╗\n");
[Link]("║ STUDENT REPORT CARD ║\n");
[Link]("╠══════════════════════════╣\n");

int total = 0;
for (int i = 0; i < [Link]; i++) {
char grade =
marks[i]>=90?'A':marks[i]>=75?'B':marks[i]>=60?'C':'F';
[Link]([Link]("║ %-12s %3d [%c] ║%n",
names[i], marks[i], grade));
total += marks[i];
}

[Link]("╠══════════════════════════╣\n");
[Link]([Link]("║ Average: %16.1f ║%n",
(double)total/[Link]));
[Link]("╚══════════════════════════╝");
return [Link]();
}

// StringBuffer se log banao (thread-safe ke liye ready)

static StringBuffer activityLog = new StringBuffer();

static void log(String msg) {

[Link]("[LOG] ").append(msg).append("\n");
}

public static void main(String[] args) {

Scanner sc = new Scanner([Link]);

log("System started");

[Link]("Kitne students register karoge? ");

int n = [Link]([Link]()); // No trap!
 String[] names = new String[n];
int[] marks = new int[n];

for (int i = 0; i < n; i++) {

[Link]("Student " + (i+1) + " ka naam: ");
String raw = [Link]().trim();

// Name format karo — StringBuilder use

StringBuilder formatted = new StringBuilder();
for (String part : [Link]("\\s+")) {
if (![Link]()) {
[Link]([Link]([Link](0)))
.append([Link](1).toLowerCase())
.append(" ");
}
}
names[i] = [Link]().trim();

[Link]("Marks (0-100): ");

marks[i] = [Link]([Link]());
log(names[i] + " registered with marks " + marks[i]);
}

// Report print karo

[Link](buildReport(names, marks));

// Activity log print karo

[Link]("\n=== Activity Log ===");
[Link]([Link]());

// Palindrome check demo

[Link]("\nKoi word likho (palindrome check): ");
String word = [Link]().trim().toLowerCase();
String rev = new StringBuilder(word).reverse().toString();
[Link](word + ([Link](rev)?" IS":" is NOT") + " a
palindrome!");

[Link]();
}
}

// Sample Output (3 students):

// ╔══════════════════════════╗
// ║ STUDENT REPORT CARD ║
// ╠══════════════════════════╣
// ║ Rakesh Kumar 85 [B] ║
// ║ Priya Sharma 92 [A] ║
// ║ Ajay Verma 70 [C] ║
// ╠══════════════════════════╣
// ║ Average: 82.3 ║
// ╚══════════════════════════╝
// [LOG] System started
// [LOG] Rakesh Kumar registered with marks 85
// [LOG] Priya Sharma registered with marks 92
// racecar IS a palindrome!

⚠️Common Galtiyan
// Common galtiyan — StringBuilder, Scanner traps, thread safety
// ── Galti 1: StringBuilder ko String ki tarah compare kiya ──
StringBuilder sb = new StringBuilder("Hello");
// ❌ GALAT:
// if (sb == "Hello") // false — different types!
// if ([Link]("Hello")) // false! [Link] is reference-based
// ✅ SAHI:
if ([Link]().equals("Hello")) [Link]("Match!");

// ── Galti 2: Loop mein StringBuilder result galat ──

StringBuilder csv = new StringBuilder();
String[] fruits = {"Mango", "Apple", "Banana"};
for (String f : fruits) {
[Link](f).append(",");
}
// ❌ GALAT output: Mango,Apple,Banana, ← trailing comma!
// ✅ FIX 1: deleteCharAt
[Link]([Link]()-1); // Mango,Apple,Banana ✅
// ✅ FIX 2: [Link]
String result = [Link](",", fruits); // Mango,Apple,Banana ✅

// ── Galti 3: nextInt() ke baad nextLine() trap ──

Scanner sc = new Scanner([Link]);
int n = [Link]();
// ❌ GALAT:
String name = [Link](); // Khaali string milegi!
// ✅ SAHI:
[Link](); // Buffer clear
 String name2 = [Link](); // Ab sahi input milega

// ── Galti 4: Scanner close karna bhool gaye ──

// ❌ GALAT — resource leak!
Scanner sc2 = new Scanner([Link]);
// ... use karo ... (but close nahi kiya)
// ✅ SAHI — try-with-resources
try (Scanner sc3 = new Scanner([Link])) {
// auto close ho jaayega!
}

// ── Galti 5: StringBuilder ko thread-safe samajh liya ──

// ❌ GALAT — multi-thread mein StringBuilder use kiya
// Thread1 aur Thread2 ek saath [Link]() karein → corrupt data!
// ✅ SAHI — multi-thread ke liye StringBuffer

📋 Quick Revision — Exam ke Liye

14 Sabse Zaroori Baatein
• 1. StringBuilder kya hai: Mutable String — same object modify hota hai — naya nahi banta
• 2. StringBuffer kya hai: StringBuilder + synchronized — multi-thread safe
• 3. Performance: String (slowest) < StringBuffer < StringBuilder (fastest)
• 4. append(): end mein kuch bhi jodo — chaining karo
• 5. insert(i, x): beech mein ghusao — index par
• 6. delete(s, e): s to e-1 remove karo — end EXCLUSIVE
• 7. replace(s, e, str): range ko naye string se replace karo
• 8. reverse(): palindrome check ka best tarika!
• 9. setCharAt(i, ch): String mein nahi hota — StringBuilder mein hota hai
• 10. toString(): final mein String mein convert karo
• 11. Scanner: [Link] — [Link] se keyboard input
• 12. nextLine(): poori line — spaces ke saath — use karo!
• 13. nextInt() trap: nextInt ke baad [Link]() se buffer clear karo
• 14. Scanner close(): [Link]() ya try-with-resources — resource leak na ho

Topic Rule / Syntax Easy Yaad Karo

StringBuilder kya hai Mutable String — ek hi Whiteboard — erase karo, dobara likho
object modify

StringBuffer kya hai Mutable + synchronized Bank counter — ek waqt ek kaam

(thread-safe)

append() [Link]("hello") End mein jodna — chain bhi kar sakte

insert(i, str) [Link](5, "Java") Beech mein ghusa do

delete(s, e) [Link](2, 7) Index s to e-1 remove karo

replace(s, e, str) [Link](0, 4, "Hi") Index range replace karo

reverse() [Link]() Ulta karo — interview mein aata hai!

toString() [Link]() String mein convert karo — final step

capacity() [Link]() Current buffer size — default 16

String vs SB perf Loop mein SB 40x faster + operator naya object banata hai

nextLine() [Link]() Poori line — spaces ke saath

next() trap [Link]() space tak rukta "Rakesh Kumar" → sirf "Rakesh"!
hai

nextInt() trap nextInt ke baad nextLine() Buffer mein \n reh jaata hai
call karo

Scanner close [Link]() — try-finally Resource leak nahi hona chahiye

mein

Java Notes — StringBuilder • StringBuffer • Mutable String • Scanner • nextLine() Trap • User Input | Hinglish
Edition 🇮🇳