Java String

← Core Java | Notes | Home

1. String Literal — SCP, == comparison
2. String Object — new keyword, heap memory
3. String Immutability — thread safety, SCP, security
4. StringBuilder & StringBuffer — mutable, synchronized, thread-safe

• Q1. What is String Constant Pool?
• Q2. String vs StringBuilder vs StringBuffer?
• Q3. Why is String immutable?
• Q4. String Literal vs String Object?
• Q5. When is StringBuffer better than String?
• Q6. What does immutability mean?
• Q7. How to create an immutable class?

← Core Java | Notes

Type of a String Object which is mostly used. Declared directly using String keyword and actual string value in double quotes without using new keyword.

String s1 = "Hello";
String s2 = "Hello";
s1 == s2 // true

1. String literal object is stored in String Constant Pool insie heap memory.
2. If String object of same value already exists in the String Constant Pool JVM reuses it and hence it is memory efficient.
3. == returns true if two String literals have same value (ie same string) because both references to same object in memory.

String object created using new keyword.

String s1 = new String("Hello");
String s2 = new String("Hello");
s1 == s2 // false

1. It is store in heap memory outside String Constant Pool.
2. New Object is created everytime

1. Once a String literal or String Object is created, its value cannot be changed.
2. Any modifications (like concat(), replace(), etc) creates a new String Object instead of modifying the existing one.

   String s1 = "Hello";
   s1.concat(" World");
   System.out.println(s1) // Hello
   

because s1 reference to "Hello". concat() creates a new String Object, but the returned object is not assigned back to s1.

Reasons why String is immutable:

1. Thread safety
2. Memory optimization through String Pool reuse
3. Security (important for class loading, URLs, file paths, etc)
4. Immutability is a foundation of functional programming

1. They are used to modify the same object in memory instead of creating new objects.
2. They use internal character array that grows dynamically when needed.

   StringBuilder sb = new StringBuilder("Hello");
   sb.append(" World");
   System.out.println(sb) // Hello World
   

append() modifies the same object instead of creating new one.

1. Not thread-safe
2. Faster because there is no synchronization overhead.
3. Used in single-threaded environment where performance is important.

1. Thread-safe
2. Slighty slower than StringBuilder because methods are synchronized
3. Used in multithreaded environment

1. Most methods in StringBuffer are synchronized.
2. Only one thread can execute synchronized methods on the same object at a time.
3. This prevents multiple threads from modifying the internal character array simultaneously.

   public synchronized StringBuffer append(String str)
   

Synchronization ensures thread safety but adds performance overhead.

StringBuilder was introduced in Java 5 as a faster alternative to StringBuffer when thread safety is not required.

String Constant Pool (SCP) is a special memory in heap to store String Literals.

So when a new String Literal is is created, jvm checks SCP first :

• If the same value already exists in the pool, the existing String Object is reused, and the new reference variable points to that existing object.
• Otherwise a new string object is created in the pool.

This reduces unnecessary object creation, saves memory, and improves performance because multiple references can point to the same immutable String Object.

• String is immutable once created cannot be changed. If modified, new object is created.
• StringBuffer and StringBuiler are used to create mutable string objects. If modified, the same object is updated instead of creating a new one.
• StringBuilder is not thread-safe and is faster compared to StringBuffer because it does not have synchronization.
• StringBuffer is thread-safe is slighty slower than StringBuilder because its methods are synchronized. It is mainly used in multithreaded environment.

Strings are immutable for security, thread-safety and performance reasons.

• Immutability prevents modifications of sentitive data like passwords, file paths, database URLs, etc.
• Since strings cannot be changed, they can be safely shared across multiple threads without synchronization.
• Immutability allows the JVM to use the String Constant Pool (SCP), where string literals with the same value are reused, resulting in better memory efficiency and performance.

String Literal :

• String Literal is saved in String Constant Pool (SCP), which is located in heap memory.
• When a new String Literal is created, the jvm checks the SCP to see if an object with the same value already exists.If it exists, the existing object is reused and the new reference variable points to that existing object instead of creating a new one.

  String s1 = "hello";
  String s2 = "hello";
  s1 == s2 // returns true because both references points to same object in SCP
  

String Object :

• Whereas String Object created using new keyword always creates a new object in heap memory, even if another object with same value already exist.

  String s1 = new String("hello");
  String s2 = new String("hello");
  s1 == s2 // returns false because both references point to different objects.
  

Note : equals() compares content, whereas == compares references.

s1.equals(s2) // true .. even when == is false.

• When frequent modifications to a string are required, since StringBuffer is mutable.
• When same data is shared aross multiple threads concurrently in multithreaded environment.
• When thread-safety is required, because the method of StringBuffer are synchronized.

• In Java, immutability means an object's internal state cannot be changed after the object is created.
• Any operation that appears to modify the object actually creates a new object with the modified value.
• The original object remains unchanged in memory.

  String s1 = "hello";
  s1.concat(" world");
  

What Happens Here?

String s1 = "hello";
s1.concat(" world");
System.out.println(s1); // hello

• String is immutable, so concat() does not modify the existing object.
• A new String object "hello world" is created in memory.
• Since the returned object is not assigned to any variable, it becomes eligible for garbage collection.
• s1 still points to "hello".

• Immutable objects are safer because their state cannot be accidentally changed.
• String, Integer, and LocalDate are common immutable classes in Java.

• Make the class final so it cannot be inherited.
• Make all fields private and final.
• Initialize fields using a constructor.
• Do not provide setter methods.
• For mutable fields like list, return defensive copies to prevent external modification.

  final class Employee{
  
      private final String name;
      private final List<String> skills;
      
      public Employee(String name, List<String> skills){
          this.name = name;
          this.skills = List.copyOf(skills);
      }
      
      // setters
      public String getName() {
          return name;
      }
      
      public List<String> getSkills() {
          return List.copyOf(skills);
      }
  }
  

← Core Java | Notes | Home