Quick Overview of Java String Class

Java String Class is present in java.util package.
A string is a sequence of characters. But, it’s not a primitive data type but an object.
String object is immutable in Java. So once created, we can’t change it.
String has a shortcut way to create its objects using double quotes. These string objects are also called string literals.
String is the only java class that supports operator overloading. We can use the ‘+’ operator to concatenate two strings.
Java store string objects in a specific pre-defined area. String pool is the part of java heap space to store string literals.
String is serializable in nature and implements Serializable interface.
Other interfaces implemented by String class are Comparable, CharSequence, Constable, and ConstantDesc. The Constable and ConstantDesc interfaces are part of Java 12 Constants API.

Different Ways to Create String in Java

There are two ways to create string objects in java program.

Using Double Quotes: A shortcut and special way to create strings. This is the easiest and preferred way to create a String object. The string object is created in the String Pool. For example, String s1 = "Hello";

Using new operator: We can also use new operator too for creating a string object. The string object is stored in the heap space and doesn’t take advantage of the string pool. For example, String s2 = new String("Hello");

Below image illustrates the process of creating strings using both the above methods.

Important Methods of String Class

Let’s look at some of the important methods of String class. Some of these methods are overloaded to handle different scenarios with the arguments.

length(): Returns the length of the string object.
charAt(int index): Returns the character value at the given index.
toCharArray(): this method creates a character array from this string.
getBytes(String charsetName): used to create a byte array from this string.
equals(Object anObject): used to compare this string with another object.
equalsIgnoreCase(String anotherString): used to compare this string with another string case-insensitively.
compareTo(String anotherString), compareToIgnoreCase(String str): compares this string to another string lexicographically. The first one being case-sensitive and the second one performs case insensitive comparison.
startsWith(String prefix): returns true if this string starts with the given string.
endsWith(String suffix): returns true if this string ends with the given string.
substring(int beginIndex, int endIndex): returns a substring of this string.
concat(String str): Concatenates the given string to the end of this string and return it.
replace(char oldChar, char newChar): returns a new string after replacing oldChar with the newChar.
matches(String regex): checks whether this string matches the given regular expression.
split(String regex): splits this string into a string array using the regular expression argument.
join(CharSequence delimiter, CharSequence... elements): A utility method to join many strings into a new string with the specified delimiter. We can use this method to create a CSV record from the array of strings.
toLowerCase(), toUpperCase(): used to get the lowercase and uppercase version of this string.
trim(): used to remove leading and trailing whitespaces from this string.
strip(), stripLeading(), stripTrailing(): returns new string after stripping white spaces from this string. If you are confused what’s the difference between strip() and trim() – there are none. Both of them perform the same task but strip() method is more readable. It goes in line with similar methods in other programming languages.
isBlank(): returns true if the string is empty or contains only white spaces.
lines(): introduced in Java 11, returns a stream of lines from this string.
indent(int n): introduced in Java 12, returns an indented string based on the argument value.
transform(Function<? super String, ? extends R> f): introduced in Java 12 to apply a function to this string. The function should accept a single string argument and return R.
format(String format, Object... args): returns a formatted string using the specified format and arguments.
valueOf(Object obj): returns the string representation of the given object. There are overloaded versions to work with primitive data types, arrays, and objects.
intern(): returns the string from the string pool.
repeat(int count): returns a new string after concatenating this string specified times.
describeConstable(), resolveConstantDesc(MethodHandles.Lookup lookup): implemented for Java 12 Constants API.

Benefits of String Immutability

String Pool is possible because String is immutable. Hence saving memory and fast performance.
More secure since we can’t change the value of string object.
Thread safety while working with strings in a multi-threaded environment.
Class loading is more secure since the string value passed as an argument to load a class can’t be changed.

Quick Word on StringBuffer and StringBuilder

String immutability provides a lot of benefits. But, when we have to manipulate strings, it causes a lot of memory and inefficient operations.
That’s why there are two classes for string manipulation – StringBuffer and StringBuilder. Both of them provide similar operations. But, StringBuffer is synchronized and StringBuilder is not.

Java String Pool

Java String Pool is the special area in the heap memory to store string objects. There are two ways to create string objects. If we use double quotes to create a string object, it’s stored in the string pool. If we use the new operator to create a string, it’s created in the heap memory.

Table of Contents

How Does Java String Pool Works?

When we create a string literal, it’s stored in the string pool.
If there is already a string with the same value in the string pool, then new string object is not created. The reference to the existing string object is returned.
Java String Pool is a cache of string objects. It’s possible because string is immutable.
If we create a string object using new operator, it’s created in the heap area. If we want to move it to the string pool, we can use intern()method.
String Pool is a great example of Flyweight design pattern.

Understanding String Pool With a Program

Let’s understand the working of string pool with a simple program.

package net.javastring.strings;

public class JavaStringPool {

    public static void main(String[] args) {

        String s1 = "Hello";

        String s2 = "Hello";

        String s3 = new String("Hi");

        String s4 = "Hi";

        System.out.println("s1 == s2? " + (s1 == s2));

        System.out.println("s3 == s4? " + (s3 == s4));

        s3 = s3.intern();

        System.out.println("s3 == s4? " + (s3 == s4));

    }

}

When we create the first string s1, there is no string with the value “Hello” in the string pool. So a string “Hello” is created in the pool and its reference is assigned to s1.
When we are creating second string s2, there is already a string with the value “Hello” in the string pool. The existing string reference is assigned to s2.
When we create third string s3, it’s created in the heap area because we are using the new operator.
When we create fourth string s4, a new string with the value “Hi” is created in the pool and its reference is assigned to s4.
When we compare s1 == s2, it returns true because both the variables are referring to the same string object.
When we compare s3 == s4, it returns false because they point to the different string objects.
When we call intern() method on s3, it checks if there is any string in the pool with the value “Hi”? Since we already have a string with this value in the pool, its reference is returned and assigned to s3.
Now s3 == s4returns true because both the variables are referring to the same string objects.

What are the Benefits of Java String Pool?

Let’s look at some of the benefits of java string pool.

Java String Pool allows caching of string objects. This saves a lot of memory for JVM that can be used by other objects.
Java String Pool helps in better performance of the application because of reusability. It saves time to create a new string if there is already a string present in the pool with the same value.

Why we should never create String using new operator?

Let’s look at the code snippet to create a string using new operator.

String s3 = new String("Hi");

A new string with value “Hi” is created in the string pool.
Then the String constructor is called by passing the string created in the above step.
A new string is created in the heap space and its reference is assigned to s3.
The string created in the first step is orphan and available for garbage collection.
We ended up creating two strings when we wanted to create a single string in the heap area.

Java String contains() Method Examples

Java String contains() method returns true if this string contains the given character sequence.

Table of Contents

Java String contains() method signature

String contains() method signature is:

public boolean contains(CharSequence s)

Important Points for contains() method

This utility method was introduced in Java 1.5
It uses indexOf() method to check if this string contains the argument string or not.
If the argument is null then NullPointerException will be thrown.
This method is case sensitive. For example, "x".contains("X"); will return false.
You can convert both the strings to lowercase for case insensitive operation. For example, "x".toLowerCase().contains("X".toLowerCase()); will return true.

Java String equals() Method – Always Use This to Check String Equality

Java String equals() method compares this string to another object.

Table of Contents

Java String equals() Signature

String equals() method signature is:

public boolean equals(Object anObject)

The result is true if the argument is String having the same value as this string. For all other cases, it will return false. If we pass null argument, then the method will return false.

Why equals() Method Parameter is Not String?

It’s an interesting question. It makes prefect sense to have the method parameter as String because we are checking equality between two string objects.

So why this method argument is Object?

It’s because String equals() method is overriding Object class equals() method. You can confirm this by looking at the equals() method java documentation too.

Important Points about String equals() Method

Java String equals() method overrides the Object class equals() method.
If you want to check two strings for equality, you should always use equals() method.
String equals() method doesn’t throw any exception. It always returns a boolean result.
If you are looking to check equality ignoring case, then use equalsIgnoreCase() method.

Java String equals() Method Example

Let’s look at a simple example of String equals() method.

package net.javastring.strings;

public class JavaStringEquals {

    public static void main(String[] args) {

        String s1 = "abc";

        String s2 = "abc";

        System.out.println("s1 is equal to s2? " + (s1.equals(s2)));

    }

}

Java String equals() and equalsIgnoreCase() Example

Let’s look at another example where we will accept two strings from user input. Then we will check their equality using equals() and equalsIgnoreCase() methods.

package net.javastring.strings;

import java.util.Scanner;

public class JavaStringEquals {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("Enter The First String:");

        String str1 = sc.nextLine();

        System.out.println("Enter The Second String:");

        String str2 = sc.nextLine();

        sc.close();

        System.out.println("Both the input Strings are Equal? = " + str1.equals(str2));

        System.out.println("Both the input Strings are Case Insensitive Equal? = " + str1.equalsIgnoreCase(str2));

    }

}