Java String Interview Questions and Answers

October 28, 2012 by Lokesh Gupta

All of us must have gone though interview questions related to String class in java. These questions range from immutability to memory leak issues. I will try to cover such questions in this post.

String Interview Questions discussed below:

Why strings are immutable?
String pool concept
Keyword ‘intern’ usage
Matching Regular expressions?
Strings comparison?
Memory leak issue

String in java are like any other programming language, a sequence of characters. This is more like a utility class to work on that char sequence. This char sequence is maintained in following variable:

/** The value is used for character storage. */
private final char value[];

To access this array in different scenarios, following variables are used:

/** The offset is the first index of the storage that is used. */
private final int offset;

/** The count is the number of characters in the String. */
private final int count;

Why strings are immutable?

We all know that strings in java are immutable. If you want to know, what immutability is and how it is achieved? follow this post: How to make a java class immutable?

Here the question is WHY? Why immutable? Lets analyze.

The very first reason i can think of is performance increase. Java language was developed to speed up the application development as it was not that much fast in previous languages. JVM designers must have been smart enough to identify that real world applications will consist of mostly Strings in form of labels, messages, configuration, output and such numerous ways.
Seeing such over use, they imagined how dangerous can be string’s improper use. So they came up with concept of String pool (next section). String pool is nothing but a collection of some strings mostly unique. The very basic idea behind String pool is to reuse string once created. This way if a particular string is created 20 times in code, application end up having only one instance.
Second reason I see as security considerations. Strings are most used parameter type in each aspect of java programming. Be it loading a driver or open a URL connection, you need to pass the information as parameter in form of string. If strings have not been final then they have opened up a Pandora box of security issues.All of us must have gone though interview questions related to String class in java. These questions range from immutability to memory leak issues. I will try to cover such questions in this post.

Apart from above two reasons, i didn’t find any convincing answer for this question. If you any something appealing, please share with me.

String pool concept

String pool is a special memory area separate from regular heap memory where these string constants are stored. These objects are referred string variables during the life cycle of application.

In java, String can be created by many ways. Lets understand them:

1) String assignment


String str = "abc";

Above code causes JVM to verify if there is already a string “abc” (same char sequence). If such string exist, JVM simply assign the reference of existing object to variable str, otherwise a new object “abc” will be created and its reference will be assigned to variable str.

2) Using new keyword


String str = new String("abc");

This version end up creating two objects in memory. One object in string pool having char sequence “abc” and second in heap memory referred by variable str and having same char sequence as “abc”.

As java docs says : Unless an explicit copy of original is needed, use of this constructor is unnecessary since Strings are immutable.

Keyword ‘intern’ usage

This is best described by java docs:

When the intern() method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

String str = new String("abc");

str.intern();

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true. Means if s and t both are different string objects and have same character sequence, then calling intern() on both will result in single string pool literal referred by both variables.

Matching Regular expressions

Not so secret but useful feature if you still have not explored it. You must have seen usage of Pattern and Matcher for regular expression matching. String class provides its own shortcut. Use it directly. This method also uses Pattern.matches() inside function definition.


String str = new String("abc");

str.matches("<regex>");

String comparison

Another favorite area in interviews. There are generally two ways to compare objects

Using == operator
Using equals() method

== operator compare for object references i.e. memory address equality. So if two string objects are referring to same literal in string pool or same string object in heap then s ==t will return true, else false.

equals() method is overridden in String class and it verify the char sequences hold by string objects. If they store the same char sequence, the s.equals(t) will return true, else false.

Memory leak issue

Till now we gone through basic stuff. Now something serious. Have you tried creating substrings from a string object. I bet, Yes. Do you know the internals of substring in java. How they create memory leaks?

Sub strings in java are created using method substring(int beginIndex) and some other overloaded forms of this method. All these methods create a new String object and update the offset and count variable which we saw in start of this article.

The original value[] is unchaged. Thus if you create a string with 10000 chars and create 100 substrings with 5-10 chars in each, all 101 objects will have same char array of size 10000 chars. It is memory wastage without any doubt.

Let see this using a program:


import java.lang.reflect.Field;
import java.util.Arrays;

public class SubStringTest {
	public static void main(String[] args) throws Exception
	{
		//Our main String
		String mainString = "i_love_java";
		//Substring holds value 'java'
		String subString = mainString.substring(7);

		System.out.println(mainString);
		System.out.println(subString);

		//Lets see what's inside mainString
		Field innerCharArray = String.class.getDeclaredField("value");
		innerCharArray.setAccessible(true);
		char[] chars = (char[]) innerCharArray.get(mainString);
		System.out.println(Arrays.toString(chars));

		//Now peek inside subString
		chars = (char[]) innerCharArray.get(subString);
		System.out.println(Arrays.toString(chars));
	}
}

Output:

i_love_java
java
[i, _, l, o, v, e, _, j, a, v, a]
[i, _, l, o, v, e, _, j, a, v, a]

Clearly, both objects have same char array stored while subString need only four characters.

Lets solve this issue using our own code:


import java.lang.reflect.Field;
import java.util.Arrays;

public class SubStringTest
{
	public static void main(String[] args) throws Exception
	{
		//Our main String
		String mainString = "i_love_java";
		//Substring holds value 'java'
		String subString = fancySubstring(7, mainString);

		System.out.println(mainString);
		System.out.println(subString);

		//Lets see what's inside mainString
		Field innerCharArray = String.class.getDeclaredField("value");
		innerCharArray.setAccessible(true);
		char[] chars = (char[]) innerCharArray.get(mainString);
		System.out.println(Arrays.toString(chars));

		//Now peek inside subString
		chars = (char[]) innerCharArray.get(subString);
		System.out.println(Arrays.toString(chars));
	}

	//Our new method prevents memory leakage
	public static String fancySubstring(int beginIndex, String original)
	{
		return new String(original.substring(beginIndex));
	}
}

Output:

i_love_java
java
[i, _, l, o, v, e, _, j, a, v, a]
[j, a, v, a]

Now substring has only characters which it need, and intermediate string used to create our correct substring can be garbage collected and thus leaving no memory footprint.

I can think of these questions generally asked in interviews. If you know any more questions specifically regarding String class, please share.

Happy Learning !!

About Lokesh Gupta

Founded HowToDoInJava.com in late 2012. I love computers, programming and solving problems everyday. A family guy with fun loving nature. You can find me on Facebook, Twitter and Google Plus.

Feedback, Discussion and Comments

Ancil Hameed
September 6, 2017
String str = new String(“how_to_do_in_java”);
As you mentioned above the above line will create two object one in heap and other in String Constant Pool(Perm are of heap).
str.intern() method will check if SCP(String Constant Pool)) has this char if not then it will return that else it will create a object with this char.
My question is why will there be a possibilty that this character wont exist in SCP because when we create with new literal definetly it will be created in SCP
Reply
Suryakant
April 18, 2016
Really appreciate for this blog!!
Sir please rectify as I have a small doubt.
```
 

String s1=new String("abc"); //1st line
String s2="abc";                           //2nd line
Sytem.out.println(s1==s2); // false
```
As per my understanding, 1st line will create two objects(1 heap+1 pool) and 2nd line will not create any object as “abc” is already present in string pool. So s2 must be assigned to s1 and should show the result true. But it is showing false.
What is happening in this case?? (I am using JDK 1.8)….Plz explain
Reply
- Murtuza
  July 28, 2016
  As per my understanding. S1 is the variable that would be pointing to the object in heap while s2 is pointing to the object in String pool. And when we do s1 == s2, we are comparing the memory address rather than the actual content. hence in this case the memory location doesn’t matches and it returns false.
  Reply
- Santosh
  August 31, 2016
  Here s1 is pointing to the object in heap where as s2 is pointing to object in String pool.
  If you do s2==s1.intern() then you will get true as the output as intern() method will return the reference from String pool.
  Reply
Pratik Kelwalkar
October 27, 2015
hi,
As of java 8 or 1.7.x mentioned above, the issue has been resolved as i tested the above code and realised that the substring now created a string with the modified char array and not the entire original character array. Excellent blog though !! I always refer before going for a interview!
Reply
Mahi_ksp
March 13, 2015
Nice Post keep it up…
Reply

swekha

February 1, 2015

suppose I have a string s=”The god is great”. how we will print like “great is god the” ? we will not hardcode the value of s. so we will provide the value at runtime. Please tell me lokesh how I will do this?

Lokesh

February 1, 2015

Let me know if something is not clear.

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Main 
{
	public static void main(String[] args) 
	{
		String initial = "The god is great";

		String[] arr = initial.split(" ");

		List<String> list = Arrays.asList(arr);

		Collections.reverse(list);

		arr = (String[]) list.toArray();

		System.out.println(joinArr(arr));
	}

	private static String joinArr(String[] array) 
	{
		StringBuilder sb = new StringBuilder();
		for (String word : array) {
			sb.append(" ");
			sb.append(word);
		}
		String result = sb.toString();
		return result.replaceFirst(" ", "");
	}
}

Output:

great is god The

nitesh
December 9, 2014
how many objects will get created
String str1=new String(“nitesh”);
String str2=new String(“nitesh”);
String str3=”nitesh”;
String str4=str3;
String str5=str2;
Reply
- Lokesh
  December 10, 2014
  String str1=new String(“nitesh”); //Two objects (1 in heap + 1 in pool)
  String str2=new String(“nitesh”); //One object (In heap only)
  String str3=”nitesh”; //No new object
  String str4=str3; //No new object
  String str5=str2; //No new object
  Total 3 objects.
  Reply
  - siva
    January 5, 2016
    what about the character arrays? do we need to consider them?
    Reply
    - Lokesh Gupta
      January 5, 2016
      Technically, all arrays are objects in java, even arrays of primitive types. So, YES, we can consider them but in above example, we have counted only instances of String class.
      Reply
Aashish Singh Rawat
November 20, 2014
String s1 = “abcd5”;
String s2 = “abcd”+”5″;
String s3 = “adcd”+s1.length();
System.out.println(s1 == s2);//true
System.out.println(s2 == s3);//false
System.out.println(s2 == s3);//false
in this code why output is true,false,false and how many objects actually create in heap and string pool?
Reply
- Mayank Rupareliya
  July 5, 2015
  String s1 = “abcd5”;
  String s2 = “abcd”+”5″;
  If you look into .class file for the above two lines then you will find them identical meaning compiler changes second line to make it look like first line so ultimately at runtime in the string pool there will be only one string “abcd5”. – This justifies that s1 == s2 should return true.
  String s3 = “abcd”+s1.length();
  In for this line “abcd” will be inserted into string pool but s1.length() is just a integer concatenation which is not similar to the string “abcd5”. – I might be wrong here…
  Reply
  - Deepak Jha
    February 4, 2017
    First two strings are compile time constants hence they will go to Pool. While last one will be created on heap as s1.length is not compile time constant so compile will leave this to JVM who eventually put this on heap.
    Reply
partha
November 5, 2014
String s1 = “abc”;
String s2 = new String(s1);
System.out.println(s1 == s2);
String s3 = s2.intern();
System.out.println(s1 == s3);
in this code how many objects actually create ?
and my ans is 2 .one in pool coz of literal & 2nd one in heap bt not in intern pool due to the same literal already present in pool sir is this correct or not
Reply
- Lokesh
  November 6, 2014
  You are right.
  Reply
  - partha
    November 6, 2014
    sir thanx fr quick response
    and one request sir if it is possible plz u post one example to send sms from a java pgm ,it will be help full to me .once again thank u sir .
    Reply
chandan
October 30, 2014
In the Intern() method description you might wanna add following point:
All literal strings and string-valued constant expressions are interned.
Reply
Venkat
October 26, 2014
Hi Lokesh,
I need some help in understanding the concept “Using new keyword creating two objects in memory. One object in string pool having char sequence “abc” and second in heap memory referred by variable str and having same char sequence as “abc”.
Is there a way to test this scenario? Because in some other blogs i had read like when we use new operator,JVM will be creating object in heap memory but if we need same string object to String constant pool we need to user intern() method, is that true?
Reply
- Lokesh
  October 27, 2014
  Someone passed “abc” in new String(“abc”). Before actually executing this line, “abc” itself must be in string pool (it’s an object, right?). Executing the new String() then creates another instance.
  This SO thread gives correct answer: http://stackoverflow.com/questions/10571158/string-object-creation-using-new-and-its-comparison-with-intern-method
  Reply
Bhaskar Verma
August 25, 2014
Hi Sir,
Can you Explain in detail,how String constant pool works.Eg-String s1=new String(“abc”); ,String s2=new String(“abc”); how this two string is handled in String pool.
Reply
Nikhil Shelke
August 8, 2014
What is happening in stringbuffer means how it allows to append values on the same memory location which is not possible in string as it is immutable
Reply
- Lokesh
  August 8, 2014
  String buffer internally maintains a char array. All appended content is added into this array only. when you call toString() method, a string is returned with content of this array.
  Reply
Venkata Sriram
May 13, 2014
Excellent stuff sir,but i faced one question in interview,please guide sir.question is
String st=”abc”; // st will create in string pool since it is a String Literal
String st1=new String(“XYZ”) + st ; // it will gets created in both pool as well as heap.and concatenation internally uses StringBuilder(from 1.5 onwards.).now where st1 will create sir.please Help.
Reply
- Lokesh
  May 13, 2014
  After concatanation strings, StringBuilder return the value using toString() method. This method is written as:
```
public String toString() {
  // Create a copy, don't share the array
  return new String(value, 0, count);
}
```
  So it return a new String object which end up creating two objects in memory. One in heap as spring object and another in as string literal in string pool.
  Reply
  - Venkata Sriram
    May 14, 2014
    Thanks alot sir.if you have time please write article on How to maintain HttpSession in cluster mode sir.whenever any variable is putting in Session.if the request goes to another machine means that session variable returning null sir.i dont know whether any entry to made in web.xml or some xml file in order to handle by application server.Thanks sir
    Reply
    - Lokesh
      May 14, 2014
      I will try to get something for you.
      Reply
    - Sowmi
      June 9, 2014
      Have the variable in an object and serialize the object. When the request goes to another machine,try porting the serialized object file to the new machine as well. De-serialize your object in the new machine and put the object into session. You can now get the variable from the object in session.
      @ Lokesh: Correct me if I’m wrong anywhere.
      Thanks
      Reply
      - Lokesh
        June 9, 2014
        Conceptually what you said is correct. But in real, it should be only some config options set while creating clusters. I will check and update.
        Reply
Dipanshu
April 6, 2014
Hi Lokesh,
I also found the same output ..
[i, _, l, o, v, e, _, j, a, v, a]
[j, a, v, a]
could not get memory leakage issue here.
i tried it in JDK 1.5 , 1.6 and 1.7 as well .
Reply
Vijay
March 31, 2014
Really Gud Post …Thanks!!
Reply
divya kumar
January 10, 2014
I wonder if that was the case(Memory leak using substring()) then why Java still ignored that.
I have herd that in Java1.7 this drawback was removed.
Reply
- Lokesh Gupta
  January 10, 2014
  Yeh! They finally realized and corrected it.
  Reply
Jitendra
October 25, 2013
Hello,
Article is good, thanks for this.
But, As per my knowledge method
String.subString(int x) is not create new object it point to earlier one.
http://stackoverflow.com/questions/16108477/java-strings-and-the-substring-method
http://stackoverflow.com/questions/15986501/string-object-creation-and-its-constructor
Thanks
Jitendra
Reply
- Lokesh Gupta
  October 25, 2013
  Yes, you are right till jdk 1.6. This is precisely what I discussed in memory leak section.
  Reply
  - Umesh
    September 13, 2014
    In the memory leak problem, how come it is a memory leak if substring and mainstring is referring to same string that is in the string pool?
    – Umesh
    Reply
Dinesh Mathiazhagan
October 12, 2013
Your are great Guru !!!
Reply
jule64
October 9, 2013
Just wanted to say great post!
Reply
Jan Hoppe
May 2, 2013
This string leak is annoying. If you are parsing xml with the default xerces parser, all attributes and values will be substrings! If you store just one attribute value of each xml-stream you have parsed, your heap is floated with those original strings….
So the fix for java.lang.String in java 7u6 is simple but great!
Reply
Ludovic Aelbrecht
February 23, 2013
FYI, the memory leak thing is not true anymore. I use Java 1.7.0u13, and running your code outputs:
[i, _, l, o, v, e, _, j, a, v, a]
[j, a, v, a]
I had a look at the String.java file, and indeed the field ‘offset’ is gone.
Reply
benjamin leroux (@Benjamin_Leroux)
October 31, 2012
It’s wrong you just create a memory leak by doing String(original.substring(beginIndex)); as you create a new array.
and a performence issue too (arrays copy are not free).
In some case it’s usefull to do this if you don’t use the oiginal string anymore. BUT just in some special case. in your case for 100 substring your create 100 arrays instead of one.
And string is also immutable for the same reason. if you have
String s1 = “toto”;
String s2 = s1.substring(0,2);
s2.changeCharAt(0,’m’)
you will have s1 equals to “moto”
…
Reply
- Admin
  October 31, 2012
  Benjamin, thanks for analyzing the substring method and providing more insight. Yes, you are right that array copy is not free and so holding multiple arrays.
  My analysis was originally for the case when you read some large text file (say an XML file over 1 MB) in a string and use tostring() method to extract only some tokens out of it. In this case or similar cases, you end up having 3-4 strings, which should be ideally 100-200 characters but actually in memory you store a very large array for no good use. Thus memory leak.
  Reply

Ask Questions & Share Feedback Cancel reply

Your email address will not be published. Required fields are marked *

Comment

*Want to Post Code Snippets or XML content? Please use [java] ... [/java] tags otherwise code may not appear partially or even fully. e.g.

[java] 
public static void main (String[] args) {
...
} 
[/java]

Name *

Email *

Website

Help me fight spammers. Solve this simple math. * + 2 = 11