The java.lang.String class encapsulates sequences of characters within a Java application. Every text literal enclosed in double quotes constitutes an instance of this immutable class. Being located in the java.lang package, explicit import statements are unnecessary.

Immutability Characteristics

Instances of String maintain a fixed state once instantiated. While the data cannot be altered after creation, instances can be referenced by multiple pointers. Conceptually resembling a character array (char[]), the internal storage utilizes a byte array in modern JDK versions.

Instantiation Strategies

Several constructors exist for creating String instances:

Example Impelmentation

public class InstanceDemo {
    public static void main(String[] args) {
        // Initialize empty
        String blank = new String();
        
        // From char array
        char[] letters = {'j', 'a', 'v', 'a'};
        String objFromChars = new String(letters);
        
        // From byte array
        byte[] bytes = {74, 65, 86, 65};
        String objFromBytes = new String(bytes);
        
        // Literal usage
        String literal = "example";
    }
}

Memory Allocation Differences

When new is invoked, a distinct memory block is allocated on the heap regardless of content repetition. Conversely, string literals trigger checks against the String Constant Pool. If a matching sequence exists, the reference is reused rather than allocating new memory.

Equality Checks

The operator == compares memory addresses for object types, whereas primitive types compare actual values. The equals() method is overridden in many standard classes to compare content.

String refA = new String("data");
String refB = new String("data");
System.out.println(refA == refB);      // false (different addresses)

String litA = "data";
String litB = "data";
System.out.println(litA == litB);      // true (pooled reference)

// Content comparison
System.out.println(litA.equals(litB)); // true

Iteration and Slicing

To access individual characters, iterate based on length and use charAt().

String source = "sequence";
for (int i = 0; i < source.length(); i++) {
    System.out.print(source.charAt(i) + " ");
}

Substrings are extracted using substring(start, end). Note that the starting index is inclusive, while the ending index is exclusive. A variant accepting only start extracts until the end of the string.

Mutable Alternatives

For scenarios requiring frequent modification, StringBuilder acts as a buffer. Unlike String, its content can change. Key utilities include:

• append(): Adds data of various types.
• reverse(): Flips the sequence order.
• length(): Returns current size.

public class BufferTest {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Start");
        builder.append(123);
        builder.reverse();
        System.out.println(builder.toString());
    }
}

Delimited Joining

Introduced in JDK 8, StringJoiner facilitates concatenating elements with custom separators without manual looping.

StringJoiner joiner = new StringJoiner("-", "[", "]");
joiner.add("Item1");
joiner.add("Item2");
System.out.println(joiner); // [Item1-Item2]

Performance Considerations

Literal concatenation often happens at compile time, optimziing performance by avoiding intermediate objects. However, concatenating variables in a loop generates transient objects on the heap, consuming more resources compared to using a mutable buffer.

Shuffling Sequence

Rearranging character order involves converting to an array, swapping indices randomly, and reconstructing.

import java.util.Random;

public class ShuffleDemo {
    public static void main(String[] args) {
        String original = "randomize-me";
        char[] chars = original.toCharArray();
        Random rng = new Random();

        for (int i = 0; i < chars.length; i++) {
            int swapIdx = rng.nextInt(chars.length);
            char temp = chars[i];
            chars[i] = chars[swapIdx];
            chars[swapIdx] = temp;
        }

        String mixed = new String(chars);
        System.out.println(mixed);
    }
}