Java Interview Questions

Why String is immutable?

In programming, an object is said to be immutable if its state cannot be modified after it has been created. A string is immutable in many programming languages, including Python, Java, and C#.

There are several reasons why strings are typically implemented as immutable objects:

Performance: Strings are often used in operations that require copying or concatenating them with other strings. If strings were mutable, these operations would be more complicated and slower because they would require creating new string objects or modifying existing ones.

Thread-safety: Immutable objects are inherently thread-safe because they cannot be modified by multiple threads at the same time. This eliminates the need for synchronization and can improve the performance of concurrent programs.

Security: Immutable objects are less prone to security vulnerabilities such as buffer overflows and injection attacks because they cannot be modified in unexpected ways.

Consistency: Immutable objects guarantee that their value will not change during their lifetime. This can simplify programming by eliminating the need to track changes to objects and ensuring that the behavior of programs is consistent across different platforms and environments.

While immutability has some disadvantages (such as the need to create new objects when modifying a string), the benefits often outweigh the costs, especially in large or complex programs.

Example

In Java, strings are immutable by default. Here are some examples to illustrate this:

1. String declaration:

rustCopy codeString str = "Hello";

In this example, the string “Hello” is assigned to the variable str. This string is immutable, which means that its value cannot be changed once it is created.

2. String concatenation:

javascriptCopy codeString str1 = "Hello";
String str2 = " World";
String str3 = str1 + str2;

In this example, two immutable strings, “Hello” and ” World”, are concatenated using the + operator to create a new string, “Hello World”. The resulting string, str3, is also immutable.

3. String methods:

rustCopy codeString str = "Hello";
String str2 = str.toUpperCase();

In this example, the toUpperCase() method is called on the string str, which returns a new string that is the uppercase version of str (“HELLO”). The original string, str, is not modified and remains immutable.

These examples demonstrate that in Java, once a string object is created, its value cannot be changed. Any operations that modify the string actually create a new string object with the updated value.

What is Static in Java?

In Java, static is a keyword that can be used in several ways:

1. static variable: A static variable is a variable that belongs to the class rather than to an instance of the class. This means that all instances of the class share the same value of the static variable. A static variable is declared using the static keyword before the variable’s data type. For example:

javaCopy codepublic class MyClass {
    static int count = 0;
}

In this example, count is a static variable that belongs to the MyClass class rather than to any specific instance of the class.

2. static method: A static method is a method that belongs to the class rather than to an instance of the class. This means that the method can be called without creating an instance of the class. A static method is declared using the static keyword before the method’s return type. For example:

csharpCopy codepublic class MyClass {
    static void myStaticMethod() {
        System.out.println("This is a static method.");
    }
}

In this example, myStaticMethod() is a static method that can be called using the class name, like this: MyClass.myStaticMethod();.

3. static block: A static block is a block of code that is executed when the class is loaded into memory. This is useful for initializing static variables or performing other setup tasks that only need to be done once. A static block is declared using the static keyword followed by a set of curly braces containing the code to be executed. For example:

csharpCopy codepublic class MyClass {
    static {
        System.out.println("This is a static block.");
    }
}

In this example, the code in the static block will be executed when the MyClass class is loaded into memory.

In general, static elements in Java belong to the class rather than to any specific instance of the class. This makes them useful for things like keeping track of global state or performing setup tasks that only need to be done once. However, it’s important to use static elements judiciously, as they can also make code harder to test and maintain.