# Interview Questions

## **What is the difference between `String` and `StringBuilder` in Java?**

* `String` is an immutable class, meaning its value cannot be changed once created. Any modification to a `String` results in the creation of a new `String` object.
* `StringBuilder` is a mutable class that allows efficient modification of strings. It provides methods to append, insert, delete, and replace characters within a string without creating new objects.

Java Example - `String`:

```java
String str = "Hello";
str = str + " World";
```

In this example, concatenating the string " World" to the existing `str` creates a new `String` object, resulting in memory overhead.

Java Example - `StringBuilder`:

```java
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
```

In this example, the `StringBuilder` allows efficient modification of the string by appending " World" to the existing `sb` an object without creating new objects.

## **How can you concatenate strings in Java?**

In Java, strings can be concatenated using the `+` operator or by using the `concat()` method.

Java Example - Using `+` operator:

```java
String str1 = "Hello";
String str2 = " World";
String result = str1 + str2;
```

Java Example - Using `concat()` method:

```java
String str1 = "Hello";
String str2 = " World";
String result = str1.concat(str2);
```

Both examples yield the same result, "Hello World", by concatenating the strings.

## **How can you split a string into an array of substrings in Java?**

In Java, you can split a string into an array of substrings using the `split()` method, specifying a delimiter.

Java Example:

```java
String str = "Hello,World,Java";
String[] arr = str.split(",");
```

In this example, the `split()` method splits the string `str` using the comma (",") delimiter, resulting in an array `arr` containing three substrings: "Hello", "World", and "Java".

## **How can you replace characters in a string in Java?**

To replace characters in a string, you can use the `replace()` method or the `replaceAll()` method in Java.

Java Example - Using `replace()` method:

```java
String str = "Hello, World!";
String replacedStr = str.replace("o", "X");
```

In this example, the `replace()` method replaces all occurrences of "o" with "X" in the string `str`, resulting in "HellX, WXXrld!".

Java Example - Using `replaceAll()` method:

```java
String str = "Hello, World!";
String replacedStr = str.replaceAll("[aeiou]", "*");
```

In this example, the `replaceAll()` method replaces all lowercase vowels (a, e, i, o, u) with "*", resulting in "H*ll\*, W\*rld!".

## **How can you convert a string to uppercase or lowercase in Java?**

To convert a string to uppercase or lowercase, you can use the `toUpperCase()` method or the `toLowerCase()` method in Java.

Java Example - Converting to uppercase:

```java
String str = "Hello, World!";
String upperCaseStr = str.toUpperCase();
```

In this example, the `toUpperCase()` method converts all characters in the string `str` to uppercase, resulting in "HEL

LO, WORLD!".

Java Example - Converting to lowercase:

```java
String str = "Hello, World!";
String lowerCaseStr = str.toLowerCase();
```

In this example, the `toLowerCase()` method converts all characters in the string `str` to lowercase, resulting in "hello, world!".

## **How can you extract a substring from a string in Java?**

To extract a substring from a string, you can use the `substring()` method in Java, specifying the starting index and optionally the ending index.

Java Example:

```java
String str = "Hello, World!";
String substring = str.substring(7, 12);
```

In this example, the `substring()` method extracts the substring starting from index 7 (inclusive) to index 12 (exclusive) from the string `str`, resulting in "World".

## **How can you check if a string contains a specific substring in Java?**

To check if a string contains a specific substring, you can use the `contains()` method in Java.

Java Example:

```java
String str = "Hello, World!";
boolean containsSubstring = str.contains("World");
```

In this example, the `contains()` method checks if the string `str` contains the substring "World". If the substring is found, it returns `true`; otherwise, it returns `false`.

## **How can you remove leading and trailing whitespaces from a string in Java?**

To remove leading and trailing whitespaces from a string, you can use the `trim()` method in Java.

Java Example:

```java
String str = "   Hello, World!   ";
String trimmedStr = str.trim();
```

In this example, the `trim()` method removes the leading and trailing whitespaces from the string `str`, resulting in "Hello, World!".

## **How can you check if two strings are equal in Java?**

To check if two strings are equal in Java, you can use the `equals()` method or the `equalsIgnoreCase()` method for case-insensitive comparison.

Java Example - Using `equals()` method:

```java
String str1 = "Hello";
String str2 = "Hello";
boolean isEqual = str1.equals(str2);
```

In this example, the `equals()` method compares the contents of `str1` and `str2` and returns `true` if they are equal.

Java Example - Using `equalsIgnoreCase()` method:

```java
String str1 = "Hello";
String str2 = "hello";
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);
```

In this example, the `equalsIgnoreCase()` method compares the contents of `str1` and `str2` in a case-insensitive manner and returns `true` if they are equal.

## **How can you reverse a string in Java?**

Java Example:

```java
public String reverse(String str){
   String reversed = "";
   for (int i = str.length() - 1 ; i >= 0; i--) {
       reversed += str.charAt(i);
   }
   return reversed;
}
```

## **How can you check if a string is empty or null in Java?**

To check if a string is empty or null in Java, you can use the **`isEmpty()`** method in combination with null check.

Java Example:

```java
String str = ""; // or str = null;
boolean isNullOrEmpty = (str == null || str.isEmpty());
```

In this example, the **`isEmpty()`** method checks if the string **`str`** is empty, and the null check ensures that the string is not null. If the string is either empty or null, the **`isNullOrEmpty`** variable is set to **`true`**.

## **How can you count the occurrences of a specific character in a string in Java?**

To count the occurrences of a specific character in a string, you can iterate through the string and compare each character with the target character.

Java Example:

```java
String str = "Hello, World!";
char targetChar = 'o';
int count = 0;

for (char c : str.toCharArray()) {
    if (c == targetChar) {
        count++;
    }
}
```

In this example, the loop iterates through each character in the string **`str`** and increments the **`count`** variable whenever the target character 'o' is found.

## **How can you check if a string is a palindrome in Java?**

To check if a string is a palindrome, you can compare the string with its reverse using the **`StringBuilder`** class.

Java Example:

```java
String str = "madam";
StringBuilder reversedStr = new StringBuilder(str).reverse();
boolean isPalindrome = str.equals(reversedStr.toString());
```

In this example, the **`equals()`** method compares the original string **`str`** with its reversed version **`reversedStr`**. If they are equal, the **`isPalindrome`** variable is set to **`true`**.

## **How can you remove all occurrences of a specific character from a string in Java?**

To remove all occurrences of a specific character from a string, you can use the **`replace()`** method.

Java Example:

```java
String str = "Hello, World!";
char targetChar = 'o';
String removedStr = str.replace(String.valueOf(targetChar), "");
```

In this example, the **`replace()`** method replaces all occurrences of the target character 'o' with an empty string, effectively removing them from the original string.

## **How can you check if a string starts with a specific prefix in Java?**

To check if a string starts with a specific prefix, you can use the **`startsWith()`** method.

Java Example:

```java
String str = "Hello, World!";
String prefix = "Hello";
boolean startsWithPrefix = str.startsWith(prefix);
```

In this example, the **`startsWith()`** method checks if the string **`str`** starts with the prefix "Hello". If it does, the **`startsWithPrefix`** variable is set to **`true`**.

## **How can you split a string into an array of substrings in Java?**

To split a string into an array of substrings, you can use the **`split()`** method.

Java Example:

```java
String str = "Hello, World!";
String[] substrings = str.split(", ");
```

In this example, the **`split()`** method splits the string **`str`** into an array of substrings using the delimiter ", ", resulting in \["Hello", "World!"].

## **How can you convert an integer to a string in Java?**

To convert an integer to a string, you can use the **`Integer.toString()`** method or the **`String.valueOf()`** method.

Java Example - Using **`Integer.toString()`**:

```java
int number = 42;
String str = Integer.toString(number);
```

In this example, the **`toString()`** method converts the integer **`number`** to a string.

Java Example - Using **`String.valueOf()`**:

```java
int number = 42;
String str = String.valueOf(number);
```

In this example, the **`valueOf()`** method converts the integer **`number`** to a string.

## **How to find any letter like all ‘e’ from the United States of America or from any String?**

Sure, here is the Java code to find all occurrences of the letter `e` in the string "United States of America":

```java
public class FindAllE {

  public static void main(String[] args) {
    String string = "United States of America";
    int count = 0;
    for (int i = 0; i < string.length(); i++) {
      if (string.charAt(i) == 'e') {
        System.out.println(string.charAt(i) + " :: " + count);
        System.out.println("index of e :: " + i);
        count++;
      }
    }
  }
}
```

This code will print the following output:

**Code snippet**

```java
e :: 0
index of e :: 4
e :: 1
index of e :: 11
e :: 2
index of e :: 19
```

The code works by first creating a string called `string`. This string is initialized to the value "United States of America". Then, a counter variable is created to keep track of the number of occurrences of the letter `e`. Then, a for loop is used to iterate through the string, one character at a time. If the current character is equal to the letter `e`, the code prints the character and its index in the string. The code then increments the counter variable.

The main function of the code simply calls the `main()` method. The `main()` method then prints the list of all occurrences of the letter `e` in the string.

## **How to reverse the United States of America or reverse any string?**

Sure, here is the Java code to reverse the string "United States of America":

**Java**

```java
public class ReverseString {

  public static void main(String[] args) {
    String string = "United States of America";
    String newString = "";
    for (int i = string.length() - 1; i >= 0; i--) {
      newString += string.charAt(i);
    }
    System.out.println(newString);
  }
}
```

This code will print the following output:

**Code snippet**

```java
aciremA fo setatS detinU
```

## How to split the string "United States of America" into 4 pieces

```java
public class SplitString {

  public static void main(String[] args) {
    String string = "United States of America";
    String[] words = string.split(" ");
    for (int i = 0; i < words.length; i++) {
      System.out.println(words[i]);
    }
  }
}

```

This code will print the following output:

**Code snippet**

```java
United
States
of
America
```

The code works by first creating a string called `string`. This string is initialized to the value "United States of America". Then, a call is made to the `split()` method on the `string` object. The `split()` method takes a delimiter as input and returns an array of strings. In this case, the delimiter is a space character. The `split()` method returns an array of strings, each of which is one of the words in the original string.

Finally, a for loop is used to iterate through the array of strings and print each string.

To loop an array in Java, you can use a for loop. The syntax for a for loop to loop an array is as follows:

```java
for (int i = 0; i < array.length; i++) {
  // Do something with the element at index i
}
```

In this syntax, `array` is the name of the array, `i` is a loop variable, and `array.length` is the length of the array. The loop will iterate through the array, one element at a time. The loop variable `i` will be incremented by 1 after each iteration.

## How to find out which number contains 3 from 10 to 30?

```java
public class FindNumbersWithThree {

  public static void main(String[] args) {
    for (int i = 10; i <= 30; i++) {
      if (String.valueOf(i).contains("3")) {
        System.out.println(i);
      }
    }
  }
}
```

This code will print the following output:

**Code snippet**

```java
13
23
30
```

The code works by first creating a for loop that iterates from 10 to 30. Inside the loop, the `String.valueOf()` method is used to convert the integer `i` to a string. Then, the `contains()` method is used to check if the string contains the character "3". If the string contains the character "3", the number `i` is printed.

### 🎙️ Interviewer: What will be the output of the following program? 🤔

```java
public static void main(String[] args) {
    String s1 = new String("pankaj");
    String s2 = new String("PANKAJ");
    System.out.println(s1 = s2);
}
```

🙋‍♂️ Interviewee: The output of the program will be "PANKAJ" because we are assigning the value of `s2` to `s1` using the assignment operator `=`. This program is not comparing the strings using the equality operator `==`, so the case difference between the two strings does not matter in this case. 😊

### 🎙️ Interviewer: What will be the output of the following program? 🤔

```java
public static void main(String[] args) {
    String s1 = new String("pankaj");
    String s2 = new String("PANKAJ");
    s2.intern();
    System.out.println(s1 == s2);
}
```

🙋‍♂️ Interviewee: The output of the program will be `false`. Although the `intern()` method is called on `s2`, which returns the reference to the string from the string pool, the reference is not assigned back to `s2` in this case. Therefore, `s1` and `s2` still have different references, resulting in the comparison `s1 == s2` evaluating to `false`.

If we change the code on line 3 to `s2 = s2.intern();`, then the output will be `true` because `s2` will now refer to the string from the string pool, making `s1` and `s2` refer to the same object in memory.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://qatesting.gitbook.io/qa/java/string/interview-questions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.