Java Strings, generally, can be said to be an object that demonstrates the sequences of char data values.We would be going through various steps during String initialization in Java. One can even think of an array of char data values working the same as Java strings. For example :

char[] c={S','h','u','b','h','a','m'}; 
String st=new String(c);

is same as

String st="Shubham";  

The Java String class gives us various methods to perform several operations on strings like concat(), compare(), split(), equals(), replace(), length(), compareTo(),substring(), intern(),

Also, the java.lang.String class in Java is there as an implementer of, Comparable, Serializational and CharSequence interfaces.

String in Java
The various implementations of the java.lang.String class

How to initialize Strings in Java ? — The CharSequence Interface

CharSequence interface is there and is generally helpful in representing represent the many sequences of char data values or characters. The StringBuffer, StringBuilder and the String classes in Java demonstrate it. This signifies to mean that, we can usually declare the various Java strings by the help of these three mentioned above classes.

CharSequence in Java
These three classes help declare various strings

Strings in Java is immutable that is, it cannot be altered or changed. Whenever there is a change in a String, a new object of it is created. Mutable strings are generally created by using StringBuilder and StringBuffer classes.

Now, let’s first understand the various ways to create the String objects in Java.

In this instructional exercise, we’ll center around the various methods concerning the initialization of Strings in Java.

Creation of Java Strings

Most importantly, we ought to recollect how Strings are made in Java.

We can utilize the new watchword or keyword or by using the Literal syntax:

String usingNew = new String("Shubham");
String usingLiteral = "Shubham";

Furthermore, it’s likewise significant that we see how Strings are overseen in a pool.

Declaring Strings

To start with, how about we simply proclaim a String, without providing an explicit value.

public class InitializingStrings 
    String fieldString;
    void printStringDeclaration() 
        String localString;

As should be obvious, in the event that we attempt to utilize localString, before giving it a suitable value, we’ll get an assemblage blunder. Also, the output in the console would show “null” as the value of the fieldString.

It’s just plain obvious, part factors are instated with a default value when the class is developed. Thus, the various variables are generally assigned with a default value during a class construction, like “null” as in String‘s. Therefore, we need to initialize local variable values by self.

It is thus, seen, that If we assign localString as “null“, the fieldString and the localString both become equal. As in:

String localString = null;
assertEquals(fieldString, localString);

String initialization in Java Using Literals

Let’s now create two Strings using the same literal:

String literalOne = "Shubham";
String literalTwo = "Shubham";
// Confirming that only one object is created by comparing the references:
assertTrue(literalOne == literalTwo);

The reason behind this, takes us back to the fact that Strings are stored in a pool. 

How to Initialize a String in Java Using new

We’ll see some unique conduct, however, on the off chance that we utilize the “new” keyword..

String newStringOne = new String("Shubham");
String newStringTwo = new String("Shubham");
// Although the value of both Strings will be the same as earlier, we’ll have to different objects this time:
assertFalse(newStringOne == newStringTwo);

How to initialize strings in Java using null Values

Let’s now see how null Strings show conduct.

//Declaring and Initializing a null value
String NValue = null;

On printing the value of  NValue , we’d see the word “null”.


The JVM specification states that null being the default or pre-assigned value for various references, is not particularly bound to String .

Thus, looking at  PrintStream’s #println implementation, we’ll see it calls String’s #valueOf:

public void println(Object s) {
    String st = String.valueOf(s);
    synchronized (this) {

Here, we can find our answer:

public static String valueOf(Object a) {
    return (a == null) ? "null" : a.toString();

So, this is the reason for the “null” value.


Thus, we have looked and done away with the various methods to initialize Strings in Java. Also, the minute difference between initialization and declaration has also been cleared. There was also an emphasis on using the literal syntax and the new keyword.

Lastly, we glanced over ways to assign null values to Strings. Also, we have seen how the null value is adjusted in memory, and how it looks when we display it.

Categorized in:

Tagged in:

, , ,