☕ Java Programming

String in Java
String Pool • == vs .equals() • Types of String
Immutability • StringBuilder • StringBuffer • Memory Diagrams • Interview Questions
Strings
---
Sequence of characters.
String is a class.
String is treated as an Object.

Types of String:
----
[Link] String: No change after creation.
[Link] String: We can change it after creation.

Immutable String:
---
Immutable String Created using:
String literal (“---”) without new keyword String contanst Pool
String literal (“---”) with new keyword  Normal Heap Area
String Methods:
----
[Link]() Return type String.
[Link]() Return type Int.
[Link]() Return type boolean.
[Link]() Return type boolean
[Link]()  Return type String.
[Link]() Converts string into array. Return type char []
[Link]()  RT boolean
[Link]()  RT boolean
[Link]() RT byte[]
[Link]() RT String
[Link]() RT String , Used to achieve consistency.
[Link]() RT String, Used to achieve consistency.
[Link]() RT String array: String[]
[Link] RT boolean
[Link]() Return type int =>First Occurence
[Link]()  Last Occurence
[Link]() RT String only
[Link]() RT int
[Link]()  Pusing string from Non constant Pool to constant Pool

import [Link];
public class Main {

public static void main([Link][] args) {

/*
String x="abcd";
String concat = [Link]("123");
[Link](concat);

int length = [Link]();

[Link](length);

*/

/*
String i = new String("123");
String j = new String("123");
[Link]([Link](j)); //true

String s = new String("ABC");

String r = new String("abc");
[Link]([Link](r)); //true

String xyz = " abcd ";

String trim = [Link]();
[Link](trim);
*/

/*
String test = "abcd123%*()UUU";
char[] charArray = [Link]();

for(char c : charArray){
if((c>=65 && c<=90) || (c>=97 && c<=122) ){
[Link](c);
}
}
*/

/*
 String h = "abcd@[Link]";
boolean b = [Link]("@[Link]");
[Link](b); //treu
*/

/*
String k = "abcde";
char[] charArray1 = [Link]();
byte[] b = new byte[[Link]];

int i=0;
for(char c : charArray1){
b[i] = (byte)c;
i++;
}

String string = [Link](b);

[Link](string);
*/
/*

String k = "abcde";
byte[] bytes = [Link]();
String string = [Link](bytes);
[Link](string);
*/

String k = "abcdefghijk";
// String substring1 = [Link](4);
// [Link](substring1); //efghijk
String substring1 = [Link](4,7);
[Link](substring1); //efg

}
}

Mutable String:
---
[Link]([Link])
[Link]([Link])

🔷 String Kya Hai? — Basic Samjho

String Java mein ek class hai — primitive type nahi! Ye characters ka sequence hai — jaise "Hello" = H,e,l,l,o.
String ko double quotes mein likhte hain.

📌 String ke 3 Key 1. STRING EK CLASS HAI — [Link] — automatically import hoti hai
Facts 2. STRING IMMUTABLE HAI — ek baar bana, badal nahi sakta (character by
character fixed)
3. STRING POOL — Java ek special memory area maintain karta hai jahan
strings share hoti hain

String = Printed passport. Ek baar passport print ho gaya — uske characters badal nahi sakte. Kuch change
karna hai? Naya passport banao! Purana wahi rehta hai. Waise hi String immutable hai — modify nahi hoti,
naya String banta hai.

// String basics — literal vs new, immutability

// String banana — 2 tarike
String s1 = "Hello"; // Way 1: Literal — String Pool mein jaata hai
String s2 = new String("Hello"); // Way 2: new keyword — Heap par alag object

// String ek class hai — isliye itne methods hain!

[Link]([Link]()); // 5
[Link]([Link]()); // HELLO
[Link]([Link](1)); // e
[Link]([Link](1,4)); // ell
[Link]([Link]("ell")); // true

// String immutable — modification kiya toh naya String bana

String original = "Java";
String modified = [Link](); // Naya String "JAVA" bana
[Link](original); // Java ← abhi bhi same! Badla nahi
[Link](modified); // JAVA ← naya String

🔷 Immutability — String Badlta Kyun Nahi?

Immutable matlab — ek baar banao, phir change nahi ho sakta. Jab bhi String ko modify karte ho, Java actually ek
NAYA String object banata hai — purana wahi rehta hai!

Sochho tum ek whiteboard par 'Java' likha. Ab tum 'JAVA' banana chahte ho — lekin whiteboard permanent
marker se likha hai! Tum whiteboard erase karke naya likh sakte ho — lekin purana whiteboard hata nahi —
yahi hai immutability!
 // Immutability — proof aur reasons
// Immutability — proof karo
String s = "Hello";
[Link]([Link](s)); // e.g. 12345 (object ka address)

s = s + " World"; // Lagta hai modify kiya — actually NAYA String bana!
[Link]([Link](s)); // e.g. 67890 ← alag address!
// Purana "Hello" object Heap par abhi bhi hai — GC collect karega baad mein

// ── Loop mein + operator ka problem ──

String result = "";
for (int i = 0; i < 5; i++) {
result = result + i; // Har iteration mein NAYA String — slow!
}
// 5 iterations mein 5 naye String objects ban gaye — memory waste!

// ── Immutability kyun? 3 Reasons ──

// 1. SECURITY: Password string koi change nahi kar sakta
// 2. THREAD SAFETY: Multiple threads ek hi String use kar sakti hain safely
// 3. STRING POOL: Sharing possible hai kyunki value change nahi hoti

🔷 String Constant Pool — Java ka Smart System

String Constant Pool (SCP) Heap memory ka ek special area hai. Jab tum literal syntax se String banate ho —
Java pehle pool mein check karta hai: kya yeh string pehle se hai? Agar hai — same object return karta hai. Naya
nahi banata!

String Pool = Library ka catalog. Agar library mein 'Harry Potter' pehle se hai — toh koi naya copy nahi kharidti
library — same book deti hai. Waise Java String pool mein pehle se rakhi String ko dobara nahi banata —
reuse karta hai!

3.1 — Literal se String Banana — Pool Mein Jaata Hai

🏊 String Constant Pool (Heap ka special area)

"Java" "Hello" "Patna" "Python"

String s1 = "Java"; → Pool mein "Java" nahi tha → banaya → s1 point karta hai
String s2 = "Hello"; → Pool mein "Hello" nahi tha → banaya → s2 point karta hai
String s3 = "Java"; → Pool mein "Java" PEHLE SE HAI → same object return!
 s1 == s3 → TRUE! (dono same pool object par point kar rahe hain)

// Literal strings — pool reuse proof

// Literal — Pool use karta hai
String s1 = "Java";
String s2 = "Java";
String s3 = "Hello";

[Link](s1 == s2); // true ← dono same pool object!

[Link](s1 == s3); // false ← alag strings

// identityHashCode se prove karo:

[Link]([Link](s1)); // e.g. 12345
[Link]([Link](s2)); // e.g. 12345 ← SAME!
[Link]([Link](s3)); // e.g. 99999 ← DIFFERENT

String s1 = "Java"; String s2 = "Java"; — Pool mein ek hi object!

📦 STACK 🏔️HEAP
s1 → 0xP001 String Constant Pool:
s2 → 0xP001 ← same! 0xP001: "Java" ← s1 aur s2
s3 → 0xP002 dono yahan point
0xP002: "Hello" ← s3

Koi naya object nahi bana!

3.2 — new String() — Pool BYPASS karta hai!

Jab new keyword use karte ho — Java poochhhta bhi nahi pool mein — seedha Heap par naya object banata hai.
Isliye == false aata hai!

String s1 = "Java"; String s2 = new String("Java"); — 2 ALAG objects!

📦 STACK 🏔️HEAP
s1 → 0xP001 (pool) String Constant Pool:
s2 → 0xH500 (heap) 0xP001: "Java" ← s1

s1 == s2 → FALSE Regular Heap:

(alag addresses!) 0xH500: "Java" ← s2
(alag object!)
 Content same — address alag!

// new String() — pool bypass, intern() fix

// new String() — Pool bypass
String s1 = "Java"; // Pool mein jaata hai
String s2 = new String("Java"); // Pool bypass — alag Heap object

[Link](s1 == s2); // false ← alag objects!

[Link]([Link](s2)); // true ← content same hai

// identityHashCode prove karta hai:

[Link]([Link](s1)); // e.g. 12345 (pool)
[Link]([Link](s2)); // e.g. 67890 (heap) ← ALAG!

// ── intern() — new String ko pool mein daal sakte ho ──

String s3 = new String("Java").intern(); // Pool mein daal do!
[Link](s1 == s3); // true! ← ab pool ka reference mil gaya

3.3 — Pool mein String kab NAYA banta hai?

🏊 Pool Rules — Step by Step 1: String literal likhte ho → JVM pool check karta hai
Step Step 2: Pool mein hai?
YES → same reference return — naya object nahi banta ✅
Memory save!
NO → naya String pool mein banata hai → reference return

Step 3: new String() likhte ho → Direct Heap par — pool check hi nahi
hota

String pool Java 7 se Heap mein aaya (pehle PermGen mein tha)
Pool ke objects bhi GC collect kar sakta hai (agar koi reference nahi)

🔷 == vs .equals() — Sabse Zyada Poocha Jaata Interview Mein!

Yeh concept Java interview mein hamesha aata hai! == aur .equals() dono compare karte hain — lekin KUCH
ALAG cheez compare karte hain. Samjho dhyan se:
 == = Do ghar ka ADDRESS compare karo. Patna aur Patna ek hi sheher hai — lekin alag alag ghar hain toh
address alag! .equals() = Do ghar ka CONTENT compare karo. Dono ghar mein ek jaisi cheezein hain? Toh
equal!

Feature == (Double Equals) .equals() Method

Kya compare References (memory address) Content (actual characters)
karta?
Kab true aata? Dono same object point karein Dono ka content same ho
Primitives par? Kaam karta — value compare Kaam nahi — primitives mein .equals()
nahi
String literals? True (pool mein same object) True (content same)
new String()? False (alag objects!) True (content same)
Use karo jab? Null check: s == null String content compare karna ho
Risk? Galat result — confusing bugs! Safe — hamesha content compare
Example s1 == s2 → address same? [Link](s2) → content same?

4.1 — 4 Cases — Clearly Samjho

// 4 Cases — == vs .equals() har scenario mein
// ═══════════════════════════════════════════════════
// Case 1: Dono literals — Pool mein same object
// ═══════════════════════════════════════════════════
String a = "Hello";
String b = "Hello";
[Link](a == b); // true ← pool same object
[Link]([Link](b)); // true ← content bhi same

// ═══════════════════════════════════════════════════
// Case 2: Ek literal, ek new String()
// ═══════════════════════════════════════════════════
String c = "Hello";
String d = new String("Hello");
[Link](c == d); // false ← alag objects (pool vs heap)
[Link]([Link](d)); // true ← content same

// ═══════════════════════════════════════════════════
// Case 3: Dono new String()
 // ═══════════════════════════════════════════════════
String e = new String("Hello");
String f = new String("Hello");
[Link](e == f); // false ← dono alag Heap objects
[Link]([Link](f)); // true ← content same

// ═══════════════════════════════════════════════════
// Case 4: Alag content
// ═══════════════════════════════════════════════════
String g = "Hello";
String h = "World";
[Link](g == h); // false ← alag objects
[Link]([Link](h)); // false ← content bhi alag

// RULE: String compare karte waqt HAMESHA .equals() use karo!

// == sirf null check ke liye use karo: if (s == null)

4.2 — String Concatenation aur Pool

// Concatenation aur pool — compile-time vs runtime
// Concatenation ka Pool pe effect

// ── Compile-time constant → Pool mein jaata hai ──

String s1 = "Hello" + " World"; // Compile time — compiler join karta hai
String s2 = "Hello World";
[Link](s1 == s2); // true ← compiler ne pehle se join kar diya!

// ── Runtime concatenation → Pool bypass ──

String part1 = "Hello";
String part2 = " World";
String s3 = part1 + part2; // Runtime — naya object bana, pool mein nahi!
[Link](s2 == s3); // false ← s3 pool mein nahi!
[Link]([Link](s3)); // true ← content same

// ── final variables → compile-time constant treat hote hain ──

final String f1 = "Hello";
final String f2 = " World";
String s4 = f1 + f2; // final hai — compile time join hota hai
 [Link](s2 == s4); // true ← pool mein same object!

4.3 — equalsIgnoreCase(), compareTo() — Aur Useful Methods

// equalsIgnoreCase, compareTo, null-safe equals
// ── equalsIgnoreCase() — case ignore karke compare ──
String username = "RAKESH";
String input = "rakesh";
[Link]([Link](input)); // false
[Link]([Link](input)); // true ✅

// ── compareTo() — alphabetical order ──

String s1 = "Apple";
String s2 = "Banana";
[Link]([Link](s2)); // negative (A comes before B)
[Link]([Link](s1)); // positive (B comes after A)
[Link]([Link](s1)); // 0 (same)

// ── Safe equals — NullPointerException se bachao ──

String userInput = null;
// ❌ GALAT — NPE!
// if ([Link]("admin")) ...

// ✅ Way 1 — null check pehle

if (userInput != null && [Link]("admin")) {
[Link]("Login!");
}

// ✅ Way 2 — literal pehle rakho (best practice!)

if ("admin".equals(userInput)) { // null safe — NPE nahi aayega!
[Link]("Login!");
}
// "admin" null nahi ho sakta — isliye pehle aata hai

🔷 Types of String in Java — Teen Types

Java mein String banane ke teen main tarike hain — aur teen alag classes hain. Har ek alag situation ke liye best
hai:

📌 Teen Types 1. String — Immutable (nahi badlta) — [Link]

2. StringBuilder — Mutable, fast (single thread ke liye) — [Link]
3. StringBuffer — Mutable, thread-safe (multi-thread ke liye) —
[Link]

Type 1 — String (Immutable)

String = Patthar par khudha hua naam. Ek baar khud gaya — badal nahi sakta. Kuch change karna hai? Naya
patthar lo! Performance ke liye costly — lekin safe aur shareable.

// String — immutable type

// String — immutable — har modification naya object banata hai
String name = "Rakesh";
name = name + " Kumar"; // Naya String bana — "Rakesh" wahan hi raha
name = [Link](); // Phir naya — ab teen objects ban gaye!
[Link](name); // RAKESH KUMAR

// Kab use karo?

// ✅ Jab String change nahi hoga — fixed values
// ✅ Thread-safe environment
// ✅ HashMap keys (immutable hona zaroori)
// ✅ Configuration values

// ❌ Kab nahi use karo?

// ❌ Loop mein baar baar modify karna ho — StringBuilder better!

Type 2 — StringBuilder (Mutable, Fast)

StringBuilder = Whiteboard par likha hua. Erase karo, dobara likho — jitni baar chaho! Whiteboard alag nahi
kharidna — same whiteboard modify hota hai. Fast aur efficient!

// StringBuilder — mutable, append, insert, delete, reverse

// StringBuilder — mutable, single-thread ke liye fast
StringBuilder sb = new StringBuilder();
 // append() — add karo end mein
[Link]("Hello");
[Link](" ");
[Link]("World");
[Link]([Link]()); // Hello World

// insert() — beech mein daal do

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

// delete() — hata do
[Link](5, 15); // index 5 to 14 remove
[Link](sb); // Hello World

// replace() — replace karo

[Link](6, 11, "Java");
[Link](sb); // Hello Java

// reverse() — ulta karo

[Link]();
[Link](sb); // avaJ olleH

// length() aur charAt()

[Link]([Link]()); // 10
[Link]([Link](0)); // a

// ── Loop mein StringBuilder — kitna fast! ──

long start = [Link]();
StringBuilder fast = new StringBuilder();
for (int i = 0; i < 10000; i++) {
[Link](i); // Ek hi object modify — naya nahi bana!
}
[Link]("StringBuilder time: " + ([Link]()-start) + "ms");
// StringBuilder time: ~5ms ← FAST!

String vs StringBuilder — Performance Comparison

// String vs StringBuilder — performance proof
 // ── String + loop — SLOW (naye objects ban rahe hain) ──
long t1 = [Link]();
String slow = "";
for (int i = 0; i < 10000; i++) {
slow = slow + i; // Har baar NAYA String object! ← BAD
}
[Link]("String loop: " + ([Link]()-t1) + "ms");
// String loop: ~200ms ← SLOW!

// ── StringBuilder + loop — FAST ──

long t2 = [Link]();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
[Link](i); // Same object modify — naya nahi bana ← GOOD
}
[Link]("StringBuilder: " + ([Link]()-t2) + "ms");
// StringBuilder: ~5ms ← 40x FASTER!

// Rule: Loop mein String + kabhi mat karo — StringBuilder use karo!

Type 3 — StringBuffer (Thread-Safe)

StringBuffer = Bank ka shared notebook. Multiple bank tellers (threads) ek saath notebook mein likhna chahte
hain — lekin ek waqt mein sirf ek likh sakta hai (synchronized). Safe hai lekin thoda slow!

// StringBuffer — thread-safe, synchronized

// StringBuffer — StringBuilder jaisi hi — lekin thread-safe!
// Sab methods synchronized hain — ek waqt ek thread access kar sakta hai

StringBuffer sfb = new StringBuffer();

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

// StringBuilder aur StringBuffer same methods hain!

// Fark sirf thread-safety ka hai:

// ── Kab kya use karo? ──

 // String → String fixed/nahi badlega → use karo
// StringBuilder → Single thread mein modify → use karo (FAST)
// StringBuffer → Multi-thread mein modify → use karo (SAFE)

// Multi-thread demo (conceptual):

StringBuffer shared = new StringBuffer();
// Thread 1: [Link]("Hello"); // Safe!
// Thread 2: [Link](" World"); // Safe! Synchronized hai

// StringBuilder multi-thread mein:

StringBuilder unsafe = new StringBuilder();
// Thread 1 + Thread 2 ek saath → CORRUPT DATA possible!

Feature String (immutable) StringBuilder StringBuffer

Mutable? ❌ Immutable (nahi ✅ Mutable (badl sakta) ✅ Mutable (badl sakta)
badlta)
Thread-safe? ✅ Yes ❌ No ✅ Yes (synchronized)
Performance Slow (new object Fast Slower (sync overhead)
banata)
Use karo jab? String fixed ho Single thread modify Multi-thread modify
Memory pool? ✅ String Pool use karta ❌ Pool nahi ❌ Pool nahi
+ operator? New object banata har append() use karo append() use karo
baar
Package [Link] [Link] [Link]
Common methods length,charAt,substring append,insert,delete append,insert,delete

🔷 Common String Methods — Cheatsheet

// Common String methods — full cheatsheet

String s = " Hello, Java World! ";

// ── Length ──
[Link]([Link]()); // 22

// ── Case ──
[Link]([Link]()); // " HELLO, JAVA WORLD! "
[Link]([Link]()); // " hello, java world! "

// ── Trim (leading/trailing spaces hataao) ──

[Link]([Link]()); // "Hello, Java World!"
[Link]([Link]()); // Same — Unicode aware (Java 11+)

// ── charAt aur substring ──

[Link]([Link]().charAt(0)); // H
[Link]([Link]().substring(7)); // Java World!
[Link]([Link]().substring(7, 11)); // Java

// ── Search ──
[Link]([Link]("Java")); // true
[Link]([Link]("Java")); // 9 (first occurrence)
[Link]([Link]("l")); // 14
[Link]([Link](" H")); // true
[Link]([Link]("! ")); // true

// ── Replace ──
[Link]([Link]().replace("Java", "Python"));
// Hello, Python World!
[Link]([Link]().replaceAll("[aeiou]", "*"));
// H*ll*, J*v* W*rld! (regex — sab vowels replace)

// ── Split ──
String csv = "Rakesh,Priya,Ajay,Sunita";
String[] names = [Link](",");
[Link]([Link]); // 4
[Link](names[1]); // Priya

// ── Join ──
String joined = [Link](" | ", "Java", "Python", "C++");
[Link](joined); // Java | Python | C++

// ── isEmpty aur isBlank ──

[Link]("".isEmpty()); // true
[Link](" ".isEmpty()); // false (spaces hain)
[Link](" ".isBlank()); // true (Java 11 — only spaces)
 // ── String to int / int to String ──
int num = [Link]("42"); // String → int
String str = [Link](42); // int → String
String str2 = [Link](42); // int → String

🏗️Complete Project — Student Registration System

String, StringBuilder, == vs equals — sab ek saath ek real project mein:

// Complete Project — Registration System with String, StringBuilder, equals

// Student Registration System — String concepts demo
import [Link];

public class RegistrationSystem {

// ── Username validation — equals use karo ──

static boolean isValidUser(String[] users, String input) {
for (String user : users) {
if ([Link](input)) return true; // .equals ✅
}
return false;
}

// ── Report generate — StringBuilder use karo ──

static String generateReport(String[] students, int[] marks) {
StringBuilder report = new StringBuilder(); // Fast!
[Link]("=== STUDENT REPORT ===").append("\n");
[Link]("-".repeat(30)).append("\n");

for (int i = 0; i < [Link]; i++) {

[Link]([Link]("%-15s : %d%n",
students[i], marks[i]));
}
[Link]("-".repeat(30));
return [Link](); // String mein convert karo at end
}

// ── Name format karo — String methods use karo ──

static String formatName(String raw) {
if (raw == null || [Link]()) return "Unknown";
raw = [Link]().toLowerCase();
return [Link]([Link](0)) + [Link](1);
}

// ── Pool demo — literal vs new ──

static void poolDemo() {
[Link]("\n── String Pool Demo ──");
String a = "Admin";
String b = "Admin";
String c = new String("Admin");

[Link]("a == b (literals): " + (a == b)); // true

[Link]("a == c (new): " + (a == c)); // false
[Link]("[Link](c): " + ([Link](c))); // true
[Link]("Lesson: Hamesha .equals() use karo!");
}

public static void main(String[] args) {

// Registered users
String[] users = {"rakesh", "priya", "ajay", "sunita"};

// Login test
[Link]("=== Login Test ===");
String[] attempts = {"RAKESH", "PRIYA", "Unknown", "ajay"};
for (String attempt : attempts) {
boolean valid = isValidUser(users, attempt);
[Link](attempt + " → " + (valid ? "✅ Login OK" : "❌ Invalid"));
}

// Name formatting
[Link]("\n=== Name Formatting ===");
String[] rawNames = {" RAKESH KUMAR ", "priya", null, " ", "AJAY"};
for (String n : rawNames) {
[Link]("'" + n + "' → '" + formatName(n) + "'");
}
 // Report generation
[Link]("\n" + generateReport(
new String[]{"Rakesh", "Priya", "Ajay", "Sunita"},
new int[]{85, 92, 78, 88}
));

poolDemo();
}
}

// Output:
// === Login Test ===
// RAKESH → ✅ Login OK (equalsIgnoreCase works!)
// PRIYA → ✅ Login OK
// Unknown → ❌ Invalid
// ajay → ✅ Login OK
//
// === Name Formatting ===
// ' RAKESH KUMAR ' → 'Rakesh kumar'
// 'priya' → 'Priya'
// 'null' → 'Unknown'
// ' ' → 'Unknown'
//
// === STUDENT REPORT ===
// Rakesh : 85
// Priya : 92
// ...

⚠️Common Galtiyan — Dhyan Do!

// Common galtiyan — ==, null, loop +, immutability, isEmpty

// ── Galti 1: String compare mein == use kiya ──
String s1 = new String("Java");
String s2 = new String("Java");
// ❌ GALAT:
if (s1 == s2) [Link]("equal"); // Print nahi hoga!
// ✅ SAHI:
 if ([Link](s2)) [Link]("equal"); // equal ✅

// ── Galti 2: Null String par .equals() call kiya ──

String user = null;
// ❌ GALAT — NullPointerException!
// if ([Link]("admin")) ...
// ✅ SAHI — literal pehle:
if ("admin".equals(user)) [Link]("match"); // No NPE!

// ── Galti 3: Loop mein + operator se String build kiya ──

// ❌ SLOW — har iteration mein naya String!
String result = "";
for (int i = 0; i < 1000; i++) result = result + i;
// ✅ FAST — StringBuilder use karo
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) [Link](i);
String result2 = [Link]();

// ── Galti 4: Immutability bhool gaye ──

String name = "rakesh";
[Link](); // ❌ Kuch nahi hua! Return value ignore kiya
[Link](name); // rakesh ← nahi badla!
// ✅ SAHI — return value capture karo
name = [Link](); // Assign back karo
[Link](name); // RAKESH ✅

// ── Galti 5: isEmpty() vs isBlank() confuse kiya ──

String spaces = " ";
[Link]([Link]()); // false ← spaces hain!
[Link]([Link]()); // true ← sirf spaces (Java 11+)
// Validation mein isBlank() better hai!

📋 Quick Revision — Exam ke Liye

10 Sabse Zaroori Baatein

• 1. String kya hai: [Link] class — char sequence — immutable
• 2. Immutable matlab: badal nahi sakta — modification pe naya object banta hai
 • 3. String literal: "Hello" → String Pool mein jaata hai — reuse hota hai
• 4. new String(): Pool bypass — alag Heap object — == se compare nahi milega
• 5. String Pool: Heap ka special area — same content ke liye ek hi object
• 6. == (address): Same object? — String mein unreliable — avoid karo
• 7. .equals(): Same content? — HAMESHA yahi use karo String compare mein
• 8. equalsIgnoreCase(): Case ignore — login/search mein useful
• 9. StringBuilder: Mutable — loop mein use karo — String + se fast
• 10. StringBuffer: StringBuilder jaisa — thread-safe — multi-thread mein use karo

Topic Rule / Syntax Easy Yaad Karo

String kya hai Immutable class — char[] ka Ek baar likha — nahi badla!
wrapper
String literal String s = "Hello" Pool mein jaata hai — reuse hota
new String() String s = new String("Hello") Pool bypass — alag Heap object
String Pool Heap ka ek special area Ek baar banao — sab share karo
== (address check) Same object? → true/false Patna ka address vs Patna ka content
.equals() Same content? → true/false Hamesha yeh use karo String mein!
equalsIgnoreCase() Case ignore karke compare "Java".equalsIgnoreCase("java") = true
intern() Pool mein daalo new String ko Pool ka membership dilao
Immutable kyun? Security + Thread safety + Passport copy nahi hoti — original rehta
Pool reuse
StringBuilder Mutable — append() se Loop mein + use mat karo — slow hoga
modify karo

Java Notes — String • String Pool • == vs .equals() • Immutability • StringBuilder • StringBuffer | Hinglish
Edition 🇮🇳