What are the features of strings in Java and how are…

Immutability: Objects of the String class cannot be changed after creation. Any operation that appears to modify a string (e.g., concatenation) actually creates a new String object. This ensures thread safety and allows strings to be used as keys in HashMap and HashSet.
String Pool: The JVM maintains a special memory area called the string pool. When creating a string literal, the JVM first checks the pool. If a string with the same value already exists, a reference to the existing object is returned. If not, a new object is created in the pool and a reference to it is returned. This optimizes memory usage for frequently used strings.
```
// s1 and s2 point to the same object in the string pool
String s1 = "hello";
String s2 = "hello";

// s3 is created in the heap but can be added to the pool using intern()
String s3 = new String("hello");
```
Operator + Overloading: The + operator for strings is used for concatenation. Starting from Java 5, the compiler optimizes concatenation of multiple strings using StringBuilder (or StringBuffer in multithreaded scenarios).
```
String a = "Java";
String b = " is fun";
String result = a + b; // Equivalent to new StringBuilder().append(a).append(b).toString();
```
Implementation: character array: Internally, a string is represented as a character array (char[]). In older Java versions (before Java 9), each character occupied 2 bytes (UTF-16), even if it could be represented with a single byte (ASCII). Starting from Java 9, String is optimized for Latin characters, using a byte array (byte[]) with a coder field indicating encoding (LATIN1 or UTF16), which saves memory.
```
// Internal representation in Java 9+
// final byte[] value;
// final byte coder; // 0 for LATIN1, 1 for UTF16
```

String comparison: To compare string contents, use the equals() method, not the == operator. The == operator compares object references, not their values.

String str1 = "test";
String str2 = new String("test");
String str3 = "test";

System.out.println(str1 == str2); // false (despite having the same content, different objects)
System.out.println(str1 == str3); // true (references to the same object in the pool)
System.out.println(str1.equals(str2)); // true (compares content)

Methods for working with strings: The String class provides many useful methods for string manipulation, such as length(), charAt(), substring(), indexOf(), replace(), split(), trim(), toUpperCase(), toLowerCase(), and others.

What are the features of strings in Java and how are they expressed?