Java Stringsలు ఎందుకు అనిర్వచనీయమైనవి, మరియు StringBuilder ఏమిటి?

Question

Accepted Answer

Java లో, **String objects అనిర్వచనీయమైనవి** — ఒసారి సృష్టించిన తర్వాత, వాటి విషయాలు ఎప్పుడూ మారవు. String ను సవరించటానికి కనిపించే ఏదైనా ఆపరేషన్ వాస్తవానికి **కొత్త** String ను సృష్టిస్తుంది. సమర్థవంతమైన పునరావృత సవరణ కోసం, బదులుగా **StringBuilder** ను ఉపయోగిస్తారు.

## Stringsలు అనిర్వచనీయమైనవి

```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` వంటి పద్ధతులు అన్నీ **కొత్త** String objects ను రిటర్న్ చేస్తాయి — అసలు ఎప్పుడూ సవరించబడదు.

## ఎందుకు అనిర్వచనీయతა? ప్రయోజనాలు

```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
```

अनिर్वచనీయతা Stringsలను స్వాభావికంగా థ్రెడ్-సేఫ్ చేస్తుంది, JVM ను String పూల్ ద్వారా లిటరల్‌లను **intern** (షేర్) చేయడానికి అనుమతిస్తుంది, మరియు వాటిని మ్యాప్ కీలుగా విశ్వాసయోగ్యంగా చేస్తుంది (వాటి హ్యాష్ ఎప్పుడూ మారదు).

## పనితీరు సమస్య: లూప్‌లలో 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 ను సృష్టిస్తుంది (అన్ని ముందటి కంటెంట్‌ను కాపీ చేస్తుంది), లూప్‌లో strings నిర్మించడం చతుర్భుజం మరియు చాలా చెత్త ఉత్పత్తి చేస్తుంది.

## StringBuilder — సమర్థవంతమైన మిউటబల్ స్ట్రింగ్‌లు

```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` అనేది మిউటబల్ ఆక్షర శ్రేణి — `append`/`insert`/`delete` దాని అంతర్గత బఫర్‌ను సవరించుకుంటాయి కొత్త objects సృష్టించకుండా, లూప్-ఆధారిత నిర్మాణాన్ని సమర్థవంతంగా చేస్తాయి. (`StringBuffer` థ్రెడ్-సేఫ్ కానీ నెమ్మదిగా ఉండే వేరియంట్.)

## ఇది ఎందుకు ముఖ్యమైనది

String అనిర్వచనీయతা Java యొక్క నిర్వచించే లక్షణం ముఖ్యమైన పరిణామాలతో: ఇది థ్రెడ్ సేఫ్‌టీ ఇస్తుంది, మెమరీ-సేవ string పూల్‌ను ప్రారంభించుకుంటుంది, మరియు Stringsలను మ్యాప్ కీలలో మరియు సెక్యూరిటీ సందర్భాలలో సురక్షితం చేస్తుంది — కానీ ఇది అర్థం చేసుకోవడం లూప్‌లలో నిష్కపట string concatenation ఒక నిజమైన **పనితీరు విషం** (O(n²), అధిక చెత్త).

**StringBuilder** పునరావృత సవరణ కోసం ఉపయోగించాలనేది ఒక ఆచరణీయ ఆవశ్యకత అనిర్వచనీయతను అర్థం చేసుకోవడం నుండి నేరుగా వస్తుంది.

ఈ కలయిక — *ఎందుకు* Stringsలు అనిర్వచనీయమైనవి (సేఫ్‌టీ, షేరింగ్, హ్యాషింగ్) మరియు *ఎప్పుడు* StringBuilder కి స్విచ్ చేయాలి (లూప్ concatenation) — ఇంటర్‌వ్యూ విషయం మరియు తరచుగా వాస్తవ-ప్రపంచ పనితీరు పరిష్కారం రెండూ.