Core Java

Top 10 Questions of Java Strings

The following are top 10 frequently asked questions about Java Strings.

1. How to compare strings? Use “==” or use equals()?

In brief, “==” tests if references are equal and equals() tests if values are equal. Unless you want to check if two strings are the same object, you should always use equals().

It would be better if you know the concept of string interning.

2. Why is char[] preferred over String for security sensitive information?

Strings are immutable, which means once they are created, they will stay unchanged until Garbage Collector kicks in. With an array, you can explicitly change its elements. In this way, security sensitive information(e.g. password) will not be present anywhere in the system.

3. Can we use string for switch statement?

Yes to version 7. From JDK 7, we can use string as switch condition. Before version 6, we can not use string as switch condition.

// java 7 only!
switch (str.toLowerCase()) {
      case "a":
           value = 1;
           break;
      case "b":
           value = 2;
           break;
}

4. How to convert string to int?

int n = Integer.parseInt("10");

Simple, but so frequently used and sometimes ignored.

5. How to split a string with white space characters?

We can simple do split using regular expression. “\s” stands for white space characters such as ” “, “\t”, “\r”, “\n”.

String[] strArray = aString.split("\\s+");

6. Does substring() method create a new string?

The answer is no. The substring() method gives a window to an array of chars which represents the existing String, but do not create a new one. To create a new string, you can do add an empty string like the following:

str.substring(m, n) + ""

This will create a new string. The above approach sometimes can make your code faster, because Garbage Collector can collect the unused large string and keep only the sub string.

In Oracle JDK 7, substring() creates a new string. Check out the diagram for showing substring() difference between JDK 6 and JDK 7.

7. String vs StringBuilder vs StringBuffer

String vs StringBuilder: StringBuilder is mutable, which means you can modify it after its creation.
StringBuilder vs StringBuffer: StringBuffer is synchronized, which means it is thread-safe but slower than StringBuilder.

8. How to repeat a string?

In Python, we can just multiple a number to repeat a string. In Java, we can use the repeat() method of StringUtils from Apache Commons Lang package.

String str = "abcd";
String repeated = StringUtils.repeat(str,3);
//abcdabcdabcd

9. How to convert string to date?

String str = "Sep 17, 2013";
Date date = new SimpleDateFormat("MMMM d, yy", Locale.ENGLISH).parse(str);
System.out.println(date);
//Tue Sep 17 00:00:00 EDT 2013

10. How to count # of occurrences of a character in a string?

Use StringUtils from apache commons lang.

int n = StringUtils.countMatches("11112222", "1");
System.out.println(n);

One more
Do you know How to detect if a string contains only uppercase letter?

Related Articles:

Reference: Top 10 FAQs of Java Strings from our JCG partner Ryan Wang at the Programcreek blog.
Subscribe
Notify of
guest

This site uses Akismet to reduce spam. Learn how your comment data is processed.

5 Comments
Oldest
Newest Most Voted
Inline Feedbacks
View all comments
Jaromir Hamala
Jaromir Hamala
10 years ago

The point no. 6 is no longer true. The Oracle JDK 7+ does not reuse the char[] from the original String, but it create a new one.

John
John
10 years ago
Reply to  ProgramCreek

From the jdk 1.6.0.18 :
public String substring(int beginIndex, int endIndex) {
if (beginIndex count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex – beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex – beginIndex, value);
}

Vess
Vess
10 years ago
Reply to  ProgramCreek

public String substring(int beginIndex, int endIndex) {
if (beginIndex count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex – beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex – beginIndex, value);
}

This is the implementation of the method in Oracle JDK 6.
And from JDK7 documentation:
http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#substring(int)

Jaromir Hamala
Jaromir Hamala
10 years ago
Reply to  ProgramCreek

Hi,

check this out: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/lang/String.java#String.substring%28int%2Cint%29

the substring() method indeed passes the original char[], offset and count, but the constructor in OpenJDK 7 creates a copy of the char[]: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/lang/String.java#234

Back to top button