Java Strings ஏன் immutable, மற்றும் StringBuilder எதற்காக?

Question

Accepted Answer

Java-வில், **String objects immutable** — ஒருமுறை உருவாக்கப்பட்டால், அவற்றின் உள்ளடக்கங்கள் ஒருபோதும் மாற முடியாது. ஒரு String-ஐ மாற்றுவது போல் தோன்றும் எந்தவொரு செயல்பாடும் உண்மையில் ஒரு **புதிய** String-ஐ உருவாக்குகிறது. திறமையான மீண்டும் மீண்டும் மாற்றத்திற்கு, நீங்கள் அதற்குப் பதிலாக **StringBuilder**-ஐ பயன்படுத்துகிறீர்கள்.

## Strings immutable

```java
String s = "Hello";
s.concat(" World");   // returns a NEW string; `s` is unchanged
System.out.println(s); // "Hello" — the original is untouched

s = s + " World";      // creates a NEW string and rebinds s; old "Hello" is discarded
```

`concat`, `toUpperCase`, `replace`, மற்றும் `substring` போன்ற methods அனைத்தும் **புதிய** String objects-ஐ திருப்பித் தருகின்றன — original ஒருபோதும் மாற்றப்படுவதில்லை.

## ஏன் immutability? நன்மைகள்

```text
✓ Thread safety   — immutable objects are safe to share across threads (no locking)
✓ String pool     — identical string literals can be SHARED/reused (memory savings)
✓ Hashing/keys    — safe as HashMap keys (hashCode can be cached, never changes)
✓ Security        — strings used for filenames, URLs, credentials can't be altered
                    after a security check
```

Immutability Strings-ஐ இயல்பாகவே thread-safe ஆக்குகிறது, JVM-ஐ String pool மூலம் literals-ஐ **intern** (பகிர) அனுமதிக்கிறது, மேலும் அவற்றை map keys ஆக நம்பகமானதாக்குகிறது (அவற்றின் hash ஒருபோதும் மாறாது).

## செயல்திறன் சிக்கல்: loops-இல் string concatenation

```java
// ❌ creates a NEW string object on EVERY iteration — O(n²), wasteful
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i;   // each += allocates a whole new string
}
```

ஒவ்வொரு `+=` ஒரு புதிய String-ஐ உருவாக்குவதால் (முந்தைய அனைத்து உள்ளடக்கத்தையும் நகலெடுத்து), ஒரு loop-இல் strings-ஐ உருவாக்குவது quadratic ஆகும் மற்றும் ஏராளமான garbage-ஐ உருவாக்குகிறது.

## StringBuilder — திறமையான mutable strings

```java
// ✅ StringBuilder mutates an internal buffer — O(n), efficient
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);   // modifies the buffer in place, no new objects
}
String result = sb.toString();   // convert to a String once, at the end
```

`StringBuilder` என்பது characters-இன் mutable sequence ஆகும் — `append`/`insert`/`delete` புதிய objects-ஐ உருவாக்காமல் அதன் internal buffer-ஐ மாற்றுகிறது, இது loop-அடிப்படையிலான கட்டமைப்பை திறமையாக்குகிறது. (`StringBuffer` என்பது thread-safe ஆனால் மெதுவான variant ஆகும்.)

## இது ஏன் முக்கியம்

String immutability என்பது முக்கியமான விளைவுகளுடன் கூடிய ஒரு வரையறுக்கும் Java பண்பு: இது thread safety-ஐ வழங்குகிறது, memory-சேமிக்கும் string pool-ஐ சாத்தியமாக்குகிறது, மேலும் Strings-ஐ map keys ஆகவும் security சூழல்களிலும் பாதுகாப்பாக்குகிறது — ஆனால் loops-இல் naive string concatenation ஒரு உண்மையான **செயல்திறன் ஆபத்து** (O(n²), அதிகப்படியான garbage) என்பதையும் இது குறிக்கிறது.

மீண்டும் மீண்டும் மாற்றத்திற்கு **StringBuilder**-ஐ பயன்படுத்த வேண்டும் என்பதை அறிவது immutability-ஐ புரிந்துகொள்வதிலிருந்து நேரடியாக வரும் ஒரு நடைமுறை அவசியம்.

இந்த இணைப்பு — Strings ஏன் immutable (safety, sharing, hashing) என்பதும், எப்போது StringBuilder-க்கு மாற வேண்டும் (loop concatenation) என்பதும் — ஒரு பொதுவான interview தலைப்பும், அடிக்கடி நிகழும் நிஜ-உலக செயல்திறன் சரிசெய்தலும் ஆகும்.