Java ਵਿੱਚ, String objects ਅਸਮੂਤ ਹਨ — ਇੱਕ ਵਾਰ ਬਣਾਏ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਉਹਨਾਂ ਦੀ ਸਮੱਗਰੀ ਕਦੀ ਵੀ ਬਦਲ ਨਹੀਂ ਸਕਦੀ। ਕੋਈ ਵੀ ਕਾਰਜ ਜੋ String ਨੂੰ ਬਦਲਦਾ ਜਾਪਦਾ ਹੈ, ਅਸਲ ਵਿੱਚ ਇੱਕ ਨਵਾਂ String ਬਣਾਉਂਦਾ ਹੈ। ਕੁਸ਼ਲਤਾ ਨਾਲ ਵਾਰ-ਵਾਰ ਸੋਧ ਲਈ, ਤੁਸੀਂ StringBuilder ਦੀ ਬਜਾਏ ਵਰਤਦੇ ਹੋ।
;
s.concat();
System.out.println(s);
s = s + ;
concat, toUpperCase, replace ਅਤੇ substring ਵਰਗੇ methods ਸਾਰੇ ਨਵੇ String objects ਵਾਪਸ ਕਰਦੇ ਹਨ — ਅਸਲ ਕਦੀ ਸੋਧੀ ਨਹੀਂ ਜਾਂਦੀ।
✓ 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 ਨੂੰ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ thread-safe ਬਣਾਉਂਦੀ ਹੈ, JVM ਨੂੰ String pool ਦੁਆਰਾ literals ਨੂੰ intern (ਸਾਂਝਾ) ਕਰਨ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ map keys ਵਜੋਂ ਭਰੋਸੇਮੰਦ ਬਣਾਉਂਦੀ ਹੈ (ਉਹਨਾਂ ਦਾ hash ਕਦੀ ਨਹੀਂ ਬਦਲਦਾ)।
// ❌ 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 ਬਣਾਉਣਾ ਰੂੜੀਸੀ ਹੈ ਅਤੇ ਬਹੁਤ ਸਾਰਾ garbage ਪੈਦਾ ਕਰਦਾ ਹੈ।
// ✅ 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 ਅੱਖਰਾਂ ਦਾ ਇੱਕ mutable sequence ਹੈ — append/insert/delete ਇਸਦੇ ਅੰਦਰੂਨੀ buffer ਨੂੰ ਨਵੇ objects ਬਣਾਏ ਬਿਨਾਂ ਸੋਧਦੇ ਹਨ, loop-ਅਧਾਰਿਤ ਬਾਲ੍ਹੀ ਨੂੰ ਕੁਸ਼ਲ ਬਣਾਉਂਦੇ ਹਨ। (StringBuffer thread-safe ਪਰ ਹੌਲੀ variant ਹੈ।)
String ਅਸਮੂਤਾ ਇੱਕ ਪਰਿਭਾਸ਼ਾਤਮਕ Java ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜਿਸ ਦੇ ਮਹੱਤਵਪੂਰਨ ਨਤੀਜੇ ਹਨ: ਇਹ thread safety ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, memory-saving string pool ਨੂੰ ਸਮਰੱਥ ਕਰਦਾ ਹੈ, ਅਤੇ Strings ਨੂੰ map keys ਅਤੇ security contexts ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਬਣਾਉਂਦਾ ਹੈ — ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ loops ਵਿੱਚ ਭਲਕਲੀ string concatenation ਇੱਕ ਅਸਲੀ performance pitfall ਹੈ (O(n²), ਬਹੁਤ ਸਾਰਾ garbage)।
ਵਾਰ-ਵਾਰ ਸੋਧ ਲਈ StringBuilder ਵਰਤਣਾ ਜਾਣਨਾ ਇੱਕ ਵਿਹਾਰਕ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਅਸਮੂਤਾ ਨੂੰ ਸਮਝਣ ਤੋਂ ਆਉਂਦੀ ਹੈ।
ਇਹ ਮਿਸ਼ਰਣ — ਕਿਉਂ Strings ਅਸਮੂਤ ਹਨ (safety, sharing, hashing) ਅਤੇ ਕਦੋਂ StringBuilder ਵਾਲੀ ਸਵਿਚ ਕਰਨੀ ਹੈ (loop concatenation) — ਦੋਵੇਂ ਇੱਕ ਆਮ interview topic ਅਤੇ ਇੱਕ ਵਾਰ-ਵਾਰ real-world performance fix ਹੈ।