# Strings (Encoding, Immutability)

A **String** is a data type used in programming to represent text rather than numbers. It is comprised of a set of characters that can also contain spaces and numbers.

## 1. The Core Concept

Under the hood, a string is essentially an **array of characters**.
*   `"Hello"` is conceptually `['H', 'e', 'l', 'l', 'o']`.
*   However, modern languages treat them as a distinct primitive type with special methods (like `substring`, `replace`, `toUpperCase`).

## 2. Character Encoding

Computers only understand binary (0s and 1s). To store text, we map every character to a number. This mapping is called **Encoding**.

### ASCII (American Standard Code for Information Interchange)
*   **Size:** 7 bits (128 characters).
*   **Scope:** English letters (A-Z, a-z), digits (0-9), and basic punctuation.
*   **Limitation:** Cannot represent accents (é, ñ) or non-Latin scripts (Chinese, Arabic).

### Unicode & UTF-8
Unicode is a universal character set that assigns a unique number (Code Point) to every character in every language (and emojis).
*   **UTF-8:** The most common encoding for Unicode. It is **variable-width**:
    *   Standard ASCII characters take **1 byte**.
    *   Accented characters take **2 bytes**.
    *   Asian characters take **3 bytes**.
    *   Emojis take **4 bytes**.

## 3. Immutability

In many modern languages (Java, Python, C#, JavaScript), strings are **Immutable**.

*   **Meaning:** Once a string object is created, it cannot be changed.
*   **Modification:** When you "modify" a string (e.g., `str + " world"`), you are actually creating a **new** string object in memory. The old one remains unchanged (until garbage collected).

```python
# Python Example
s = "Hello"
s[0] = "J" # Error! Strings are immutable.

s = "Jello" # This creates a NEW string and points 's' to it.
```

### Why Immutability?
1.  **Security:** Strings are often used for database connections, URLs, and passwords. If they were mutable, a malicious thread could change the connection string after security checks passed.
2.  **Thread Safety:** Immutable objects are inherently thread-safe. Multiple threads can read the same string without locking.
3.  **String Pool (Interning):** Since strings can't change, the runtime can save memory by storing only one copy of duplicate strings (e.g., "Hello") and having multiple variables point to it.

## 4. Mutable Strings (String Builders)

Because string concatenation creates new objects, doing it in a loop is very inefficient ($O(N^2)$).

To solve this, languages provide mutable string classes:
*   **Java:** `StringBuilder` / `StringBuffer`
*   **C#:** `StringBuilder`
*   **Python:** Use a list of strings and then `''.join(list)`.

```java
// Java StringBuilder
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // Modifies the existing object (Fast)
```

[[programming/common-syntax]]
[[programming/arrays-and-lists]]
[[programming/integers]]