Java String Interview Questions with Answers

The given Java String interview questions range from string methods, string immutability and memory leak issues to simple examples and usecases. I will try to cover the most asked questions in Java interviews.

1. Is String a Keyword in Java?

No. String is not a Java reserved keyword. It is a derived data type, i.e., it is a class.

public class StringExample
{
    public static void main(String[] args)
    {
        Integer String = 10;

        System.out.println(String);		//Prints 10
    }
}

2. Why are Strings 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? Let’s analyze.

  1. The very first reason is performance improvement. 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 overuse, they imagined how dangerous can be string’s improper use. So they came up with a concept of String pool. 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.

  2. The 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.

3. What is String Constant Pool?

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

In Java, we can create a string in many ways. For example, using the string literals and using the new keyword.

String str1 = "abc";

String str2 = new String("abc");

Using string literal causes JVM to verify if there is already a string “abc” (same char sequence). If such string exists, JVM assigns the reference of the existing object to variable str; otherwise, a new object “abc” will be created and its reference will be assigned to the variable str1.

When using new keyword, Java ends up creating two objects in memory. One object in string pool having char sequence “abc” and second in regular heap memory referred by variable str2 and having the same char sequence as “abc“.

To have better memory utilization and overall performance, using the string literals to create the strings is recommended. Unless an explicit copy of the original is needed, the use of the constructor is unnecessary since Strings are immutable.

4. What is String intern() Process?

When the String intern() method is invoked, if the string pool already contains a string equal to the 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.

In simple words, string interning is the process of moving a String object from regular heap memory to String constant and using the object reference from the pool.

String str = new String("abc");

str.intern();

For the intern() method, for any two strings s1 and s2, s1.intern() == t2.intern() is true if and only if s1.equals(s2) is true.

This means if s1 and s2 are different string objects and have the same character sequence, then calling intern() on both will result in a single string pool literal referred by both variables.

By default, remember that all literal strings and string-valued constant expressions are interned.

5. How to Match a String with Regular Expressions?

We can use Pattern and Matcher for regular expression matching. String class provides its own method matches(). We should be using the matches() directly. This method also uses Pattern.matches() inside function definition.

String str = new String("Welcome to howtodoinjava.com");
 
System.out.println(str.matches("(.*)java(.*)"));    //Prints true
System.out.println(Str.matches("(.*)python(.*)"));  //Print false

6. How to Compare Strings?

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

  • Using == operator
  • Using equals() method

The == operator compare for object references. So if two string objects are referring to the same literal in string pool or same string object in heap then ‘s == t‘ will return true, else false.

The equals() method is overridden in String class and verifies the char sequences held by String objects. In other words, equals() method compares the values of string objects. If they store the same char sequence, the ;s.equals(t); will return true, else false.

7. Explain Memory Leak Issue caused by substring() Method?

Till now, we have 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 do they create memory leaks?

Substrings 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 at the start of this article.

The original value[] is unchanged. Thus if you create a string with 10000 chars and create 100 substrings with 5-10 chars in each, all 101 objects will have the 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));
    }
}
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 the same char array stored while the sub-string needs only four characters.

Let’s 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));
    }
}
i_love_java
java
[i, _, l, o, v, e, _, j, a, v, a]
[j, a, v, a]

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

8. How Strings work in Java?

Like any other programming language, String in Java is a sequence of characters. This is more like a utility class to work on that char sequence. This char sequence is maintained in the following variable of type char array:

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

Various string methods operate on this array in different scenarios using the following variables to maintain the position in the array:

/** 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;

10. How to Check a Palindrome String?

A String is Palindrome if its value is the same when reversed. To check Palindrome, reverse the string and compare it with the original string.

If original strings and reversed strings are the same, then the given string is a palindrome.

String originalString = "abcdcba";
         
StringBuilder strBuilder = new StringBuilder(originalString);
String reverseString = strBuilder.reverse().toString();

 
boolean isPalindrame = originalString.equals(reverseString);

System.out.println(isPalindrame);    //true

11. How to Remove or Replace Characters in a String?

To replace or remove characters, use String.replace() or String.replaceAll().

Both methods take two arguments. The first argument is character to be replaced, and the second argument is a new character placed in string.

If you want to remove characters, pass blank character in the second argument.

String originalString = "howtodoinjava";

//Replace one character
System.out.println( originalString.replace("h", "H") );         //Howtodoinjava

//Replace all matching characters
System.out.println( originalString.replaceAll("o", "O") );      //hOwtOdOinjava

//Remove one character
System.out.println( originalString.replace("h", "") );         //owtodoinjava

//Remove all matching characters
System.out.println( originalString.replace("o", "") );         //hwtdinjava

12. How to convert a String Uppercase or Lowercase?

Use String.toLowerCase() and String.toUpperCase() methods to convert string to lowercase or upper case.

String blogName = "HowToDoInJava.com";

System.out.println(blogName.toLowerCase());     //howtodoinjava.com

System.out.println(blogName.toUpperCase());     //HOWTODOINJAVA.COM

13. Can we use String in ‘switch‘ Statements?

Yes, we can use String class in switch statements since Java 7. Before Java 7, it was not possible and we had to use if-else statements to achieve similar behavior.

String number = "1";

switch (number)
{
case "1":
    System.out.println("One");	//Prints '1'
    break;
case "2":
    System.out.println("Two");
    break;
default:
    System.out.println("Other");
}

14. How to Print all Permutations of a String?

A permutation is a re-arrangement of the elements of characters so that each arrangement is unique with respect to other arrangements. e.g., below are the permutations of string “ABC” – ABC ACB BAC BCA CBA CAB.

A string of length N has N! (N Factorial) permutations.

import java.util.HashSet;
import java.util.Set;
 
public class StringExample 
{
    public static void main(String[] args) 
    {
        System.out.println(getPermutations("ABC")); 
 
        //Prints
        //[ACB, BCA, ABC, CBA, BAC, CAB]
    }
 
    public static Set<String> getPermutations(String string) 
    {
        //All permutations
        Set<String> permutationsSet = new HashSet<String>();
         
        // invalid strings
        if (string == null || string.length() == 0) 
        {
            permutationsSet.add("");
        } 
        else
        {
            //First character in String
            char initial = string.charAt(0); 
             
            //Full string without first character
            String rem = string.substring(1); 
             
            //Recursive call
            Set<String> wordSet = getPermutations(rem);
             
            for (String word : wordSet) {
                for (int i = 0; i <= word.length(); i++) {
                    permutationsSet.add(charInsertAt(word, initial, i));
                }
            }
        }
        return permutationsSet;
    }
 
    public static String charInsertAt(String str, char c, int position) 
    {
        String begin = str.substring(0, position);
        String end = str.substring(position);
        return begin + c + end;
    }
}

15. How to Reverse Each Word of a String?

To reverse each word separately, tokenize the string and get all words separated in an array. Then, apply reverse word logic to each word, and finally, concatenate all words.

String blogName = "how to do in java dot com";
 
//spilt on white space
String[] tokens = blogName.split(" ");
 
//It will store reversed words 
StringBuffer finalString = new StringBuffer();
 
//Loop all words and reverse them
for (String token : tokens) {
    String reversed = new StringBuffer(token).reverse().toString();
    finalString.append(reversed);
    finalString.append(" ");
}
 
//Check final string
System.out.println(finalString.toString());     //woh ot od ni avaj tod moc

16. How to Split a String?

Use String.split() method that breaks a given string around matches of the given regular expression. It’s also called get string tokens based on a delimiter.

The split() method returns the array of strings. Each string in the array is an individual token.

String numbers = "1,2,3,4,5,6,7";
         
String[] numArray = numbers.split(",");
 
System.out.println(Arrays.toString(numArray));  //[1, 2, 3, 4, 5, 6, 7]

17. Why We should not Use Strings for Storing the Passwords?

We know that strings are stored in the constant pool in Java. Once a string is created in the string pool, it stays in the pool unless it is garbage collected. By this time, any malicious program can access the memory area in the physical memory and access the string data as well.

If we store the password as a string, it will be held in the spring pool and available in memory for a longer duration than required because garbage collection cycles are unpredictable. This makes sensitive password strings vulnerable to hacking and data theft.

Can one option be argued to make String blank after using it? No, we cannot. We know that once a String is created, we cannot manipulate it e.g. you cannot change its content. Strings are final and immutable.

But char arrays are mutable, we can overwrite their content after using it. So our application shall use char[] to store password text, and after using the password, replace array content with a blank.

String password = "123456";     //Do not use it
         
char[] passwordChars = new char[4];      //Get password from some system such as database
 
//use password
 
for(char c : passwordChars) {
    c = ' ';
}

18. Are Strings Thread-safe?

Yes, strings are thread-safe because they are immutable.

Remember that all immutable instances are thread-safe, by design.

19. Why String are used as HashMap Keys?

In Java, a Map key shall be immutable and should honor the contract between equals() and hashCode() method. String class satisfies both conditions.

Also, the String class provides many useful methods to compare, sort, tokenize or lower-upper cases. These methods can be used while performing CRUD operations on Map.

All this makes String a very useful class to use in Map rather than creating our own class.

20. Difference between String, StringBuffer and StringBuilder?

  • String class represents a sequence of characters and provides useful methods to work with characters. String class instances are immutable. So each time we perform string concatenation using string class, a new object will be created with the concatenated string.
  • StringBuilder class is used to perform string concatenation operations in a more memory-efficient way. It internally maintains char[] and manipulates the content in this array only. When we need to get the complete concatenated string after performing all operations, it creates a new String with the stored character array.
  • StringBuffer is very much same as StringBuilder class. The only difference is that it is thread-safe. It’s all methods are synchronized.

21. How to Concatenate Multiple Strings?

Use StringBuffer or StringBuilder classes based on you need thread safety or not. Use append() methods in both classes to concatenate strings.

StringBuffer buffer = new StringBuffer();
         
buffer.append("how")
        .append("to")
        .append("do")
        .append("in")
        .append("java")
        .append(".")
        .append("com");
 
String blogName = buffer.toString();
 
System.out.println(blogName); //howtodoinjava.com

22. Count the Number of String Objects in Given Program?

String s1 = "howtodoinjava.com";
String s2 = "howtodoinjava.com";
String s3 = new String("howtodoinjava.com");
  1. Above code will create 2 objects.
  2. First object will be created in string pool by first statement.
  3. Second statement will not create any new object, and s2 will refer to same string constant as s1.
  4. Third statement will create a new string object in heap memory.

23. Count the Occurrences of Each Character in a String?

To find the number of occurrences of each character in a given string, we have used HashMap with the character as a key and its occurrence count as a value.

With each new occurrence of a character, we will increment the counter value for that character.

String blogName = "howtodoinjava.com";
 
HashMap<Character, Integer> occurancesMap = new HashMap<Character, Integer>();
 
char[] strArray = blogName.toCharArray();
 
for (char c : strArray)
{
    if(occurancesMap.containsKey(c))
    {
        occurancesMap.put(c, occurancesMap.get(c)+1);
    }
    else
    {
        occurancesMap.put(c, 1);
    }
}
 
System.out.println(occurancesMap);
//{a=2, c=1, d=1, h=1, i=1, j=1, m=1, n=1, .=1, o=4, t=1, v=1, w=1}

24. Reverse a String without StringBuilder or StringBuffer?

The best way to reverse a string is the StringBuffer.reverse() and StringBuilder.reverse() methods. Still, the interviewer may ask you to write your own program, to check your skill level.

Use the below-given recursion-based example to reverse the string.

This program takes the first character from the string and places it at the last position in the string. It uses this replacement for all characters in the string until the whole string is reversed.

public class StringExample
{
    public static void main(String[] args) 
    {
        String blogName = "howtodoinjava.com";
         
        String reverseString = recursiveSwap(blogName);
         
        System.out.println(reverseString);
    }
     
    static String recursiveSwap(String str)
    {
         if ((null == str) || (str.length() <= 1))
         {
                return str;
         }
         return recursiveSwap(str.substring(1)) + str.charAt(0);
    }
}

I can think of these frequently asked String interview questions will help you in your next interview. If you know any more questions specifically regarding String class, please share.

Happy Learning !!

Was this post helpful?

Join 7000+ Awesome Developers

Get the latest updates from industry, awesome resources, blog updates and much more.

* We do not spam !!

46 thoughts on “Java String Interview Questions with Answers”

  1. Feedback:
    In 25th questions, we should go with iterative approach. Recursion will be overhead here and also we are using substring() function too many times here, which is not memory efficient.

    Reply
  2. “`
    char[] passwordChars = new char[4]; //Get password from some system such as database

    //use password

    for(char c : passwordChars) {
    c = ‘ ‘;
    }
    “`
    You have copy of the original char in variable `c`, thus this code does not change `passwordChars `.

    Reply
  3. How many objects will be created and where those will be stored in below scenario:

    String s1 = “ABC”;
    String s2 = “XYZ”;
    s1.concat(s2);
    system.out.println(s1 + s2);

    Reply
  4. 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
    • It is in general that a String is checked for availability in String Constant Pool (SCP).
      When we create String str = new String(“how_to_do_in_java”), definitely a reference is created in SCP. But, reference of the object in heap memory is returned. Intern method is implemented in such a way that it would check for a reference in SCP. In our case when we create a String object using new operator, we are sure that it will create one reference in SCP.

      Reply
  5. 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
    • 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
    • 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
    • Because, s1 is pointing to address in Heap and not string pool . I tried the below. Now it shows true.

      String s1=new String(“abc”); //1st line
      s1=s1.intern(); //2nd line
      String s2=”abc”; //3nd line
      System.out.println(s1==s2); // true

      Reply
  6. 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
  7. 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?

    Reply
    • 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 = &quot;The god is great&quot;;
      
      		String[] arr = initial.split(&quot; &quot;);
      
      		List&lt;String&gt; 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(&quot; &quot;);
      			sb.append(word);
      		}
      		String result = sb.toString();
      		return result.replaceFirst(&quot; &quot;, &quot;&quot;);
      	}
      }
      
      Output:
      
      great is god The
      
      Reply
  8. 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
    • 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
  9. 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
    • 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
      • 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
  10. 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
  11. 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
  12. 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
  13. 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
    • 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
  14. 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
    • 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
      • 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
        • 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
  15. 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
  16. 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
  17. 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
  18. 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
    • 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

Leave a Comment

HowToDoInJava

A blog about Java and related technologies, the best practices, algorithms, and interview questions.