☕ Java Programming — Easy Notes

String Methods in Java

substring • split • intern • charAt • indexOf • replace • matches
Colorful Index Rulers • Split Visuals • Step-by-Step Code • Real Projects • Interview Prep

🇮🇳 Hinglish Notes — Ruler/Scissor Analogy | Index Diagrams | Split Visuals | Easy

Language

🔷 Pehle Samjho — String ka Index Kya Hota

Hai?
Har String ek sequence of characters hai. Har character ka apna INDEX (position) hota hai — 0 se
shuru hota hai. Yeh index hi sabse important hai — substring, charAt, indexOf — sab index par based
hain!

String = Train ke dabba. Pehla dabba index 0, doosra index 1... Koi bhi dabba dhundho — seedha
index batao — mil jaayega! charAt(2) = 3rd dabba ka character.

"Hello, Java!" — Har character ka index

0 1 2 3 4 5 6 7 8 9 10 11

H e l l o , · J a v a !
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

📌 Index ✅ Index ALWAYS 0 se shuru hota hai — pehla character index 0 par hai
Rules —
✅ Last index = length - 1 ("Hello" mein last index = 4)
Yaad
Rakho ✅ Negative index allowed NAHI — arr[-1] → Exception
✅ Positive index: 0 = pehla, 1 = doosra, 2 = teesra ...
✅ Counting always LEFT to RIGHT

🔷 Method 1 — charAt(index)
[Link](int index) → returns: char

Ek specific position (index) ka character return karta hai — ek char

 charAt = Train mein specific dabba dhundho. 'Mujhe 3rd dabba chahiye' → charAt(2). Remember:
0-based index hai!

"Java" — charAt examples

0 1 2 3

J a v a
-4 -3 -2 -1

// charAt(index) — ek character lo
String s = "Java";

[Link]([Link](0)); // J ← pehla character

[Link]([Link](1)); // a
[Link]([Link](2)); // v
[Link]([Link](3)); // a ← aakhri character

// length - 1 = last index

[Link]([Link]([Link]()-1)); // a ← last char

// ❌ GALAT — StringIndexOutOfBoundsException
// [Link](4); // Length 4 hai — valid index 0,1,2,3 sirf
// [Link](-1); // Negative allowed nahi

// ── Practical use — vowel check ──

String word = "Rakesh";
[Link]("Characters:");
for (int i = 0; i < [Link](); i++) {
char ch = [Link](i);
String type = "aeiouAEIOU".indexOf(ch) >= 0 ? "vowel" : "consonant";
[Link](" [" + i + "] '" + ch + "' → " + type);
}
// [0] 'R' → consonant
// [1] 'a' → vowel
// [2] 'k' → consonant ...

// ── First aur Last character ──

String name = "Priya";
char first = [Link](0); // P
char last = [Link]([Link]()-1);// a
[Link](first + "..." + last); // P...a
🔷 Method 2 — indexOf() aur lastIndexOf()
[Link](String str) → returns: int

Pehli baar str kahan mila? → index return karta hai. Nahi mila → -1

indexOf = Library mein book dhundho. 'Harry Potter pehli baar kahan hai?' — mila toh shelf number
batao — nahi mila toh -1 (not found).

"Hello Java Hello" — indexOf examples

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

H e l l o · J a v a · H e l l o
-16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

// indexOf() aur lastIndexOf() — position dhundho

String s = "Hello Java Hello";
// 0123456789...

// ── indexOf() — PEHLI occurrence ──

[Link]([Link]("Hello")); // 0 ← index 0 par mila
[Link]([Link]("Java")); // 6 ← index 6 par mila
[Link]([Link]("Python")); // -1 ← nahi mila!
[Link]([Link]('a')); // 7 ← char bhi search kar sakte

// ── indexOf(str, fromIndex) — specific jagah se shuru karo ──

[Link]([Link]("Hello", 1)); // 11 ← index 1 se dhundo
// Ab index 0 wala 'Hello' skip ho gaya — index 11 wala mila

// ── lastIndexOf() — AAKHRI occurrence ──

[Link]([Link]("Hello")); // 11 ← last occurrence
[Link]([Link]('l')); // 13 ← last 'l'

// ── Practical: File extension nikalo ──

String filename = "project_report.docx";
int dotIndex = [Link]('.');
String extension = [Link](dotIndex + 1);
[Link]("Extension: " + extension); // docx

// ── Check karo string mein kuch hai ya nahi ──

String email = "rakesh@[Link]";
if ([Link]('@') != -1) {
[Link]("Valid email format!");
}
 // ── Count occurrences manually ──
String text = "banana";
char find = 'a';
int count = 0, idx = 0;
while ((idx = [Link](find, idx)) != -1) {
count++;
idx++;
}
[Link]("'a' count in 'banana': " + count); // 3

🔷 Method 3 — substring() — Sabse Important!

[Link](int beginIndex) / substring(int begin, int end) →
returns: String

String ka ek HISSA nikalo. begin se end-1 tak. End index EXCLUSIVE hai — woh character nahi
aata!

substring = Roti (bread) ka tukda kaatna. Roti = 'Hello World'. Kaatna chahte ho index 6 se 11 tak?
→ 'World' milega. End index par jo hai woh nahi aata — ek pehle cut hota hai!

3.1 — Index Ruler ke Saath Samjho

"Hello World" — substring examples
0 1 2 3 4 5 6 7 8 9 10

H e l l o · W o r l d
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

0 1 2 3 4 5 6 7 8 9 10

H e l l o · W o r l d
substring(6, 11) → "World" (index 6 to 10 — end 11 exclusive)

// substring() — basic usage aur patterns

String s = "Hello World";
// 01234567890 (length = 11)

// ── substring(beginIndex) — begin se end tak ──

[Link]([Link](0)); // Hello World ← sab
[Link]([Link](6)); // World ← index 6 se end
[Link]([Link](3)); // lo World ← index 3 se end
 // ── substring(begin, end) — begin to end-1 ──
[Link]([Link](0, 5)); // Hello ← index 0,1,2,3,4
[Link]([Link](6, 11)); // World ← index 6,7,8,9,10
[Link]([Link](2, 8)); // llo Wo ← index 2 to 7

// ⚠️ END INDEX EXCLUSIVE HAI — yeh bhoolna mat!

// substring(0, 5) means: 0,1,2,3,4 → 5 nahi aata!

// ── Galtiyan ──
// [Link](-1, 5); // ❌ Negative index — Exception
// [Link](5, 3); // ❌ begin > end — Exception
// [Link](0, 20); // ❌ end > length — Exception

// ── Useful patterns ──
// Pehle N characters:
[Link]([Link](0, 5)); // Hello (first 5)

// Last N characters:
[Link]([Link]([Link]()-5));// World (last 5)

// Middle nikalo:
[Link]([Link](3, 8)); // lo Wo

3.2 — substring() Practical Examples

// substring() — practical real-world examples
// ── Practical 1: Email se username aur domain nikalo ──
String email = "[Link]@[Link]";
int atIdx = [Link]('@');

String username = [Link](0, atIdx); // [Link]

String domain = [Link](atIdx + 1); // [Link]
[Link]("Username: " + username);
[Link]("Domain: " + domain);

// ── Practical 2: Date format badlo ──

String date = "2024-03-15"; // YYYY-MM-DD
String year = [Link](0, 4); // 2024
String month = [Link](5, 7); // 03
String day = [Link](8, 10); // 15
[Link](day + "/" + month + "/" + year); // 15/03/2024

// ── Practical 3: File name se extension nikalo ──

 String file = "[Link]";
int dot = [Link]('.');
String name = [Link](0, dot); // document
String ext = [Link](dot + 1); // pdf
[Link](name + " is a " + ext + " file");

// ── Practical 4: Phone number mask karo ──

String phone = "9876543210";
String masked = "XXXXXX" + [Link](6); // XXXXXX3210
[Link]("Masked: " + masked);

// ── Practical 5: URL se domain nikalo ──

String url = "[Link]
int start = [Link]("://") + 3; // after "://"
int end = [Link]('/', start); // next '/' after domain
String domain2 = [Link](start, end);
[Link]("Domain: " + domain2); // [Link]

🔷 Method 4 — split() — String ke Tukde Karo

[Link](String regex) / split(String regex, int limit) → returns:
String[]

String ko delimiter ke basis par tukdo mein kaato → String[] return karta hai

split = Scissors se roti (bread) kaatna. 'Rakesh,Priya,Ajay' ko comma se kaato → teen alag tukde.
Delimiter (comma) khud nahi aata result mein — sirf tukde aate hain!

4.1 — Basic split() — Comma, Space, Pipe

"Rakesh,Priya,Ajay,Sunita".split(",") → 4 parts
[0] [1] [2] [3]

"Rakesh" "Priya" "Ajay" "Sunita"

// split() basic — comma, space, pipe, dot

// ── Comma se split ──
String csv = "Rakesh,Priya,Ajay,Sunita";
String[] names = [Link](",");
[Link]([Link]); // 4
[Link](names[0]); // Rakesh
[Link](names[2]); // Ajay
 for (String name : names) {
[Link]("Hello, " + name + "!");
}

// ── Space se split ──
String sentence = "Java is awesome language";
String[] words = [Link](" ");
[Link]([Link]); // 4
[Link](words[0]); // Java
[Link](words[3]); // language

// ── Pipe (|) se split ── DHYAN DO: | regex mein special character hai!
String data = "Rakesh|85|IT|Patna";
String[] parts = [Link]("\\|"); // \\| — escape karo!
[Link](parts[0]); // Rakesh
[Link](parts[1]); // 85

// ── Dot (.) se split — DHYAN DO: . regex mein 'koi bhi char' hai! ──
String filename = "[Link]";
String[] segments = [Link]("\\."); // \\. — escape karo!
[Link]([Link](segments));
// [report, final, docx]

// ── Multiple spaces ──
String messy = "Java is cool";
String[] clean = [Link]("\\s+"); // \s+ = ek ya zyada whitespace
[Link]([Link](clean)); // [Java, is, cool]

4.2 — split() with Limit

"one:two:three:four:five".split(":") → 3 parts
[0] [1] [2]

"one" "two" "three:four:five"

Limit parameter batata hai — maximum kitne tukde chahiye. Baaki sab LAST element mein chale jaate
hain:

// split() with limit — max tukde

String s = "one:two:three:four:five";

// Bina limit — sab tukde

 String[] all = [Link](":");
[Link]([Link](all));
// [one, two, three, four, five] → 5 parts

// Limit = 3 — max 3 tukde, baaki last mein

String[] three = [Link](":", 3);
[Link]([Link](three));
// [one, two, three:four:five] → 3 parts!
// Last part mein baaki sab aa gaya!

// Limit = 1 — koi split nahi — poora string ek element

String[] one = [Link](":", 1);
[Link]([Link](one));
// [one:two:three:four:five] → 1 part (no split)

// Limit = -1 — trailing empty strings bhi aate hain

String trailing = "a,b,c,,";
[Link]([Link]([Link](",")));
// [a, b, c] ← trailing empty strings remove ho gaye!
[Link]([Link]([Link](",",-1)));
// [a, b, c, , ] ← trailing empty strings bhi aaye!

// ── Practical: CSV parse karo (first 2 fields only) ──

String record = "101,Rakesh Kumar,85,Patna,India";
String[] fields = [Link](",", 3);
[Link]("ID: " + fields[0]); // 101
[Link]("Name: " + fields[1]); // Rakesh Kumar
[Link]("Rest: " + fields[2]); // 85,Patna,India

4.3 — split() with Regex

// split() with regex — powerful patterns
// split() regex support karta hai — powerful!

// ── Digits pe split ──
String s1 = "abc123def456ghi";
String[] parts = [Link]("[0-9]+"); // ek ya zyada digit pe split
[Link]([Link](parts));
// [abc, def, ghi]

// ── Multiple delimiters ──
String s2 = "Rakesh,Priya;Ajay|Sunita";
String[] names = [Link]("[,;|]"); // comma, semicolon, pipe — koi bhi
[Link]([Link](names));
// [Rakesh, Priya, Ajay, Sunita]

// ── Whitespace (\s) ──
String s3 = "Hello\tWorld\nJava"; // tab aur newline bhi
String[] words = [Link]("\\s");
[Link]([Link](words));
// [Hello, World, Java]

// ── Practical: Words count karo ──

String para = "Java is a powerful language. Java is fun!";
String[] wordArr = [Link]("\\s+");
[Link]("Word count: " + [Link]); // 8

// ── Practical: CSV line parse karo ──

String csvLine = " Rakesh , 92 , Patna ";
String[] cols = [Link](",");
for (int i = 0; i < [Link]; i++) {
cols[i] = cols[i].trim(); // har col trim karo
}
[Link]([Link](cols));
// [Rakesh, 92, Patna]

🔷 Method 5 — intern() — Pool Mein Daal Do

[Link]() → returns: String

String ko String Constant Pool mein daalta hai. Agar pool mein already same string hai — wahi
reference return karta hai.

intern() = Library membership. 'Harry Potter' ghar mein rakha hai — lekin library register mein
register karo. Ab library se bhi same book milegi — alag copy nahi kharidni. intern() se pool
membership milti hai!

// intern() — pool mein register karo, memory save karo

// intern() — new String() ko pool mein laao

// ── Problem: new String() pool bypass karta hai ──

String s1 = "Java"; // Pool mein
String s2 = new String("Java"); // Heap par — alag object
[Link](s1 == s2); // false ← alag objects
 // ── Solution: intern() use karo ──
String s3 = new String("Java").intern(); // Pool mein daal do!
[Link](s1 == s3); // true! ← ab same pool object

// ── intern() kaise kaam karta hai ──

// 1. Pool check karta hai — "Java" already pool mein hai?
// 2. Hai → same reference return karta hai
// 3. Nahi → pool mein add karta hai → phir reference return

// ── Memory saving demo ──

String a = new String("Hello").intern();
String b = new String("Hello").intern();
String c = new String("Hello").intern();
[Link](a == b); // true — sab same pool object!
[Link](b == c); // true

// ── intern() practically kab use karo? ──

// 1. Bahut saari duplicate strings hain — memory save karo
// 2. String comparison == se fast karna ho (reference check cheaper)
// 3. Large dataset — same strings baar baar aati hain

// ── Example: 1000 students — same city names ──

String[] cities = new String[5];
// Sab "Patna" hain — lekin alag new objects
cities[0] = new String("Patna").intern(); // Pool mein register
cities[1] = new String("Patna").intern(); // Same pool reference!
cities[2] = new String("Patna").intern(); // Same!
[Link](cities[0] == cities[1]); // true — memory save!

// ── When NOT to use intern() ──

// ❌ Jab strings zyada alag hain — pool bada ho jaata hai
// ❌ Short-lived strings ke liye — overhead zyada
// ✅ Long-running apps mein repeated strings ke liye

🔷 Method 6 — replace(), replaceAll(),

replaceFirst()
replace(old, new) / replaceAll(regex, new) / replaceFirst(regex,
new) → returns: String

String ke andar kuch replace karo — naya String return karta hai (original nahi badlta!)
// replace(), replaceAll(), replaceFirst() — sab replace methods
String s = "Hello Java Hello Java";

// ── replace() — exact string replace, sab occurrences ──

[Link]([Link]("Java", "Python"));
// Hello Python Hello Python ← dono "Java" replace ho gaye

// ── replace() — char bhi replace kar sakte ──

[Link]("Rakesh".replace('a', '@'));
// R@kesh ← sab 'a' replace ho gaye

// ── replaceFirst() — sirf PEHLA occurrence ──

[Link]([Link]("Java", "Python"));
// Hello Python Hello Java ← sirf pehla replace!

// ── replaceAll() — regex ke saath, sab occurrences ──

String mixed = "R@k3sh K#m@r 85";
[Link]([Link]("[0-9]", "#"));
// R@k#sh K#m@r ## ← sab digits replace

[Link]([Link]("[^a-zA-Z ]", ""));

// Rksh Kmr ← sirf letters aur space rakho, baaki remove

// ── Practical examples ──
// Phone format karo:
String phone = "(091) 9876-543210";
String digits = [Link]("[^0-9]", ""); // sirf digits rakho
[Link](digits); // 09198765432101

// HTML tags hataao:

String html = "<b>Hello</b> <i>Java</i>";
[Link]([Link]("<.*?>", "")); // Hello Java

// Multiple spaces hataao:

String messy = "Java is awesome";
[Link]([Link]("\\s+", " ")); // Java is awesome

// Password mein special char check:

String pass = "Rakesh@123";
boolean hasSpecial = ![Link]("[^@#$%!]", "").isEmpty();
[Link]("Has special: " + hasSpecial); // true
🔷 Method 7 — matches() — Pattern Check Karo
[Link](String regex) → returns: boolean

POORA String ek pattern se match karta hai? → true/false. Partial match nahi — entire string match
hona chahiye!

matches() = Aadhar card verify karna. Aadhar number exactly 12 digits ka hona chahiye — ek bhi
zyada ya kam → fail! matches() bhi exactly poora string check karta hai — beech mein kuch extra
allow nahi.

// matches() — regex pattern se validate karo

// ── Basic matches() ──
[Link]("12345".matches("[0-9]+")); // true — sirf digits
[Link]("12a45".matches("[0-9]+")); // false — 'a' hai!
[Link]("HELLO".matches("[A-Z]+")); // true — sab caps
[Link]("Hello".matches("[A-Z]+")); // false — 'e' lowercase

// ── Practical validations ──

// Phone number validate karo (10 digits):

String phone = "9876543210";
boolean validPhone = [Link]("[0-9]{10}");
[Link]("Valid phone: " + validPhone); // true

// Email validate karo (basic):

String email = "rakesh@[Link]";
boolean validEmail = [Link]("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-
Z]{2,}");
[Link]("Valid email: " + validEmail); // true

// PIN code validate (6 digits):

String pin = "800001";
[Link]("Valid PIN: " + [Link]("[0-9]{6}")); // true

// Name validate (sirf letters aur space):

String name = "Rakesh Kumar";
[Link]("Valid name: " + [Link]("[A-Za-z ]+")); // true

// Password strength check:

String pass = "Rakesh@123";
boolean strong = [Link]("(?=.*[A-Z])(?=.*[0-9])(?=.*[@#$]).{8,}");
// (?=.*[A-Z]) = ek uppercase, (?=.*[0-9]) = ek digit, (?=.*[@#$]) = ek
special
[Link]("Strong password: " + strong);
 // ⚠️ matches() POORA string check karta hai:
[Link]("Hello123".matches("[0-9]+")); // false!
// Contains digits but not ONLY digits
// contains() ya indexOf() use karo partial check ke liye

🔷 Method 8 — Aur Important Methods

contains(), startsWith(), endsWith()
// contains(), startsWith(), endsWith()
String s = "Hello Java World";

// ── contains() ──
[Link]([Link]("Java")); // true
[Link]([Link]("Python")); // false

// ── startsWith() ──
[Link]([Link]("Hello")); // true
[Link]([Link]("Java")); // false
[Link]([Link]("Java", 6)); // true ← index 6 se check

// ── endsWith() ──
[Link]([Link]("World")); // true
[Link]([Link]("Java")); // false

// ── Practical: File type check ──

String file = "[Link]";
if ([Link](".pdf")) [Link]("PDF file!");
if ([Link](".docx") || [Link](".doc"))
[Link]("Word file!");

// ── URL check ──
String url = "[Link]
if ([Link]("https")) [Link]("Secure URL!");

trim(), strip(), toUpperCase(), toLowerCase(), length()

// trim, strip, case methods, length, isEmpty, format, join, valueOf
// ── trim() vs strip() ──
String s = " Hello World ";
[Link]("'" + [Link]() + "'"); // 'Hello World'
[Link]("'" + [Link]() + "'"); // 'Hello World' (Java 11+, Unicode
aware)

// strip() variants:
[Link]([Link]()); // "Hello World " ← sirf aage se
[Link]([Link]()); // " Hello World" ← sirf peeche se

// ── toUpperCase() / toLowerCase() ──
[Link]("hello".toUpperCase()); // HELLO
[Link]("HELLO".toLowerCase()); // hello

// Case-insensitive comparison:
String input = "ADMIN";
if ([Link]().equals("admin")) [Link]("Admin found!");

// ── length() ──
[Link]("Java".length()); // 4
[Link]("".length()); // 0
[Link](" ".length()); // 2 (spaces count!)

// ── isEmpty() vs isBlank() ──
[Link]("".isEmpty()); // true
[Link](" ".isEmpty()); // false (spaces hain!)
[Link](" ".isBlank()); // true (Java 11 — only whitespace)

// ── [Link]() / formatted() ──
String formatted = [Link]("Name: %-10s | Marks: %d", "Rakesh", 85);
[Link](formatted); // Name: Rakesh | Marks: 85

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

// Join from array:

String[] langs = {"Java", "Python", "C++"};
[Link]([Link](", ", langs)); // Java, Python, C++

// ── valueOf() — kuch bhi String mein convert karo ──

[Link]([Link](42)); // "42"
[Link]([Link](3.14)); // "3.14"
[Link]([Link](true)); // "true"
[Link]([Link]('A')); // "A"
📊 String Methods — Complete Reference Table
Method Syntax / Example Kya return karta?

charAt(i) "Java".charAt(1) char 'a'

indexOf(s) "Hello".indexOf("ll") int 2

indexOf(s,from) [Link]("a",3) int — index 3 ke baad

lastIndexOf(s) "banana".lastIndexOf('a') int 5

substring(b) "Hello".substring(2) String "llo"

substring(b,e) "Hello".substring(1,4) String "ell" (end exclusive)

split(regex) "a,b,c".split(",") String[] {"a","b","c"}

split(r,limit) "a:b:c".split(":",2) String[] {"a","b:c"}

intern() new String("x").intern() String from pool

replace(old,new) "java".replace('a','@') String "j@v@"

replaceAll(r,s) [Link]("[0-9]","#") String — regex replace

replaceFirst(r,s) [Link]("a","@") String — first only

matches(regex) "123".matches("[0-9]+") boolean true

contains(s) "Hello".contains("ell") boolean true

startsWith(s) "Hello".startsWith("He") boolean true

endsWith(s) "[Link]".endsWith(".pdf") boolean true

toLowerCase() "JAVA".toLowerCase() String "java"

toUpperCase() "java".toUpperCase() String "JAVA"

trim() " Hi ".trim() String "Hi"

strip() " Hi ".strip() String "Hi" (Java 11+)

length() "Java".length() int 4

isEmpty() "".isEmpty() boolean true

isBlank() " ".isBlank() boolean true (Java 11+)

[Link](x) [Link](42) String "42"

[Link](d,..) [Link](",","a","b") String "a,b"

[Link](..) [Link]("%d",42) String "42"

toCharArray() "Java".toCharArray() char[] {'J','a','v','a'}

compareTo(s) "A".compareTo("B") int negative (A before B)

equalsIgnoreCase() "JAVA".equalsIgnoreCase("java boolean true

")
 Complete Project — Student Data Processor
Ek complete project jisme saare String methods ek saath use honge — CSV parsing, validation,
formatting:

// Complete Project — CSV parse, validate, format, username generate

// Student Data Processor — All String methods in action
import [Link];

public class DataProcessor {

// ── Email validate karo ──

static boolean isValidEmail(String email) {
if (email == null || [Link]()) return false;
return [Link]("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]
{2,}");
}

// ── Phone validate karo ──

static boolean isValidPhone(String phone) {
if (phone == null) return false;
String digits = [Link]("[^0-9]", "");
return [Link]("[6-9][0-9]{9}"); // Indian mobile number
}

// ── Name format karo ──

static String formatName(String raw) {
if (raw == null || [Link]()) return "Unknown";
String[] parts = [Link]().toLowerCase().split("\\s+");
StringBuilder sb = new StringBuilder();
for (String part : parts) {
[Link]([Link]([Link](0)))
.append([Link](1))
.append(" ");
}
return [Link]().trim();
}

// ── CSV record parse karo ──

static void processCSVRecord(String line) {
// Format: ID,Name,Email,Phone,City
String[] fields = [Link](",", 5); // max 5 parts
if ([Link] < 5) {
[Link](" Invalid record: " + line);
return;
 }

String id = fields[0].trim();
String name = formatName(fields[1]);
String email = fields[2].trim().toLowerCase();
String phone = fields[3].trim();
String city = fields[4].trim();

[Link](" ID: " + id);

[Link](" Name: " + name);
[Link](" Email: " + email + " " +
(isValidEmail(email)?"✅":"❌"));
[Link](" Phone: " + phone + " " +
(isValidPhone(phone)?"✅":"❌"));
[Link](" City: " + city);
}

// ── Username generate karo ──

static String generateUsername(String fullName, int id) {
String[] parts = [Link]().split("\\s+");
String first = parts[0].toLowerCase().substring(0, [Link](3,
parts[0].length()));
String last = [Link]>1 ? parts[[Link]-1].toLowerCase() :
"";
return first + last + id;
}

public static void main(String[] args) {

[Link]("=== Student Data Processor ===");

// CSV data
String[] records = {
"101, rakesh kumar , rakesh@[Link] , 9876543210 , Patna",
"102,PRIYA SHARMA,priya@[Link],8765432109,Delhi",
"103, ajay verma ,invalid-email,1234567890,Mumbai",
"104,sunita devi,sunita@[Link],7654321098,Kolkata",
};

for (String rec : records) {

[Link]("\nProcessing: " + [Link](0,20) +
"...");
processCSVRecord(rec);
}

// Username generation
[Link]("\n=== Generated Usernames ===");
 String[] names = {"Rakesh Kumar", "Priya Sharma", "Ajay Verma"};
int[] ids = {101, 102, 103};
for (int i = 0; i < [Link]; i++) {
[Link](names[i] + " → " + generateUsername(names[i],
ids[i]));
}

// intern() demo
[Link]("\n=== intern() Memory Demo ===");
String city1 = new String("Patna").intern();
String city2 = new String("Patna").intern();
[Link]("Same object? " + (city1 == city2)); // true
}
}

// Output:
// Processing: 101, rakesh kumar ,...
// ID: 101
// Name: Rakesh Kumar (formatted!)
// Email: rakesh@[Link] ✅
// Phone: 9876543210 ✅
// City: Patna
//
// Processing: 103, ajay verma ...
// Email: invalid-email ❌
// Phone: 1234567890 ❌ (starts with 1 — invalid Indian mobile)
//
// Generated Usernames:
// Rakesh Kumar → rakKumar101
// Priya Sharma → priSharma102

📋 Quick Revision — Exam ke Liye

12 Sabse Zaroori Baatein
• 1. charAt(i): index i ka ek character — 0-based — last = length-1
• 2. indexOf(s): pehli occurrence ka index — nahi mila → -1
• 3. lastIndexOf(s): aakhri occurrence ka index — reverse search
• 4. substring(b): index b se end tak — naya String
• 5. substring(b,e): index b to e-1 — END EXCLUSIVE! — bhoolna mat
• 6. split(regex): String ke tukde → String[] — delimiter nahi aata result mein
• 7. split(r,limit): max limit tukde — baaki last mein chale jaate hain
 • 8. intern(): pool mein register — same content → same reference → memory save
• 9. replace(o,n): sab occurrence replace — char ya String
• 10. replaceAll(r,s): regex se replace — powerful — sab occurrence
• 11. matches(r): POORA string pattern se match? — partial nahi
• 12. Immutability: koi bhi method original String nahi badlta — return value lo!

Method Syntax Easy Yaad Karo

charAt(i) [Link](2) Index 2 ka character — ek char

indexOf(str) [Link]("Java") Pehli baar kahan mila? → index ya -1

lastIndexOf(str) [Link]("a") Aakhri baar kahan mila?

substring(s) [Link](5) Index 5 se end tak — naya String

substring(s,e) [Link](2,7) Index 2 to 6 — end exclusive!

split(regex) [Link](",") Comma se tukde karo → String[]

split(r,limit) [Link](",",3) Max 3 tukde — baaki last mein

intern() [Link]() Pool mein daal do — same reference lo

replace(old,new) [Link]("a","@") Sab occurrence replace karo

replaceAll(regex) [Link]("[0-9]","#") Regex se replace — powerful!

matches(regex) [Link]("[A-Z]+") Poora string regex se match?

contains(str) [Link]("Java") Andar hai? → true/false

startsWith(str) [Link]("Hello") Shuru aise hota hai?

endsWith(str) [Link](".txt") End aisa hota hai?

trim()/strip() [Link]() Aage-peeche ke spaces hataao

Java Notes — String Methods • charAt • indexOf • substring • split • intern • replace • matches | Hinglish Edition 🇮🇳