Java Strings
In Java, a string is a sequence of characters. For example, "hello" is a
string containing a sequence of characters 'h' , 'e' , 'l' , 'l' , and 'o' .
We use double quotes to represent a string in Java. For example,
// create a string
String type = "Java programming";
Example: Create a String in Java
class Main {
public static void main(String[] args) {
// create strings
String first = "Java";
String second = "Python";
String third = "JavaScript";
// print strings
System.out.println(first); // print Java
System.out.println(second); // print Python
System.out.println(third); // print JavaScript
}
}
Run Code
In the above example, we have created three strings named first , second ,
and third .
Here, we are directly creating strings like primitive types.
However, there is another way of creating Java strings (using
the new keyword).
Note: Strings in Java are not primitive types (like int , char , etc). Instead,
all strings are objects of a predefined class named String .
And all string variables are instances of the String class.
Java String Operations
Java provides various string methods to perform different operations on
strings. We will look into some of the commonly used string operations.
1. Get the Length of a String
To find the length of a string, we use the length() method. For example,
class Main {
public static void main(String[] args) {
// create a string
String greet = "Hello! World";
System.out.println("String: " + greet);
// get the length of greet
int length = greet.length();
System.out.println("Length: " + length);
}
}
Run Code
Output
String: Hello! World
Length: 12
In the above example, the length() method calculates the total number of
characters in the string and returns it.
2. Join Two Java Strings
We can join two strings in Java using the concat() method. For example,
class Main {
public static void main(String[] args) {
// create first string
String first = "Java ";
System.out.println("First String: " + first);
// create second
String second = "Programming";
System.out.println("Second String: " + second);
// join two strings
String joinedString = first.concat(second);
System.out.println("Joined String: " + joinedString);
}
}
Run Code
Output
First String: Java
Second String: Programming
Joined String: Java Programming
In the above example, we have created two strings
named first and second . Notice the statement,
String joinedString = first.concat(second);
Here, the concat() method joins the second string to the first string and
assigns it to the joinedString variable.
We can also join two strings using the + operator in Java.
3. Compare Two Strings
In Java, we can make comparisons between two strings using
the equals() method. For example,
class Main {
public static void main(String[] args) {
// create 3 strings
String first = "java programming";
String second = "java programming";
String third = "python programming";
// compare first and second strings
boolean result1 = first.equals(second);
System.out.println("Strings first and second are equal: " +
result1);
// compare first and third strings
boolean result2 = first.equals(third);
System.out.println("Strings first and third are equal: " +
result2);
}
}
Run Code
Output
Strings first and second are equal: true
Strings first and third are equal: false
In the above example, we have created 3 strings named first , second ,
and third .
Here, we are using the equal() method to check if one string is equal to
another.
The equals() method checks the content of strings while comparing them.
Escape Character in Java Strings
Java Strings are Immutable
In Java, strings are immutable. This means once we create a string, we
cannot change that string.
To understand it more thoroughly, consider an example:
// create a string
String example = "Hello! ";
Here, we have created a string variable named example . The variable holds
the string "Hello! " .
Now, suppose we want to change the string.
// add another string "World"
// to the previous tring example
example = example.concat(" World");
Here, we are using the concat() method to add another string "World" to
the previous string.
It looks like we are able to change the value of the previous string.
However, this is not true .
Let's see what has happened here:
1. JVM takes the first string "Hello! "
2. creates a new string by adding "World" to the first string
3. assigns the new string "Hello! World" to the example variable
4. The first string "Hello! " remains unchanged
Creating Strings Using the New Keyword
So far, we have created strings like primitive types in Java.
Since strings in Java are objects, we can create strings using
the new keyword as well. For example,
// create a string using the new keyword
String name = new String("Java String");
In the above example, we have created a string name using
the new keyword.
Here, when we create a string object, the String() constructor is invoked.
Note: The String class provides various other constructors to create
strings. To learn more, visit Java String (official Java documentation).
Example: Create Java Strings Using the New
Keyword
class Main {
public static void main(String[] args) {
// create a string using new
String name = new String("Java String");
System.out.println(name); // print Java String
}
}
Run Code
Create String Using Literals vs. New Keyword
Now that we know how strings are created using string literals and
the new keyword, let's see what is the major difference between them.
In Java, the JVM maintains a string pool to store all of its strings inside the
memory. The string pool helps in reusing the strings.
1. While creating strings using string literals,
String example = "Java";
Here, we are directly providing the value of the string ( Java ). Hence, the
compiler first checks the string pool to see if the string already exists.
If the string already exists, the new string is not created. Instead,
the new reference, example points to the already existing string
( Java ).
If the string doesn't exist, a new string ( Java) is created.
2. While creating strings using the new keyword,
String example = new String("Java");
Here, the value of the string is not directly provided. Hence, a
new "Java" string is created even though "Java" is already present inside
the memory pool.
