ทำไม Java Strings จึงเปลี่ยนแปลงค่าไม่ได้ (immutable) และ StringBuilder มีไว้ทำอะไร?

Question

Accepted Answer

ใน Java นั้น **อ็อบเจกต์ String เปลี่ยนแปลงค่าไม่ได้ (immutable)** เมื่อสร้างขึ้นมาแล้ว เนื้อหาของมันจะไม่มีทางเปลี่ยนได้อีก การดำเนินการใด ๆ ที่ดูเหมือนจะแก้ไข String จริง ๆ แล้วเป็นการสร้าง String **ตัวใหม่** สำหรับการแก้ไขซ้ำ ๆ อย่างมีประสิทธิภาพ คุณควรใช้ **StringBuilder** แทน

## String เปลี่ยนแปลงค่าไม่ได้

```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 **ตัวใหม่** ตัวต้นฉบับจะไม่ถูกแก้ไขเลย

## ทำไมต้อง immutable? ประโยชน์ที่ได้

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

ความ immutable ทำให้ String มีความปลอดภัยต่อการทำงานแบบหลายเธรด (thread-safe) โดยธรรมชาติ ช่วยให้ JVM สามารถ **intern** (แชร์ใช้ร่วมกัน) literal ต่าง ๆ ผ่าน String pool และทำให้มันน่าเชื่อถือเมื่อใช้เป็น key ของ map (เพราะ hash ของมันไม่มีวันเปลี่ยน)

## ปัญหาด้านประสิทธิภาพ: การต่อสตริงในลูป

```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 ตัวใหม่ (โดยคัดลอกเนื้อหาทั้งหมดก่อนหน้า) การสร้างสตริงในลูปจึงมีความซับซ้อนแบบกำลังสอง (quadratic) และสร้างขยะจำนวนมหาศาล

## 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` คือลำดับของตัวอักษรที่แก้ไขค่าได้ (mutable) เมธอด `append`/`insert`/`delete` จะแก้ไข buffer ภายในของมันโดยไม่สร้างอ็อบเจกต์ใหม่ ทำให้การสร้างสตริงในลูปมีประสิทธิภาพ (`StringBuffer` เป็นรุ่นที่ thread-safe แต่ช้ากว่า)

## ทำไมจึงสำคัญ

ความ immutable ของ String เป็นคุณลักษณะที่เป็นเอกลักษณ์ของ Java ซึ่งมีผลตามมาที่สำคัญ: มันให้ความปลอดภัยแบบหลายเธรด ช่วยให้เกิด String pool ที่ประหยัดหน่วยความจำ และทำให้ String ปลอดภัยเมื่อใช้เป็น key ของ map และในบริบทด้านความปลอดภัย แต่มันก็หมายความว่าการต่อสตริงในลูปแบบไร้เดียงสาเป็น **กับดักด้านประสิทธิภาพ** ที่แท้จริง (O(n²) สร้างขยะมากเกินไป)

การรู้ว่าควรใช้ **StringBuilder** สำหรับการแก้ไขซ้ำ ๆ เป็นสิ่งจำเป็นในทางปฏิบัติที่มาจากความเข้าใจเรื่องความ immutable โดยตรง

การผสมผสานนี้ ทั้ง *ทำไม* String จึง immutable (ความปลอดภัย การแชร์ การ hash) และ *เมื่อไร* ควรเปลี่ยนไปใช้ StringBuilder (การต่อสตริงในลูป) เป็นทั้งหัวข้อสัมภาษณ์ที่พบบ่อยและเป็นการแก้ปัญหาด้านประสิทธิภาพในโลกจริงที่เกิดขึ้นบ่อย