Tell about the String class in Java programming language.

The String class in Java represents an immutable sequence of characters.

Main characteristics and features:

• Immutability: Once a String object is created, its contents cannot be changed. Any operation that appears to modify the string (e.g., concatenation) actually creates a new String object. This enhances safety and thread safety.
• Overloading of the + operator: The + operator is overloaded for strings to perform concatenation.
• Two ways of creation:
  • Using a string literal: String s1 = "Hello"; - created in the string pool.
  • Using the new operator: String s2 = new String("World"); - created in the heap, and a new object can be created even if the same literal exists in the pool.
• String Pool: An area in the heap where string literals are stored for memory optimization. When creating a string literal, the JVM first checks the pool. If such a string already exists, a reference to the existing object is returned. If not, a new object is created and placed in the pool.
• Main useful methods:
  • length(): Returns the length of the string.
  • charAt(int index): Returns the character at the specified index.
  • substring(int beginIndex, int endIndex): Returns a substring.
  • contains(CharSequence s): Checks if the string contains the specified sequence of characters.
  • indexOf(int ch) / indexOf(String str): Returns the index of the first occurrence of a character or substring.
  • equals(Object anObject): Compares the contents of strings. It is important to use equals() for content comparison, not ==, which compares object references.
  • equalsIgnoreCase(String anotherString): Compares strings ignoring case.
  • replace(char oldChar, char newChar) / replace(CharSequence target, CharSequence replacement): Replaces characters or substrings.
  • trim(): Removes spaces at the beginning and end of the string.
  • split(String regex): Splits the string into substrings based on a delimiter.

Example of creation and some operations:

// Creation using literal
String str1 = "Java";

// Creation using new
String str2 = new String("Java");

// Concatenation
String str3 = str1 + " is amazing";

// Content comparison (use equals, not ==)
boolean areEqualContent = str1.equals(str2); // true

// Reference comparison (use ==)
boolean areEqualReference = (str1 == str2); // false

// String length
int length = str3.length();

// Get character
char firstChar = str1.charAt(0); // 'J'

// Check for inclusion
boolean containsIs = str3.contains("is"); // true

Immutability of String can lead to inefficiency when performing multiple modifications, as each modification creates a new object. For such scenarios, it is preferable to use StringBuilder or StringBuffer.