Java Interview Questions- No Strings Attached.

Explain how Strings are immutable in Java?

Strings in Java are immutable, meaning once a String object is created, its value cannot be changed.

If you try to modify a String, instead of altering the existing object, a new String object is created with the modified value. This behavior has several implications for performance, security, and functionality.

Why Strings are Immutable

1. Security: Strings are used extensively in Java’s network and database connection settings, class paths, file paths, etc. Making String immutable helps secure these critical parameters against malicious alteration.
2. Synchronization and Concurrency: Immutability naturally makes String objects thread-safe, simplifying concurrent programming by eliminating the need for synchronization when shared between multiple threads.
3. Caching and Reuse: Since the value of immutable objects cannot change, their hashcode can be cached and reused, which is beneficial for collections like HashSet or HashMap, improving lookup and insertion performance.
4. String Pool Efficiency: Immutability allows the JVM to optimize memory usage through string pooling (storing only one copy of each distinct string value), as there’s no risk of string values being altered.

How Many Ways you can create Strings in Java?

We can create Strings in many ways and some of them are listed below:

String Literals: This is the most common way to create strings in Java. When you create a string using string literals, Java first looks for the string in the string constant pool.

If found, it returns a reference to the pooled instance. If not, it creates a new string instance in the pool and returns a reference to this new instance. This process is automatic and helps save memory by reusing immutable strings.

String s1 = "Hello";

When you create a string with the new keyword:

Java always creates a new string object in the heap memory, even if the same string already exists in the string constant pool. This way, you can create distinct objects that have the same value.

String s2 = new String("Hello");

StringBuilder and StringBuffer:

You can create strings by first constructing a mutable sequence of characters with StringBuilder or StringBuffer and then converting it to a string.

StringBuilder sb = new StringBuilder("Hello");
String s3 = sb.toString();

Character Arrays:

You can convert a character array into a string.

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String s4 = new String(charArray);

What is String Constant Pool in Java?

The String Constant Pool in Java is a special memory region in the Java Virtual Machine (JVM) where Java stores unique string literals that appear in your code. This concept is crucial for understanding Java’s optimization for string memory usage. Here’s a detailed look into its characteristics and purpose:

Purpose

The primary purpose of the String Constant Pool is to optimize memory usage and improve performance. By storing only one copy of each distinct string literal, Java ensures that memory is used efficiently and that string comparison (by reference) can be faster in some cases.

How It Works

When your Java program includes string literals:

1. Automatic Interning: Java automatically places these literals in the String Constant Pool. This means that if you have multiple references to the same string literal in your code, Java ensures that all these references point to the same string object in the pool, thus saving memory.
2. Manual Interning: You can also manually add strings to the pool by calling the intern() method on a string object. This can be useful when you create strings dynamically (e.g., through concatenation or loading from a file) and want to ensure that equal strings share the same reference.

String name = "Vikas"; // Uses the string literal "Vikas", which is interned.
String otherName = "Vikas"; // Compiler makes s2 refer to the same "Vikas" literal in the pool.
System.out.println(name == otherName); // true, because name and otherName reference the same object in the pool.

String newName = new String("Vikas"); // Creates a new String object, not interned by default.
String internedName = name.intern(); // Ensures this "Vikas" string is in the pool and returns the pool reference.
System.out.println(name == newName); // false, different references (pool vs heap).
System.out.println(name == internedName); // true, s4 is interned, so it refers to the same object as s1.

Explain when do you use String.intern method?

The String.intern() method is a part of the Java language. When you call intern() on a string object, it checks if the string is already present in the string pool. The string pool, also known as the intern pool, is a special storage area in the Java Virtual Machine (JVM) for storing unique string literals.

• If the string is already present in the pool, the method returns a reference to the pooled instance.
• If the string is not present in the pool, it adds the string to the pool and then returns a reference to this newly added string.

Using String.intern() can reduce memory usage because it ensures that all identical strings share the same memory location. However, it can increase the CPU time due to the need to search the pool for matches.

String s1 = new String("hello");
String s2 = s1.intern();
String s3 = "hello"; // This literal is automatically interned

System.out.println(s1 == s2); // false, because s1 points to a string in the heap, not in the pool
System.out.println(s2 == s3); // true, because both s2 and s3 point to the same interned string

Characteristics

• Immutable Strings: Since strings in the pool are reused, Java strings are immutable to ensure that one reference cannot change the value for another.
• Garbage Collection: Earlier versions of Java placed the constant pool in the PermGen space, which was not garbage collected. However, recent Java versions store the pool in the heap, allowing for garbage collection of strings that are no longer referenced anywhere in the program.

Summary:

Strings in Java are immutable, meaning once a String object is created, its value cannot be changed.

1. String Literals is the most common way to create strings in Java. When you create a string using string literals, Java first looks for the string in the string constant pool.
2. Strings Immutability allows the JVM to optimize memory usage through string pooling.
3. With the new keyword Java always creates a new string object in the heap memory, even if the same string already exists in the string constant pool.
4. Since strings in the pool are reused, Java strings are immutable to ensure that one reference cannot change the value for another.
5. The primary purpose of the String Constant Pool is to optimize memory usage and improve performance. By storing only one copy of each distinct string literal, Java ensures that memory is used efficiently and that string comparison (by reference) can be faster in some cases.

I hope you like this content, Please clap and share if you like it and want me to create more content like this. Please support here.