Java String charAt()

The Java String class charAt() method returns a char value at the given index number.

The index number starts from 0 and goes to n-1, where n is the length of the string. It returns StringIndexOutOfBoundsException, if the given index number is greater than or equal to this string length or a negative number.

Syntax

public char charAt(int index)

The method accepts index as a parameter. The starting index is 0. It returns a character at a specific index position in a string. It throws StringIndexOutOfBoundsException if the index is a negative value or greater than this string length.

Specified by

CharSequence interface, located inside java.lang package.

Internal implementation

public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}

Java String charAt() Method Examples

Let's see Java program related to string in which we will use charAt() method that perform some operation on the give string.

FileName: CharAtExample.java

public class CharAtExample{
public static void main(String args[]){
String name="javatpoint";
char ch=name.charAt(4);//returns the char value at the 4th index
System.out.println(ch);
}}

Test it Now

Output:

Let's see the example of the charAt() method where we are passing a greater index value. In such a case, it throws StringIndexOutOfBoundsException at run time.

FileName: CharAtExample.java

public class CharAtExample{
public static void main(String args[]){
String name="javatpoint";
char ch=name.charAt(10);//returns the char value at the 10th index
System.out.println(ch);
}}

Output:

Exception in thread "main" java.lang.StringIndexOutOfBoundsException: 

String index out of range: 10

at java.lang.String.charAt(String.java:658)

at CharAtExample.main(CharAtExample.java:4)

Accessing First and Last Character by Using the charAt() Method

Let's see a simple example where we are accessing first and last character from the provided string.

FileName: CharAtExample3.java

public class CharAtExample3 {
public static void main(String[] args) {
String str = "Welcome to Javatpoint portal";
int strLength = str.length();
// Fetching first character
System.out.println("Character at 0 index is: "+ str.charAt(0));
// The last Character is present at the string length-1 index
System.out.println("Character at last index is: "+ str.charAt(strLength-1));
}
}

Output:

Character at 0 index is: W

Character at last index is: l

Print Characters Presented at Odd Positions by Using the charAt() Method

Let's see an example where we are accessing all the elements present at odd index.

FileName: CharAtExample4.java

public class CharAtExample4 {
public static void main(String[] args) {
String str = "Welcome to Javatpoint portal";
for (int i=0; i<=str.length()-1; i++) {
if(i%2!=0) {
System.out.println("Char at "+i+" place "+str.charAt(i));
}
}
}
}

Output:

ADAD

Char at 1 place e

Char at 3 place c

Char at 5 place m

Char at 7 place  

Char at 9 place o

Char at 11 place J

Char at 13 place v

Char at 15 place t

Char at 17 place o

Char at 19 place n

Char at 21 place  

Char at 23 place o

Char at 25 place t

Char at 27 place l

The position such as 7 and 21 denotes the space.

Counting Frequency of a character in a String by Using the charAt() Method

Let's see an example in which we are counting frequency of a character in the given string.

FileName: CharAtExample5.java

public class CharAtExample5 {
public static void main(String[] args) {
String str = "Welcome to Javatpoint portal";
int count = 0;
for (int i=0; i<=str.length()-1; i++) {
if(str.charAt(i) == 't') {
count++;
}
}
System.out.println("Frequency of t is: "+count);
}
}

Output:

Frequency of t is: 4

Counting the Number of Vowels in a String by Using the chatAt() Method

Let's see an example where we are counting the number of vowels present in a string with the help of the charAt() method.

ADAD

FileName: CharAtExample6.java

// import statement
import java.util.*;
public class CharAtExample6
{
ArrayList<Character> al;
// constructor for creating and
// assigning values to the ArrayList al
CharAtExample6()
{
al = new ArrayList<Character>();
al.add('A'); al.add('E');
al.add('a'); al.add('e');
al.add('I'); al.add('O');
al.add('i'); al.add('o');
al.add('U'); al.add('u');
}
// a method that checks whether the character c is a vowel or not
private boolean isVowel(char c)
{
for(int i = 0; i < al.size(); i++)
{
if(c == al.get(i))
{
return true;
}
}
return false;
}
// a method that calculates vowels in the String s
public int countVowels(String s)
{
int countVowel = 0; // store total number of vowels
int size = s.length(); // size of string
for(int j = 0; j < size; j++)
{
char c = s.charAt(j);
if(isVowel(c))
{
// vowel found!
// increase the count by 1
countVowel = countVowel + 1;
}
}
return countVowel;
}
// main method
public static void main(String argvs[])
{
// creating an object of the class CharAtExample6
CharAtExample6 obj = new CharAtExample6();
String str = "Javatpoint is a great site for learning Java.";
int noOfVowel = obj.countVowels(str);
System.out.println("String: " + str);
System.out.println("Total number of vowels in the string are: "+ noOfVowel + "\n");
str = "One apple in a day keeps doctor away.";
System.out.println("String: " + str);
noOfVowel = obj.countVowels(str);
System.out.println("Total number of vowels in the string are: "+ noOfVowel);
}
}

Output:

String: Javatpoint is a great site for learning Java.

Total number of vowels in the string are: 16



String: One apple in a day keeps doctor away.

Total number of vowels in the string are: 13

=============================================================================

Java String compareTo()

The Java String class compareTo() method compares the given string with the current string lexicographically. It returns a positive number, negative number, or 0.

It compares strings on the basis of the Unicode value of each character in the strings.

If the first string is lexicographically greater than the second string, it returns a positive number (difference of character value). If the first string is less than the second string lexicographically, it returns a negative number, and if the first string is lexicographically equal to the second string, it returns 0.

if s1 > s2, it returns positive number
if s1 < s2, it returns negative number
if s1 == s2, it returns 0

Syntax

public int compareTo(String anotherString)

The method accepts a parameter of type String that is to be compared with the current string.

It returns an integer value. It throws the following two exceptions:

ClassCastException: If this object cannot get compared with the specified object.

NullPointerException: If the specified object is null.

Internal implementation

int compareTo(String anotherString) {
int length1 = value.length;
int length2 = anotherString.value.length;
int limit = Math.min(length1, length2);
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (i < limit) {
char ch1 = v1[i];
char ch2 = v2[i];
if (ch1 != ch2) {
return ch1 - ch2;
}
i++;
}
return length1 - length2;
}

Java String compareTo() Method Example

FileName: CompareToExample.java

public class CompareToExample{
public static void main(String args[]){
String s1="hello";
String s2="hello";
String s3="meklo";
String s4="hemlo";
String s5="flag";
System.out.println(s1.compareTo(s2));//0 because both are equal
System.out.println(s1.compareTo(s3));//-5 because "h" is 5 times lower than "m"
System.out.println(s1.compareTo(s4));//-1 because "l" is 1 times lower than "m"
System.out.println(s1.compareTo(s5));//2 because "h" is 2 times greater than "f"
}}

Test it Now

Output:

Java String compareTo(): empty string

When we compare two strings in which either first or second string is empty, the method returns the length of the string. So, there may be two scenarios:

If first string is an empty string, the method returns a negative
If second string is an empty string, the method returns a positive number that is the length of the first string.

FileName: CompareToExample2.java

public class CompareToExample2{
public static void main(String args[]){
String s1="hello";
String s2="";
String s3="me";
System.out.println(s1.compareTo(s2));
System.out.println(s2.compareTo(s3));
}}

Test it Now

Output:

5

-2

Java String compareTo(): case sensitive

To check whether the compareTo() method considers the case sensitiveness of characters or not, we will make the comparison between two strings that contain the same letters in the same sequence.

Suppose, a string having letters in uppercase, and the second string having the letters in lowercase. On comparing these two string, if the outcome is 0, then the compareTo() method does not consider the case sensitiveness of characters; otherwise, the method considers the case sensitiveness of characters.

FileName: CompareToExample3.java

public class CompareToExample3
{
// main method
public static void main(String argvs[])
{
// input string in uppercase
String st1 = new String("INDIA IS MY COUNTRY");
// input string in lowercase
String st2 = new String("india is my country");
System.out.println(st1.compareTo(st2));
}
}

Output:

-32

Conclusion: It is obvious by looking at the output that the outcome is not equal to zero. Hence, the compareTo() method takes care of the case sensitiveness of characters.

ADAD

Java String compareTo(): ClassCastException

The ClassCastException is thrown when objects of incompatible types get compared. In the following example, we are comparing an object of the ArrayList (al) with a string literal ("Sehwag").

FileName: CompareToExample4.java

// import statement
import java.util.*;
class Players
{
private String name;
// constructor of the class
public Players(String str)
{
name = str;
}
}
public class CompareToExample4
{
// main method
public static void main(String[] args)
{
Players ronaldo = new Players("Ronaldo");
Players sachin = new Players("Sachin");
Players messi = new Players("Messi");
ArrayList<Players> al = new ArrayList<>();
al.add(ronaldo);
al.add(sachin);
al.add(messi);
// performing binary search on the list al
Collections.binarySearch(al, "Sehwag", null);
}
}

Output:

Exception in thread "main" java.lang.ClassCastException: class Players cannot be cast to class java.lang.Comparable

Java String compareTo(): NullPointerException

The NullPointerException is thrown when a null object invokes the compareTo() method. Observe the following example.

FileName: CompareToExample5.java

ADAD

public class CompareToExample5
{
// main method
public static void main(String[] args)
{
String str = null;
// null is invoking the compareTo method. Hence, the NullPointerException
// will be raised
int no = str.compareTo("India is my country.");
System.out.println(no);
}
}

Output:

Exception in thread "main" java.lang.NullPointerException

	at CompareToExample5.main(CompareToExample5.java:9)

=============================================================================

Java String concat

The Java String class concat() method combines specified string at the end of this string. It returns a combined string. It is like appending another string.

Signature

The signature of the string concat() method is given below:

public String concat(String anotherString)

Parameter

anotherString : another string i.e., to be combined at the end of this string.

Returns

combined string

Internal implementation

public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}

Java String concat() method example

FileName: ConcatExample.java

public class ConcatExample{
public static void main(String args[]){
String s1="java string";
// The string s1 does not get changed, even though it is invoking the method
// concat(), as it is immutable. Therefore, the explicit assignment is required here.
s1.concat("is immutable");
System.out.println(s1);
s1=s1.concat(" is immutable so assign it explicitly");
System.out.println(s1);
}}

Test it Now

Output:

java string

java string is immutable so assign it explicitly

Java String concat() Method Example 2

Let's see an example where we are concatenating multiple string objects.

FileName: ConcatExample2.java

public class ConcatExample2 {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "Javatpoint";
String str3 = "Reader";
// Concatenating one string
String str4 = str1.concat(str2);
System.out.println(str4);
// Concatenating multiple strings
String str5 = str1.concat(str2).concat(str3);
System.out.println(str5);
}
}

Output:

HelloJavatpoint

HelloJavatpointReader

Java String concat() Method Example 3

Let's see an example where we are concatenating spaces and special chars to the string object. It is done using the chaining of the concat() method.

FileName: ConcatExample3.java

public class ConcatExample3 {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "Javatpoint";
String str3 = "Reader";
// Concatenating Space among strings
String str4 = str1.concat(" ").concat(str2).concat(" ").concat(str3);
System.out.println(str4);
// Concatenating Special Chars
String str5 = str1.concat("!!!");
System.out.println(str5);
String str6 = str1.concat("@").concat(str2);
System.out.println(str6);
}
}

Output:

Hello Javatpoint Reader

Hello!!!

<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="afe7cac3c3c0efe5ced9cedbdfc0c6c1db">[email protected]</a>

Java String concat() Method Example 4

Till now, we have seen that the concat() method appends the string at the end of the string that invokes the method. However, we can do a bit of workaround to append the string at the beginning of a string using the concat() method.

FileName: ConcatExample4.java

// A Java program that shows how to add
// a string at the beginning of another string
public class ConcatExample4
{
// main method
public static void main(String argvs[])
{
String str = "Country";
// we have added the string "India is my" before the String str;
// Also, observe that a string literal can also invoke the concat() method
String s = "India is my ".concat(str);
// displaying the string
System.out.println(s);
}
}

Output:

India is my Country

===========================================================================

Java String contains()

The Java String class contains() method searches the sequence of characters in this string. It returns true if the sequence of char values is found in this string otherwise returns false.

Signature

The signature of string contains() method is given below:

public boolean contains(CharSequence sequence)

Parameter

sequence : specifies the sequence of characters to be searched.

Returns

true if the sequence of char value exists, otherwise false.

Exception

NullPointerException : if the sequence is null.

Internal implementation

public boolean contains(CharSequence s) {
return indexOf(s.toString()) > -1;
}

Here, the conversion of CharSequence takes place into String. After that, the indexOf() method is invoked. The method indexOf() either returns 0 or a number greater than 0 in case the searched string is found.

However, when the searched string is not found, the indexOf() method returns -1. Therefore, after execution, the contains() method returns true when the indexOf() method returns a non-negative value (when the searched string is found); otherwise, the method returns false.

Java String contains() Method Example

FileName: ContainsExample.java

class ContainsExample{
public static void main(String args[]){
String name="what do you know about me";
System.out.println(name.contains("do you know"));
System.out.println(name.contains("about"));
System.out.println(name.contains("hello"));
}}

Test it Now

Output:

true

true

false

Java String contains() Method Example 2

The contains() method searches case-sensitive char sequence. If the argument is not case sensitive, it returns false. Let's see an example.

FileName: ContainsExample2.java

public class ContainsExample2 {
public static void main(String[] args) {
String str = "Hello Javatpoint readers";
boolean isContains = str.contains("Javatpoint");
System.out.println(isContains);
// Case Sensitive
System.out.println(str.contains("javatpoint")); // false
}
}

Output:

true

false

Java String contains() Method Example 3

The contains() method is helpful to find a char-sequence in the string. We can use it in the control structure to produce the search-based result. Let's see an example.

FileName: ContainsExample3.java

public class ContainsExample3 {
public static void main(String[] args) {
String str = "To learn Java visit Javatpoint.com";
if(str.contains("Javatpoint.com")) {
System.out.println("This string contains javatpoint.com");
}else
System.out.println("Result not found");
}
}

Output:

This string contains javatpoint.com

ADAD

Java String contains() Method Example 4

The contains() method raises the NullPointerException when one passes null in the parameter of the method. The following example shows the same.

FileName: ContainsExample4.java

public class ContainsExample4
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint!";
// comparing a string to null
if(str.contains(null))
{
System.out.println("Inside the if block");
}
else
{
System.out.println("Inside the else block");
}
}
}

Output:

Exception in thread "main" java.lang.NullPointerException

	at java.base/java.lang.String.contains(String.java:2036)

	at ContainsExample4.main(ContainsExample4.java:9)

Limitations of the Contains() method

Following are some limitations of the contains() method:

The contains() method should not be used to search for a character in a string. Doing so results in an error.
The contains() method only checks for the presence or absence of a string in another string. It never reveals at which index the searched index is found. Because of these limitations, it is better to use the indexOf() method instead of the contains() method.

The Java String class contains() method searches the sequence of characters in this string. It returns true if the sequence of char values is found in this string otherwise returns false.

Signature

The signature of string contains() method is given below:

public boolean contains(CharSequence sequence)

Parameter

sequence : specifies the sequence of characters to be searched.

Returns

true if the sequence of char value exists, otherwise false.

Exception

NullPointerException : if the sequence is null.

Internal implementation

public boolean contains(CharSequence s) {
return indexOf(s.toString()) > -1;
}

Java String contains() Method Example

FileName: ContainsExample.java

class ContainsExample{
public static void main(String args[]){
String name="what do you know about me";
System.out.println(name.contains("do you know"));
System.out.println(name.contains("about"));
System.out.println(name.contains("hello"));
}}

Test it Now

Output:

true

true

false

Java String contains() Method Example 2

The contains() method searches case-sensitive char sequence. If the argument is not case sensitive, it returns false. Let's see an example.

FileName: ContainsExample2.java

public class ContainsExample2 {
public static void main(String[] args) {
String str = "Hello Javatpoint readers";
boolean isContains = str.contains("Javatpoint");
System.out.println(isContains);
// Case Sensitive
System.out.println(str.contains("javatpoint")); // false
}
}

Output:

true

false

Java String contains() Method Example 3

The contains() method is helpful to find a char-sequence in the string. We can use it in the control structure to produce the search-based result. Let's see an example.

FileName: ContainsExample3.java

public class ContainsExample3 {
public static void main(String[] args) {
String str = "To learn Java visit Javatpoint.com";
if(str.contains("Javatpoint.com")) {
System.out.println("This string contains javatpoint.com");
}else
System.out.println("Result not found");
}
}

Output:

This string contains javatpoint.com

ADAD

Java String contains() Method Example 4

The contains() method raises the NullPointerException when one passes null in the parameter of the method. The following example shows the same.

FileName: ContainsExample4.java

public class ContainsExample4
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint!";
// comparing a string to null
if(str.contains(null))
{
System.out.println("Inside the if block");
}
else
{
System.out.println("Inside the else block");
}
}
}

Output:

Exception in thread "main" java.lang.NullPointerException

	at java.base/java.lang.String.contains(String.java:2036)

	at ContainsExample4.main(ContainsExample4.java:9)

Limitations of the Contains() method

Following are some limitations of the contains() method:

The contains() method should not be used to search for a character in a string. Doing so results in an error.
The contains() method only checks for the presence or absence of a string in another string. It never reveals at which index the searched index is found. Because of these limitations, it is better to use the indexOf() method instead of the contains() method.

============================================================================

Java String endsWith()

The Java String class endsWith() method checks if this string ends with a given suffix. It returns true if this string ends with the given suffix; else returns false.

Signature

The syntax or signature of endsWith() method is given below.

public boolean endsWith(String suffix)

Parameter

suffix : Sequence of character

Returns

true or false

Internal implementation

public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}

The internal implementation shows that the endWith() method is dependent on the startsWith() method of the String class.

Java String endsWith() Method Example

FileName: EndsWithExample.java

public class EndsWithExample{
public static void main(String args[]){
String s1="java by javatpoint";
System.out.println(s1.endsWith("t"));
System.out.println(s1.endsWith("point"));
}}

Test it Now

Output:

true

true

Java String endsWith() Method Example 2

Since the endsWith() method returns a boolean value, the method can also be used in an if statement. Observe the following program.

FileName: EndsWithExample2.java

public class EndsWithExample2 {
public static void main(String[] args) {
String str = "Welcome to Javatpoint.com";
System.out.println(str.endsWith("point"));
if(str.endsWith(".com")) {
System.out.println("String ends with .com");
}else System.out.println("It does not end with .com");
}
}

Output:

false

String ends with .com

Java String endsWith() Method Example 3

The endsWith() method takes care of the case sensitiveness of the characters present in a string. The following program shows the same.

FileName: EndsWithExample3.java

public class EndsWithExample3
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint";
// the result of the following display statement
// shows endsWith() considers the case sensitiveness of
// the charaters of a string
System.out.println(str.endsWith("javaTpoint")); // false because J and j are different
System.out.println(str.endsWith("Javatpoint")); // false because T and t are different
System.out.println(str.endsWith("JavaTpoint")); // true because every character is same
}
}

Output:

false

false

true

ADAD

Java String endsWith() Method Example 4

When an empty string is passed in the parameter of the method endsWith(), the method always returns a true value. The reason behind this is that a string never changes when we append an empty string to it. For example,

The statement

String str = "Ladies and Gentlemen" + "";

results in

str = "Ladies and Gentlemen";

ADAD

Thus, we can say that any string in Java ends with an empty string (""). Observe the

FileName: EndsWithExample4.java

public class EndsWithExample4
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint";
// prints true
System.out.println(str.endsWith(""));
// prints false as there is no white space after the string
System.out.println(str.endsWith(" "));
}
}

Output:

true

false

Java String endsWith() Method Example 5

The endsWith() method raises the NullPointerException if one passes null in the parameter of the method. The following example shows the same.

FileName: EndsWithExample5.java

ADAD

public class EndsWithExample5
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint!";
// invoking the method endsWith with the parameter as null
if(str.endsWith(null))
{
System.out.println("Inside the if block");
}
else
{
System.out.println("Inside the else block");
}
}
}

Output:

Exception in thread "main" java.lang.NullPointerException

	at java.base/java.lang.String.endsWith(String.java:1485)

	at EndsWithExample5.main(EndsWithExample5.java:9)

Java String endsWith() Method Example 6

A String literal can also call the endsWith() method. The following program shows the same.

FileName: EndsWithExample6.java

public class EndsWithExample6
{
// main method
public static void main(String argvs[])
{
// invoking the method endsWith() using the string literal
if("Welcome to JavaTpoint".endsWith(""))
{
System.out.println("Inside the if block");
}
else
{
System.out.println("Inside the else block");
}
// invoking the method endsWith() using the string literal
if("Welcome to JavaTpoint".endsWith("point"))
{
System.out.println("Inside the if block");
}
else
{
System.out.println("Inside the else block");
}
// invoking the method endsWith() using the string literal
if("Welcome to JavaTpoint".endsWith("xyz"))
{
System.out.println("Inside the if block");
}
else
{
System.out.println("Inside the else block");
}
}
}

Output:

Inside the if block

Inside the if block

Inside the else block

=============================================================================

Java String equals()

The Java String class equals() method compares the two given strings based on the content of the string. If any character is not matched, it returns false. If all characters are matched, it returns true.

The String equals() method overrides the equals() method of the Object class.

Signature

publicboolean equals(Object anotherObject)

Parameter

anotherObject : another object, i.e., compared with this string.

Returns

true if characters of both strings are equal otherwise false.

Internal implementation

public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}

Java String equals() Method Example

FileName: EqualsExample.java

public class EqualsExample{
public static void main(String args[]){
String s1="javatpoint";
String s2="javatpoint";
String s3="JAVATPOINT";
String s4="python";
System.out.println(s1.equals(s2));//true because content and case is same
System.out.println(s1.equals(s3));//false because case is not same
System.out.println(s1.equals(s4));//false because content is not same
}}

Test it Now

Output:

true

false

false

Java String equals() Method Example 2

The equals() method compares two strings and can be used in if-else control structure.

FileName: EqualsExample2.java

public class EqualsExample2 {
public static void main(String[] args) {
String s1 = "javatpoint";
String s2 = "javatpoint";
String s3 = "Javatpoint";
System.out.println(s1.equals(s2)); // True because content is same
if (s1.equals(s3)) {
System.out.println("both strings are equal");
}else System.out.println("both strings are unequal");
}
}

Output:

true

both strings are unequal

Java String equals() Method Example 3

Let's see one more example to test the equality of string present in the list.

FileName: EqualsExample3.java

import java.util.ArrayList;
public class EqualsExample3 {
public static void main(String[] args) {
String str1 = "Mukesh";
ArrayList<String> list = new ArrayList<>();
list.add("Ravi");
list.add("Mukesh");
list.add("Ramesh");
list.add("Ajay");
for (String str : list) {
if (str.equals(str1)) {
System.out.println("Mukesh is present");
}
}
}
}

Output:

Mukesh is present

ADAD

Java String equals() Method Example 4

The internal implementation of the equals() method shows that one can pass the reference of any object in the parameter of the method. The following example shows the same.

FileName: EqualsExample4.java

public class EqualsExample4
{
// main method
public static void main(String argvs[])
{
// Strings
String str = "a";
String str1 = "123";
String str2 = "45.89";
String str3 = "false";
Character c = new Character('a');
Integer i = new Integer(123);
Float f = new Float(45.89);
Boolean b = new Boolean(false);
// reference of the Character object is passed
System.out.println(str.equals(c));
// reference of the Integer object is passed
System.out.println(str1.equals(i));
// reference of the Float object is passed
System.out.println(str2.equals(f));
// reference of the Boolean object is passed
System.out.println(str3.equals(b));
// the above print statements show a false value because
// we are comparing a String with different data types
// To achieve the true value, we have to convert
// the different data types into the string using the toString() method
System.out.println(str.equals(c.toString()));
System.out.println(str1.equals(i.toString()));
System.out.println(str2.equals(f.toString()));
System.out.println(str3.equals(b.toString()));
}
}

Output:

false

false

false

false

true

true

true

true

The Java String class equals() method compares the two given strings based on the content of the string. If any character is not matched, it returns false. If all characters are matched, it returns true.

The String equals() method overrides the equals() method of the Object class.

Signature

publicboolean equals(Object anotherObject)

Parameter

anotherObject : another object, i.e., compared with this string.

Returns

true if characters of both strings are equal otherwise false.

Internal implementation

public boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

if (anObject instanceof String) {

String anotherString = (String) anObject;

int n = value.length;

if (n == anotherString.value.length) {

char v1[] = value;

char v2[] = anotherString.value;

int i = 0;

while (n-- != 0) {

if (v1[i] != v2[i])

return false;

i++;

}

return true;

}

return false;

}

Java String equals() Method Example

FileName: EqualsExample.java

public class EqualsExample{

public static void main(String args[]){

String s1="javatpoint";

String s2="javatpoint";

String s3="JAVATPOINT";

String s4="python";

System.out.println(s1.equals(s2));//true because content and case is same

System.out.println(s1.equals(s3));//false because case is not same

System.out.println(s1.equals(s4));//false because content is not same

}}

Test it Now

Output:

true

false

Java String equals() Method Example 2

The equals() method compares two strings and can be used in if-else control structure.

FileName: EqualsExample2.java

public class EqualsExample2 {

public static void main(String[] args) {

String s1 = "javatpoint";

String s2 = "javatpoint";

String s3 = "Javatpoint";

System.out.println(s1.equals(s2)); // True because content is same

if (s1.equals(s3)) {

System.out.println("both strings are equal");

}else System.out.println("both strings are unequal");

}

Output:

true

both strings are unequal

Java String equals() Method Example 3

Let's see one more example to test the equality of string present in the list.

FileName: EqualsExample3.java

import java.util.ArrayList;

public class EqualsExample3 {

public static void main(String[] args) {

String str1 = "Mukesh";

ArrayList<String> list = new ArrayList<>();

list.add("Ravi");

list.add("Mukesh");

list.add("Ramesh");

list.add("Ajay");

for (String str : list) {

if (str.equals(str1)) {

System.out.println("Mukesh is present");

}

Output:

Mukesh is present

Java String equals() Method Example 4

The internal implementation of the equals() method shows that one can pass the reference of any object in the parameter of the method. The following example shows the same.

FileName: EqualsExample4.java

public class EqualsExample4

{

// main method

public static void main(String argvs[])

{

// Strings

String str = "a";

String str1 = "123";

String str2 = "45.89";

String str3 = "false";

Character c = new Character('a');

Integer i = new Integer(123);

Float f = new Float(45.89);

Boolean b = new Boolean(false);

// reference of the Character object is passed

System.out.println(str.equals(c));

// reference of the Integer object is passed

System.out.println(str1.equals(i));

// reference of the Float object is passed

System.out.println(str2.equals(f));

// reference of the Boolean object is passed

System.out.println(str3.equals(b));

// the above print statements show a false value because

// we are comparing a String with different data types

// To achieve the true value, we have to convert

// the different data types into the string using the toString() method

System.out.println(str.equals(c.toString()));

System.out.println(str1.equals(i.toString()));

System.out.println(str2.equals(f.toString()));

System.out.println(str3.equals(b.toString()));

}

Output:

false

true

============================================================================

Java String equalsIgnoreCase()

The Java String class equalsIgnoreCase() method compares the two given strings on the basis of the content of the string irrespective of the case (lower and upper) of the string. It is just like the equals() method but doesn't check the case sensitivity. If any character is not matched, it returns false, else returns true.

Signature

publicboolean equalsIgnoreCase(String str)

Parameter

str : another string i.e., compared with this string.

Returns

It returns true if characters of both strings are equal, ignoring case otherwise false.

Internal implementation

public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}

It is obvious from looking at the implementation that the equalsIgnoreCase() method is invoking the regionMatches() method. It makes the equalsIgnoreCase() method case-insensitive. The signature of the regionMatches() method is mentioned below.

public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

The regionMatches() method parses five parameters. The first parameter ignoreCase is set to true in the above implementation. Thus, when the method is executed, it checks whether the ignoreCase flag is true or not. If yes, then one character each from both the strings is taken and then compared. If the comparison gives a false value, then both the character is converted to upper case and then checked if the comparison still gives a false value, then both the characters are converted to a lower case and then compared. If the comparison gives the true value, then both the strings have equal contents; otherwise, not. Code Snippet of the discussed comparison is mentioned below.

while (toffset < last)
{
char ch1 = getChar(value, toffset++);
char ch2 = getChar(other, ooffset++);
if (ch1 == ch2)
{
continue;
}
// convert each character to uppercase and
// then make the comparison.
// If the comparison yeilds a true value,
// then next pair of characters should be scanned
char uCh1 = Character.toUpperCase(ch1);
char uCh2 = Character.toUpperCase(ch2);
if (uCh1 == u2)
{
continue;
}
// convert each character to lowercase and
// then make the comparison.
// If the comparison yeilds a true value,
// then next pair of characters should be scanned
// Otherwise, return false.
if (Character.toLowerCase(uCh1) == Character.toLowerCase(uCh2))
{
continue;
}
return false;
}
// reaching here means the content of both the strings
// are the same after ignoring the case sensitiveness
return true;

One may argue that if we made a comparison after converting to uppercase, then why do we need an extra comparison by converting characters to the lowercase. The reason behind this is to provide to the requirement of Georgian alphabets. Conversion in uppercase does not work properly for the Georgian alphabets, as they have some strange rules about the case conversion. Therefore, one extra comparison, by converting characters to the lowercase, is required.

Java String equalsIgnoreCase() Method Example

FileName: EqualsIgnoreCaseExample.java

public class EqualsIgnoreCaseExample{
public static void main(String args[]){
String s1="javatpoint";
String s2="javatpoint";
String s3="JAVATPOINT";
String s4="python";
System.out.println(s1.equalsIgnoreCase(s2));//true because content and case both are same
System.out.println(s1.equalsIgnoreCase(s3));//true because case is ignored
System.out.println(s1.equalsIgnoreCase(s4));//false because content is not same
}}

Test it Now

Output:

true

true

false

Java String equalsIgnoreCase() Method Example 2

Let's see an example where we are testing string equality among the strings.

FileName: EqualsIgnoreCaseExample2.java

import java.util.ArrayList;
public class EqualsIgnoreCaseExample2 {
public static void main(String[] args) {
String str1 = "Mukesh Kumar";
ArrayList<String> list = new ArrayList<>();
list.add("Mohan");
list.add("Mukesh");
list.add("RAVI");
list.add("MuKesH kuMar");
list.add("Suresh");
for (String str : list) {
if (str.equalsIgnoreCase(str1)) {
System.out.println("Mukesh kumar is present");
}
}
}
}

Output:

Mukesh kumar is present

============================================================================

Java String format()

The java string format() method returns the formatted string by given locale, format and arguments.

If you don't specify the locale in String.format() method, it uses default locale by calling Locale.getDefault() method.

The format() method of java language is like sprintf() function in c language and printf() method of java language.

Internal implementation

public static String format(String format, Object... args) {
return new Formatter().format(format, args).toString();
}

Signature

There are two type of string format() method:

public static String format(String format, Object... args)
and,
public static String format(Locale locale, String format, Object... args)

Parameters

locale : specifies the locale to be applied on the format() method.

format : format of the string.

args : arguments for the format string. It may be zero or more.

Returns

formatted string

Throws

NullPointerException : if format is null.

IllegalFormatException : if format is illegal or incompatible.

Java String format() method example

public class FormatExample{
public static void main(String args[]){
String name="sonoo";
String sf1=String.format("name is %s",name);
String sf2=String.format("value is %f",32.33434);
String sf3=String.format("value is %32.12f",32.33434);//returns 12 char fractional part filling with 0
System.out.println(sf1);
System.out.println(sf2);
System.out.println(sf3);
}}

Test it Now

name is sonoo

value is 32.334340

value is                  32.334340000000

Java String Format Specifiers

Here, we are providing a table of format specifiers supported by the Java String.

%a floating point (except BigDecimal) : Returns Hex output of floating point number.

%b Any type : "true" if non-null, "false" if null .

%c character : Unicode character.

%d integer (incl. byte, short, int, long, bigint) : Decimal Integer.

%e floating point : decimal number in scientific notation

%f floating point : decimal number

%g floating point : decimal number, possibly in scientific notation depending on the precision and value.

%h any type : Hex String of value from hashCode() method.

%n none : Platform-specific line separator.

%o integer (incl. byte, short, int, long, bigint) : Octal number.

% sany typeString value .

%t Date/Time (incl. long, Calendar, Date and TemporalAccessor) : %t is the prefix for Date/Time conversions. More formatting flags are needed after this. See Date/Time conversion below.

%x integer (incl. byte, short, int, long, bigint): Hex string.

Java String format() Method Example 2

This method supports various data types and formats them into a string type. Let us see an example.

public class FormatExample2 {
public static void main(String[] args) {
String str1 = String.format("%d", 101); // Integer value
String str2 = String.format("%s", "Amar Singh"); // String value
String str3 = String.format("%f", 101.00); // Float value
String str4 = String.format("%x", 101); // Hexadecimal value
String str5 = String.format("%c", 'c'); // Char value
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);
}
}

Test it Now

101

Amar Singh

101.000000

65

c

Java String format() Method Example 3

Apart from formatting, we can set width, padding etc. of any value. Let us see an example where we are setting width and padding for an integer value.

public class FormatExample3 {
public static void main(String[] args) {
String str1 = String.format("%d", 101);
String str2 = String.format("|%10d|", 101); // Specifying length of integer
String str3 = String.format("|%-10d|", 101); // Left-justifying within the specified width
String str4 = String.format("|% d|", 101);
String str5 = String.format("|%010d|", 101); // Filling with zeroes
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);
}
}

Test it Now

101

|       101|

|101       |

| 101|

|0000000101|

=============================================================================

Java String getBytes()

The Java String class getBytes() method does the encoding of string into the sequence of bytes and keeps it in an array of bytes.

Signature

There are three variants of getBytes() method. The signature or syntax of string getBytes() method is given below:

public byte[] getBytes()
public byte[] getBytes(Charset charset)
public byte[] getBytes(String charsetName)throws UnsupportedEncodingException

Parameters

charset / charsetName - The name of a charset the method supports.

Returns

Sequence of bytes.

Exception Throws

UnsupportedEncodingException: It is thrown when the mentioned charset is not supported by the method.

Internal implementation

public byte[] getBytes() {
return StringCoding.encode(value, 0, value.length);
}

String class getBytes() Method Example

The parameterless getBytes() method encodes the string using the default charset of the platform, which is UTF - 8. The following two examples show the same.

FileName: StringGetBytesExample.java

public class StringGetBytesExample{
public static void main(String args[]){
String s1="ABCDEFG";
byte[] barr=s1.getBytes();
for(int i=0;i<barr.length;i++){
System.out.println(barr[i]);
}
}}

Test it Now

Output:

Java String class getBytes() Method Example 2

FileName: StringGetBytesExample2.java

The method returns a byte array that again can be passed to the String constructor to get String.

public class StringGetBytesExample2 {
public static void main(String[] args) {
String s1 = "ABCDEFG";
byte[] barr = s1.getBytes();
for(int i=0;i<barr.length;i++){
System.out.println(barr[i]);
}
// Getting string back
String s2 = new String(barr);
System.out.println(s2);
}
}

Test it Now

Output:

Java String class getBytes() Method Example 3

The following example shows the encoding into a different charset.

FileName: StringGetBytesExample3.java

// Import statement
import java.io.*;
public class StringGetBytesExample3
{
// main method
public static void main(String argvs[])
{
// input string
String str = "Welcome to JavaTpoint.";
System.out.println("The input String is : ");
System.out.println(str + "\n");
// inside try block encoding is
// being done using different charsets
try
{
16 - bit UCS Transformation format
byte[] byteArr = str.getBytes("UTF-16");
System.out.println("After converted into UTF-16 the String is : ");
for (int j = 0; j < byteArr.length; j++)
{
System.out.print(byteArr[j]);
}
System.out.println("\n");
// Big Endian byte order, 16 - bit UCS Transformation format
byte[] byteArr1 = str.getBytes("UTF-16BE");
System.out.println("After converted into UTF-16BE the String is : ");
for (int j = 0; j < byteArr1.length; j++)
{
System.out.print(byteArr1[j]);
}
System.out.println("\n");
// ISO Latin Alphabet
byte[] byteArr2 = str.getBytes("ISO-8859-1");
System.out.println("After converted into ISO-8859-1 the String is : ");
for (int j = 0; j < byteArr2.length; j++)
{
System.out.print(byteArr2[j]);
}
System.out.println("\n");
// Little Endian byte order, 16 - bit UCS Transformation format
byte[] byteArr3 = str.getBytes("UTF-16LE");
System.out.println("After converted into UTF-16LE the String is : ");
for (int j = 0; j < byteArr3.length; j++)
{
System.out.print(byteArr3[j]);
}
}
catch (UnsupportedEncodingException g)
{
System.out.println("Unsupported character set" + g);
}
}
}

Output:

The input String is : 

Welcome to JavaTpoint.



After converted into UTF-16 the String is : 

-2-10870101010809901110109010103201160111032074097011809708401120111010501100116046



After converted into UTF-16BE the String is : 

0870101010809901110109010103201160111032074097011809708401120111010501100116046



After converted into ISO-8859-1 the String is : 

871011089911110910132116111327497118978411211110511011646



After converted into UTF-16LE the String is : 

8701010108099011101090101032011601110320740970118097084011201110105011001160460

ADAD

Java String class getBytes() Method Example 4

The following example shows when the charset is not supported by the getBytes() method, UnsupportedEncodingException is thrown.

FileName: StringGetBytesExample4.java

public class StringGetBytesExample4
{
// main method
public static void main(String argvs[])
{
// input string
String str = "Welcome to JavaTpoint.";
System.out.println("The input String is : ");
System.out.println(str + "\n");
// encoding into UTF - 17
byte[] byteArr = str.getBytes("UTF-17");
System.out.println("After converted into UTF-17 the String is : ");
for (int j = 0; j < byteArr.length; j++)
{
System.out.print(byteArr[j]);
}
}
}

Output:

ADAD

/StringGetBytesExample4.java:11: error: unreported exception UnsupportedEncodingException; must be caught or declared to be thrown

byte[] byteArr = str.getBytes("UTF-17");

                             ^

1 error

Site Content

============================================================================

Java String getChars()

The Java String class getChars() method copies the content of this string into a specified char array. There are four arguments passed in the getChars() method. The signature of the getChars() method is given below:

Signature

public void getChars(int srcBeginIndex, int srcEndIndex, char[] destination, int dstBeginIndex)

Parameters

int srcBeginIndex: The index from where copying of characters is started.

int srcEndIndex: The index which is next to the last character that is getting copied.

Char[] destination: The char array where characters from the string that invokes the getChars() method is getting copied.

int dstEndIndex: It shows the position in the destination array from where the characters from the string will be pushed.

Returns

It doesn't return any value.

Exception Throws

The method throws StringIndexOutOfBoundsException when any one or more than one of the following conditions holds true.

If srcBeginIndex is less than zero.
If srcBeginIndex is greater than srcEndIndex.
If srcEndIndex is greater than the size of the string that invokes the method
If dstEndIndex is is less than zero.
If dstEndIndex + (srcEndIndex - srcBeginIndex) is greater than the size of the destination array.

Internal implementation

The signature or syntax of string getChars() method is given below:

void getChars(char dst[], int dstBegin) {
// copies value from 0 to dst - 1
System.arraycopy(value, 0, dst, dstBegin, value.length);
}

Java String getChars() Method Example

FileName: StringGetCharsExample.java

public class StringGetCharsExample{
public static void main(String args[]){
String str = new String("hello javatpoint how r u");
char[] ch = new char[10];
try{
str.getChars(6, 16, ch, 0);
System.out.println(ch);
}catch(Exception ex){System.out.println(ex);}
}}

Test it Now

Output:

javatpoint

Java String getChars() Method Example 2

The method throws an exception if index value exceeds array range. Let's see an example.

FileName: StringGetCharsExample2.java

public class StringGetCharsExample2 {
public static void main(String[] args) {
String str = new String("Welcome to Javatpoint");
char[] ch = new char[20];
try {
str.getChars(1, 26, ch, 0);
System.out.println(ch);
} catch (Exception e) {
System.out.println(e);
}
}
}

Output:

java.lang.StringIndexOutOfBoundsException: offset 10, count 14, length 20

Java String getChars() Method Example 3

The getChars() method does not copy anything into the char array, provided the value of srcBeginIndex and srcEndIndex are the same. It is because the getChars() method copies from the srcBeginIndex index to srcEndIndex - 1 index. As srcBeginIndex is equal to srcEndIndex; therefore, srcEndIndex - 1 is less than srcBeginIndex. Therefore, the getChars() method copies nothing. The following example confirms the same.

FileName: StringGetCharsExample3.java

public class StringGetCharsExample3
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint!";
// creating a char arry of size 25
char[] chArr = new char[25];
// start and end indices are same
int srcBeginIndex = 11;
int srcEndIndex = 11;
int dstBeginIndex = 2;
try
{
// invoking the method getChars()
str.getChars(srcBeginIndex, srcEndIndex, chArr, dstBeginIndex);
System.out.println(chArr);
}
catch(Exception excpn)
{
System.out.println(excpn);
}
System.out.println("The getChars() method prints nothing as start and end indices are equal.");
}
}

Output:

The getChars() method prints nothing as start and end indices are equal.

============================================================================

Java String indexOf()

The Java String class indexOf() method returns the position of the first occurrence of the specified character or string in a specified string.

Signature

There are four overloaded indexOf() method in Java. The signature of indexOf() methods are given below:

1) int indexOf(int ch) : It returns the index position for the given char value.

2) int indexOf(int ch, int fromIndex) : It returns the index position for the given char value and from index.

3) int indexOf(String substring) : It returns the index position for the given substring.

4) int indexOf(String substring, int fromIndex) : It returns the index position for the given substring and from index.

Parameters

ch: It is a character value, e.g. 'a'

fromIndex: The index position from where the index of the char value or substring is returned.

substring: A substring to be searched in this string.

Returns

Index of the searched string or character.

Internal Implementation

public int indexOf(int ch) {
return indexOf(ch, 0);
}

Java String indexOf() Method Example

FileName: IndexOfExample.java

public class IndexOfExample{
public static void main(String args[]){
String s1="this is index of example";
//passing substring
int index1=s1.indexOf("is");//returns the index of is substring
int index2=s1.indexOf("index");//returns the index of index substring
System.out.println(index1+" "+index2);//2 8
//passing substring with from index
int index3=s1.indexOf("is",4);//returns the index of is substring after 4th index
System.out.println(index3);//5 i.e. the index of another is
//passing char value
int index4=s1.indexOf('s');//returns the index of s char value
System.out.println(index4);//3
}}

Test it Now

Output:

We observe that when a searched string or character is found, the method returns a non-negative value. If the string or character is not found, -1 is returned. We can use this property to find the total count of a character present in the given string. Observe the following example.

FileName: IndexOfExample5.java

public class IndexOfExample5
{
// main method
public static void main(String argvs[])
{
String str = "Welcome to JavaTpoint";
int count = 0;
int startFrom = 0;
for(; ;)
{
int index = str.indexOf('o', startFrom);
if(index >= 0)
{
// match found. Hence, increment the count
count = count + 1;
// start looking after the searched index
startFrom = index + 1;
}
else
{
// the value of index is - 1 here. Therefore, terminate the loop
break;
}
}
System.out.println("In the String: "+ str);
System.out.println("The 'o' character has come "+ count + " times");
}
}

Output:

In the String: Welcome to JavaTpoint

The 'o' character has come 3 times

Java String indexOf(String substring) Method Example

The method takes substring as an argument and returns the index of the first character of the substring.

FileName: IndexOfExample2.java

public class IndexOfExample2 {
public static void main(String[] args) {
String s1 = "This is indexOf method";
// Passing Substring
int index = s1.indexOf("method"); //Returns the index of this substring
System.out.println("index of substring "+index);
}
}

Test it Now

Output:

index of substring 16

Java String indexOf(String substring, int fromIndex) Method Example

The method takes substring and index as arguments and returns the index of the first character that occurs after the given fromIndex.

FileName: IndexOfExample3.java

ADAD

public class IndexOfExample3 {
public static void main(String[] args) {
String s1 = "This is indexOf method";
// Passing substring and index
int index = s1.indexOf("method", 10); //Returns the index of this substring
System.out.println("index of substring "+index);
index = s1.indexOf("method", 20); // It returns -1 if substring does not found
System.out.println("index of substring "+index);
}
}

Test it Now

Output:

index of substring 16

index of substring -1

ADAD

Java String indexOf(int char, int fromIndex) Method Example

The method takes char and index as arguments and returns the index of the first character that occurs after the given fromIndex.

FileName: IndexOfExample4.java

public class IndexOfExample4 {
public static void main(String[] args) {
String s1 = "This is indexOf method";
// Passing char and index from
int index = s1.indexOf('e', 12); //Returns the index of this char
System.out.println("index of char "+index);
}
}

Test it Now

Output:

index of char 17

=============================================================================

Java String intern()

The Java String class intern() method returns the interned string. It returns the canonical representation of string.

It can be used to return string from memory if it is created by a new keyword. It creates an exact copy of the heap string object in the String Constant Pool.

Signature

The signature of the intern() method is given below:

public String intern()

Returns

interned string

The need and working of the String.intern() Method

When a string is created in Java, it occupies memory in the heap. Also, we know that the String class is immutable. Therefore, whenever we create a string using the new keyword, new memory is allocated in the heap for corresponding string, which is irrespective of the content of the array. Consider the following code snippet.

String str = new String("Welcome to JavaTpoint.");
String str1 = new String("Welcome to JavaTpoint");
System.out.println(str1 == str); // prints false

The println statement prints false because separate memory is allocated for each string literal. Thus, two new string objects are created in the memory i.e. str and str1. that holds different references.

We know that creating an object is a costly operation in Java. Therefore, to save time, Java developers came up with the concept of String Constant Pool (SCP). The SCP is an area inside the heap memory. It contains the unique strings. In order to put the strings in the string pool, one needs to call the intern() method. Before creating an object in the string pool, the JVM checks whether the string is already present in the pool or not. If the string is present, its reference is returned.

String str = new String("Welcome to JavaTpoint").intern(); // statement - 1
String str1 = new String("Welcome to JavaTpoint").intern(); // statement - 2
System.out.println(str1 == str); // prints true

In the above code snippet, the intern() method is invoked on the String objects. Therefore, the memory is allocated in the SCP. For the second statement, no new string object is created as the content of str and str1 are the same. Therefore, the reference of the object created in the first statement is returned for str1. Thus, str and str1 both point to the same memory. Hence, the print statement prints true.

Java String intern() Method Example

FileName: InternExample.java

public class InternExample{
public static void main(String args[]){
String s1=new String("hello");
String s2="hello";
String s3=s1.intern();//returns string from pool, now it will be same as s2
System.out.println(s1==s2);//false because reference variables are pointing to different instance
System.out.println(s2==s3);//true because reference variables are pointing to same instance
}}

Test it Now

Output:

false

true

Java String intern() Method Example 2

Let's see one more example to understand the string intern concept.

FileName: InternExample2.java

public class InternExample2 {
public static void main(String[] args) {
String s1 = "Javatpoint";
String s2 = s1.intern();
String s3 = new String("Javatpoint");
String s4 = s3.intern();
System.out.println(s1==s2); // True
System.out.println(s1==s3); // False
System.out.println(s1==s4); // True
System.out.println(s2==s3); // False
System.out.println(s2==s4); // True
System.out.println(s3==s4); // False
}
}

Test it Now

Output:

true

false

true

false

true

false

ADAD

Points to Remember

Following are some important points to remember regarding the intern() method:

1) A string literal always invokes the intern() method, whether one mention the intern() method along with the string literal or not. For example,

String s = "d".intern();
String p = "d"; // compiler treats it as String p = "d".intern();
System.out.println(s == p); // prints true

2) Whenever we create a String object using the new keyword, two objects are created. For example,

String str = new ("Hello World");

Here, one object is created in the heap memory outside of the SCP because of the usage of the new keyword. As we have got the string literal too ("Hello World"); therefore, one object is created inside the SCP, provided the literal "Hello World" is already not present in the SCP.

ADAD