Java માં, String ઑબ્જેક્ટ્સ અપરિવર્તનીય છે — એક વાર બન્યા પછી, તેમાંની સામગ્રી ક્યારેય બદલાઈ શકતી નથી. જે કોઈ પણ ક્રિયા String ને સંશોધિત કરતી જણાય છે તે વાસ્તવમાં નવી String બનાવે છે. પુનરાવર્તિત સંશોધન માટે કાર્યક્ષમ રીતે, તમે તેની જગ્યાએ StringBuilder નો ઉપયોગ કરો છો.
;
s.concat();
System.out.println(s);
s = s + ;
concat, toUpperCase, replace અને substring જેવી પદ્ધતિઓ બધાં નવી String ઑબ્જેક્ટ્સ આપે છે — મૂળ કોઈપણ વખતે સંશોધિત થતો નથી.
✓ 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 પૂલ દ્વારા intern (શેર) શાબ્દિક સમર્થન આપે છે, અને તેમને map કીज તરીકે વિશ્વાસ્ત બનાવે છે (તેમનો 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 બનાવે છે (અગાઉની બધી સામગ્રીને કૉપી કરે છે), લૂપમાં strings બનાવવું ચતુર્ભુજ છે અને વિશાળ ગાર્બેજ ઉત્પાદન કરે છે.
// ✅ 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 તેના આંતરિક બફરને સંશોધિત કરે છે નવી ઑબ્જેક્ટ્સ બનાવ્યા વિના, લૂપ-આધારિત બિલ્ડિંગને કાર્યક્ષમ બનાવે છે. (StringBuffer thread-safe છે પણ ધીમું છે.)
String અપરિવર્તનીયતા Java માટે એક વ્યાખ્યાત્મક લાક્ષણિકતા છે જેમાં મહત્વપૂર્ણ પરિણામો છે: તે thread સુરક્ષા આપે છે, મેમોરી-બચત string પૂલ સક્ષમ કરે છે, અને તેમને map કીژ અને સુરક્ષા સંદર્ભમાં સુરક્ષિત બનાવે છે — પણ તેનો અર્થ એ પણ છે કે નિષ્કપટ string સંયોજન લૂપમાં વાસ્તવિક કામગીરી સમસ્યા છે (O(n²), અતિશય ગાર્બેજ).
પુનરાવર્તિત સંશોધન માટે StringBuilder ને કશું કરવું તે જાણવું વ્યવહારિક આવશ્યકતા છે જે સીધું અપરિવર્તનીયતાની સમજમાંથી આવે છે.
આ સંયોજન — શા માટે Strings અપરિવર્તનીય છે (સુરક્ષા, શેર કરવું, હેશિંગ) અને ક્યારે StringBuilder પર જવું (લૂપ સંયોજન) — બંને સમીક્ષણ વિષય અને વાસ્તવિક દુનિયાની કામગીરી સુધાર છે.