Java String

In Java, string is basically an object that represents sequence of char values. An array of
characters works same as Java string. For example:

1.​ char[] ch={‘R’,’V’,’I’,’T’,’M’};

2.​ String s=new String(ch);
is same as:

1.​ String s="RVITM";

Java String class provides a lot of methods to perform operations on strings such as compare(),
concat(), equals(), split(), length(), replace(), compareTo(), intern(), substring() etc.

The java.lang.String class implements Serializable, Comparable and CharSequence interfaces.

CharSequence Interface

The CharSequence interface is used to represent the sequence of characters.

String, StringBuffer and StringBuilder classes implement it. It means, we can create strings in
Java by using these three classes.

The Java String is immutable which means it cannot be changed. Whenever we change any
string, a new instance is created. For mutable strings, you can use StringBuffer and StringBuilder
classes.

We will discuss immutable string later. Let's first understand what String in Java is and how to
create the String object.

What is String in Java?

Generally, String is a sequence of characters. But in Java, string is an object that represents a
sequence of characters. The java.lang.String class is used to create a string object.

How to create a string object?

 There are two ways to create String object:

1.​ By string literal

2.​ By new keyword

1) String Literal

Java String literal is created by using double quotes. For Example:

1.​ String s="welcome";

Each time you create a string literal, the JVM checks the "string constant pool" first. If the string
already exists in the pool, a reference to the pooled instance is returned. If the string doesn't exist
in the pool, a new string instance is created and placed in the pool. For example:

1.​ String s1="Welcome";

2.​ String s2="Welcome";//It doesn't create a new instance
​

In the above example, only one object will be created. Firstly, JVM will not find any string
object with the value "Welcome" in string constant pool that is why it will create a new object.
After that it will find the string with the value "Welcome" in the pool, it will not create a new
object but will return the reference to the same instance.

Note: String objects are stored in a special memory area known as the "string constant pool".

Why Java uses the concept of String literal?

To make Java more memory efficient (because no new objects are created if it exists already in
the string constant pool).

2) By new keyword

1.​ String s=new String("Welcome");//creates two objects and one reference variable
In such case, JVM will create a new string object in normal (non-pool) heap memory, and the
literal "Welcome" will be placed in the string constant pool. The variable s will refer to the object
in a heap (non-pool).

Interfaces and Classes in Strings in Java

In Java, both String and CharBuffer interact with sequences of characters, but they are designed
with different use cases and underlying mechanisms in mind. Here's an exploration of their
interfaces, classes, and how they fit into the Java ecosystem.

String

The String class is one of the most fundamental types in Java, designed to represent immutable
sequences of characters. Here's a closer look at its characteristics and the interfaces it
implements:

o​ Immutability: Once instantiated, a String object cannot be modified. This immutable

design is a deliberate choice to ensure thread safety, consistency, and efficiency,
especially regarding the String pool mechanism.
o​ String Pool: Java maintains a pool of string literals to help save memory. When a new
string literal is created, Java checks the Pool for a matching string. If found, the new
variable references the pooled string. If not, the new string is added to the Pool.
o​ Implemented Interfaces: The String class implements several interfaces, including:

o​ Serializable: Allows string objects to be serialized into byte streams, facilitating

their transmission or storage.
o​ Comparable<String>: Enables lexical comparison between two strings,
supporting natural ordering within collections.
o​ CharSequence: Provides a unified read-only interface for different kinds of char
sequences, allowing String objects to be manipulated and accessed generically.

CharBuffer
CharBuffer, on the other hand, is part of the java.nio (New Input/Output) package, which
provides a set of classes for non-blocking I/O operations. CharBuffer is a mutable sequence of
characters with more flexibility for manipulation. Here's more about CharBuffer:

o​ Mutability and Direct Buffers: Unlike strings, CharBuffer instances can be modified.
They can be either heap-based or direct buffers. Direct buffers can offer higher
performance, especially for I/O operations, as they are managed outside the Java heap
and interact directly with the operating system's native I/O operations.
o​ Implemented Interfaces: CharBuffer extends the Buffer class and implements
the CharSequence, Appendable, Comparable<CharBuffer>, and Readable interfaces,
providing a rich set of functionalities for character sequence manipulation, comparison,
and reading operations.
o​ Usage Scenarios: It is particularly useful for reading and writing to channels, regular
expressions, and character processing in a more efficient manner, especially when dealing
with large datasets or requiring fine-grained control over character data.

CharSequence Interface

Java's CharSequence interface provides a unified, read-only view of character sequences and is a
component of the java.lang package. It facilitates consistent access and manipulation across
various types of character sequences, including String, StringBuilder, StringBuffer, and
CharBuffer. Through this interface, key functionalities for handling character data are defined,
enabling actions like measuring sequence length, accessing particular characters, generating
character subsequences, and transforming into a String format. By providing a common blueprint
for character sequences, `CharSequence` enables flexible and implementation-independent text
processing across the Java platform.

1.​ String
2.​ StringBuffer
3.​ StringBuilder
 String

In Java, the String class encapsulates a series of characters. Once instantiated, a String object's
content is fixed and cannot be modified, attributing to its immutable nature. This immutability
ensures that String objects are safe for concurrent use across threads and are optimally
performant in situations where the textual content remains constant. To enhance memory
efficiency, Java employs a technique called string interning. This approach optimizes the storage
and access of commonly utilized string literals.

Syntax:

Direct assignment using string literals:

1.​ String str = "Hello, World!";

Using the String constructor:

1.​ String str = new String("Hello, World!");

Filename: StringExample.java

1.​ public class StringExample {

2.​ public static void main(String[] args) {
3.​ // Creating a String
4.​ String greeting = "Hello";
5.​ // Concatenating strings
6.​ String sentence = greeting + ", World!";
7.​ // Using a method from the String class
8.​ int length = sentence.length();
9.​ System.out.println(sentence); // Output: Hello, World!
10.​ System.out.println("Length: " + length); // Output: Length: 13
11.​ }
12.​}
Output:
 Hello, World!
Length: 13

StringBuffer

StringBuffer represents a mutable sequence of characters that ensures thread safety, making it
suitable for scenarios involving multiple threads that modify a character sequence. It includes
various string manipulation capabilities, including the ability to insert, delete, and append
characters. This design avoids the necessity of generating new objects with each change, leading
to enhanced efficiency in situations requiring regular adjustments to the string content.

Syntax

1.​ StringBuffer sb = new StringBuffer();

Filename: StringBufferExample.java

1.​ public class StringBufferExample {

2.​ public static void main(String[] args) {
3.​ // Creating a StringBuffer
4.​ StringBuffer sb = new StringBuffer("Hello");
5.​ // Appending to the StringBuffer
6.​ sb.append(", World!");
7.​ // Inserting into the StringBuffer
8.​ sb.insert(5, " Java");
9.​ // Deleting from the StringBuffer
10.​ sb.delete(5, 10);
11.​ System.out.println(sb); // Output: Hello, World!
12.​ }
13.​}
Output:

Hello, World!
 StringBuilder

StringBuilder shares similarities with StringBuffer by being a mutable character sequence. The
crucial distinction lies in StringBuilder not being synchronized, rendering it not suitable for
thread-safe operations. This absence of synchronization, though, contributes to StringBuilder
offering superior performance in environments that are single-threaded or confined to a specific
thread. As a result, StringBuilder becomes the favored option for manipulating strings in
contexts where the safety of concurrent thread access is not an issue.

Syntax

1.​ StringBuilder sb = new StringBuilder();

Filename: StringBuilderExample.java

1.​ public class StringBuilderExample {

2.​ public static void main(String[] args) {
3.​ // Creating a StringBuilder
4.​ StringBuilder sb = new StringBuilder("Hello");
5.​ // Appending to the StringBuilder
6.​ sb.append(", World!");
7.​ // Inserting into the StringBuilder
8.​ sb.insert(5, " Java");
9.​ // Deleting from the StringBuilder
10.​ sb.delete(5, 10);
11.​ System.out.println(sb); // Output: Hello, World!
12.​ }
13.​}
Output:

Hello, World!
 StringTokenizer

StringJoiner in Java

StringJoiner is a class introduced in Java 8 (in java.util package) that provides an efficient way
to concatenate strings with a specified delimiter, optional prefix, and suffix.

Why Use StringJoiner?

Before Java 8, concatenating multiple strings required either:

●​ Using + operator (which creates multiple temporary objects, reducing performance)

●​ Using StringBuilder (efficient but requires manual formatting)

StringJoiner simplifies this by automatically handling delimiters, prefixes, and suffixes while
joining multiple strings.

Java's StringTokenizer class, housed within the java.util package, simplifies the process of
segmenting a string into multiple tokens, utilizing designated separators. This class is
exceptionally beneficial for parsing strings and navigating through their tokens, especially in
scenarios involving user inputs, file contents, or network transmissions formatted with
straightforward separators such as commas, spaces, or tabs. It offers an efficient means to dissect
and examine the tokenized segments of a string, catering to situations that demand basic parsing
capabilities.

The StringTokenizer class implements the Enumeration<Object> interface, allowing the tokens
of the string to be iterated like other enumeration types in Java. It offers a straightforward
approach to tokenization, avoiding the need for more complex regular expressions, making it
suitable for simple parsing needs.

Syntax:

1.​ public StringJoiner(CharSequence delimiter)

Filename: StringTokenizer.java

1.​ import java.util.StringJoiner;

2.​ public class StringTokenizer {
3.​ public static void main(String[] args) {
4.​ // Creating a StringJoiner with a comma (,) as the delimiter
5.​ StringJoiner joiner = new StringJoiner(", ");
6.​ // Adding strings to the StringJoiner
7.​ joiner.add("Apple");
8.​ joiner.add("Banana");
9.​ joiner.add("Cherry");
10.​ // Converting the StringJoiner to a String
11.​ String result = joiner.toString();
12.​ // Output the result
13.​ System.out.println(result); // Output: Apple, Banana, Cherry
14.​ }
15.​}
Output:

Apple, Banana, Cherry

Immutable String in Java

In Java, strings are immutable. It means that its value cannot be changed once a String object is
created. If any operation appears to modify a String, what happens is the creation of a new String
object. The original string remains unchanged. This immutable characteristic of strings in Java
has several implications for performance, security, and functionality.

Filename: ImmutableStringExample.java

1.​ public class ImmutableStringExample {

2.​ public static void main(String[] args) {
3.​ // Original string
4.​ String originalString = "Java";
5.​ System.out.println("Original string: " + originalString);
6.​ // Attempt to modify the original string
7.​ String modifiedString = originalString.concat(" Programming");
8.​ // Showing that the original string remains unchanged
9.​ System.out.println("After modification, original string: " + originalString);
10.​ // The result of the modification attempt is stored in a new string
11.​ System.out.println("Modified string: " + modifiedString);
12.​ // Demonstrating further that the original string is immutable
13.​ originalString.toUpperCase(); // This operation does not change the original string
14.​ System.out.println("After calling toUpperCase on original string: " + originalString);
15.​ // Correct way to use the result of a string operation
16.​ String upperCaseString = originalString.toUpperCase(); // Stores the result in a new string
17.​ System.out.println("Original string in uppercase: " + upperCaseString);
18.​ }
19.​}
Output:

Original string: Java

After modification, original string: Java
Modified string: Java Programming
After calling toUpperCase on original string: Java
Original string in uppercase: JAVA

Memory Allotment of String

Memory allotment for strings in Java is interesting due to Java's handling of string immutability
and the string pool mechanism. Understanding how strings are stored can help optimize memory
usage in Java applications, especially those that heavily use string manipulations.

String Literal Storage: When you create a string using string literals, Java checks the string
pool first. The new variable points to the existing string if it already exists. If it doesn't exist, the
new string is added to the Pool, and the variable points to this new string.

Syntax:
1.​ String s1 = "Hello"; // String literal
2.​ String s2 = "Hello"; // Points to the same "Hello" in the Pool as s1
new Keyword and String Pool: Strings created with the new operator do not use the Pool by
default. They are stored in the heap memory outside the Pool, which means each new operation
results in a new object, even if it contains the same string data.

Syntax:

1.​ String s3 = new String("Hello"); // A new string object is created in the heap
Interning: We can manually add a string to the Pool or ensure it uses the Pool by calling
the intern() method on a string object. If the Pool already contains an equal string, the string
from the Pool is returned. Otherwise, the string is added to the Pool.

Syntax:

1.​ String s4 = new String("Hello").intern(); // Ensures use of the string pool

Filename: StringMemoryAllotment.java

1.​ public class StringMemoryAllotment {

2.​ public static void main(String[] args) {
3.​ // String literals - stored in the string pool
4.​ String str1 = "Java";
5.​ String str2 = "Java";
6.​ // Checking if str1 and str2 point to the same object
7.​ System.out.println("str1 == str2: " + (str1 == str2)); // true, because both refer to the same st
ring literal in the pool
8.​ // Strings created with 'new' - stored in heap memory outside the string pool
9.​ String str3 = new String("Java");
10.​ String str4 = new String("Java");
11.​ // Checking if str3 and str4 point to the same object
12.​ System.out.println("str3 == str4: " + (str3 == str4)); // false, because 'new' creates a new obj
ect each time
13.​ // Interning str3
14.​ String str5 = str3.intern();
15.​ // Checking if str1 and str5 point to the same object
16.​ System.out.println("str1 == str5: " + (str1 == str5)); // true, str5 is interned, so it refers to the
string in the pool
17.​ // Demonstrating the effect of interning on memory allocation
18.​ String str6 = new String("Java").intern();
19.​ // Checking if str6 is the same as str1
20.​ System.out.println("str1 == str6: " + (str1 == str6)); // true, str6 is interned and points to the
pooled instance
21.​ }
22.​}
Output:

str1 == str2: true

str3 == str4: false
str1 == str5: true
str1 == str6: true

What is PermGen in Java?

PermGen (Permanent Generation) was a special memory area in the Java heap space that
stored metadata about Java classes, methods, and interned strings. It was used until Java 7 and
was replaced by Metaspace in Java 8.

Why did the String pool move from PermGen to the normal heap area?

Java 8 introduced a notable shift in memory management within the Java Virtual Machine (JVM)
by moving the String Pool from the Permanent Generation (PermGen) to the general heap space.
This adjustment was a key element of a wider effort to improve memory utilization, ease the
management and configuration of memory, and boost the efficiency and scalability of Java-based
applications. To fully comprehend the significance of this change, it's important to understand
both the constraints associated with PermGen and the advantages that stem from transferring the
String Pool and additional metadata to the heap area.
 Syntax:

1.​ String demoString = new String("RVITM").intern();

Filename: StringInternExample.java

1.​ public class StringInternExample {

2.​ public static void main(String[] args) {
3.​ // Creating a string using the new keyword, so it's not in the String Pool initially
4.​ String demoString = new String("RVITM");
5.​ // Interning the string, which adds it to the String Pool if it's not already there
6.​ // and returns a reference to the string from the Pool
7.​ String internedString = demoString.intern();
8.​ // Creating a string literal that is automatically added to the String Pool
9.​ String literalString = "RVITM";
10.​ // Checking if the interned string and the literal string refer to the same object in the String P
ool
11.​ System.out.println("Interned String and Literal String refer to the same object: " + (interned
String == literalString));
12.​ }
13.​}
Output:

Interned String and Literal String refer to the same object: true

Construct String from a subset of the char array

In Java, creating a String based on a portion of a char array is achievable through a specific
constructor in the String class. This constructor requires three parameters: the char array to be
used, an index indicating the starting point of the desired subset, and the count of characters to
encompass in the subset. Here's the syntax and an example:

Syntax:
1.​ String(char[] value, int offset, int count)

o​ value: The char array.

o​ offset: The initial offset into the array.
o​ count: The number of characters to use from the array.

Filename: CharArrayToString.java

1.​ public class CharArrayToString {

2.​ public static void main(String[] args) {
3.​ // Define a char array
4.​ char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
5.​ // Construct a string from a subset of the char array
6.​ // Here, we start at index 6 (the space character) and use the next 5 characters
7.​ String resultString = new String(charArray, 6, 5);
8.​ // Output the result
9.​ System.out.println(resultString);
10.​ }
11.​}
Output:

World

Java String Example

StringExample.java

1.​ public class StringExample{

2.​ public static void main(String args[]){
3.​ String s1="java";//creating string by Java string literal
4.​ char ch[]={'s','t','r','i','n','g','s'};
5.​ String s2=new String(ch);//converting char array to string
6.​ String s3=new String("example");//creating Java string by new keyword
7.​ System.out.println(s1);
8.​ System.out.println(s2);
9.​ System.out.println(s3);
10.​}}
Output:

java
strings
example
The above code, converts a char array into a String object. And displays the String objects s1,
s2, and s3 on console using println() method.

Java String class methods

The java.lang.String class provides many useful methods to perform operations on sequence of
char values.

No. Method Description

It returns char value for the

1 char charAt(int index)
particular index

2 int length() It returns string length

static String format(String

3 It returns a formatted string.
format, Object... args)

static String format(Locale l, It returns formatted string with

4
String format, Object... args) given locale.
 String substring(int It returns substring for given
5
beginIndex) begin index.

String substring(int It returns substring for given

6
beginIndex, int endIndex) begin index and end index.

It returns true or false after

boolean
7 matching the sequence of char
contains(CharSequence s)
value.

static String
8 join(CharSequence delimiter, It returns a joined string.
CharSequence... elements)

static String
join(CharSequence delimiter,
9 It returns a joined string.
Iterable<? extends
CharSequence> elements)

It checks the equality of string

10 boolean equals(Object another)
with the given object.

11 boolean isEmpty() It checks if string is empty.

It concatenates the specified

12 String concat(String str)
string.
 String replace(char old, char It replaces all occurrences of
13
new) the specified char value.

String replace(CharSequence It replaces all occurrences of

14
old, CharSequence new) the specified CharSequence.

static String
It compares another string. It
15 equalsIgnoreCase(String
doesn't check case.
another)

It returns a split string

16 String[] split(String regex)
matching regex.

String[] split(String regex, int It returns a split string

17
limit) matching regex and limit.

18 String intern() It returns an interned string.

It returns the specified char

19 int indexOf(int ch)
value index.

It returns the specified char

int indexOf(int ch, int
20 value index starting with given
fromIndex)
index.

It returns the specified

21 int indexOf(String substring)
substring index.
 It returns the specified
int indexOf(String substring,
22 substring index starting with
int fromIndex)
given index.

23 String toLowerCase() It returns a string in lowercase.

It returns a string in lowercase

24 String toLowerCase(Locale l)
using specified locale.

25 String toUpperCase() It returns a string in uppercase.

It returns a string in uppercase

26 String toUpperCase(Locale l)
using specified locale.

It removes beginning and

27 String trim()
ending spaces of this string.

It converts given type into

28 static String valueOf(int value) string. It is an overloaded
method.
 Immutable String in Java

A String is an unavoidable type of variable while writing any application program. String
references are used to store various attributes like username, password, etc. In Java, String
objects are immutable. Immutable simply means unmodifiable or unchangeable.

Once String object is created its data or state can't be changed but a new String object is created.

Let's try to understand the concept of immutability by the example given below:

Testimmutablestring.java

1.​ class Testimmutablestring{

2.​ public static void main(String args[]){
3.​ String s="Sachin";
4.​ s.concat(" Tendulkar");//concat() method appends the string at the end
5.​ System.out.println(s);//will print Sachin because strings are immutable objects
6.​ }
7.​ }
Output:

Sachin
Now it can be understood by the diagram given below. Here Sachin is not changed but a new
object is created with Sachin Tendulkar. That is why String is known as immutable.
 As you can see in the above figure that two objects are created but s reference variable still refers
to "Sachin" not to "Sachin Tendulkar".

But if we explicitly assign it to the reference variable, it will refer to "Sachin Tendulkar" object.

For example:

Testimmutablestring1.java

1.​ class Testimmutablestring1{

2.​ public static void main(String args[]){
3.​ String s="Sachin";
4.​ s=s.concat(" Tendulkar");
5.​ System.out.println(s);
6.​ }
7.​ }
Output:
Sachin Tendulkar
In such a case, s points to the "Sachin Tendulkar". Please notice that still Sachin object is not
modified.

Why String objects are immutable in Java?

As Java uses the concept of String literal. Suppose there are 5 reference variables, all refer to one
object "Sachin". If one reference variable changes the value of the object, it will be affected by
all the reference variables. That is why String objects are immutable in Java.

Following are some features of String which makes String objects immutable.

1. ClassLoader:

A ClassLoader in Java uses a String object as an argument. Consider, if the String object is
modifiable, the value might be changed and the class that is supposed to be loaded might be
different.

To avoid this kind of misinterpretation, String is immutable.

2. Thread Safe:

As the String object is immutable we don't have to take care of the synchronization that is
required while sharing an object across multiple threads.

3. Security:

As we have seen in class loading, immutable String objects avoid further errors by loading the
correct class. This leads to making the application program more secure. Consider an example of
banking software. The username and password cannot be modified by any intruder because
String objects are immutable. This can make the application program more secure.

4. Heap Space:
The immutability of String helps to minimize the usage in the heap memory. When we try to
declare a new String object, the JVM checks whether the value already exists in the String pool
or not. If it exists, the same value is assigned to the new object. This feature allows Java to use
the heap space efficiently.

Why String class is Final in Java?

The reason behind the String class being final is because no one can override the methods of the
String class. So that it can provide the same features to the new String objects as well as to the
old ones.

Java String compare

String comparison is a key component of Java programming and is used extensively in reference
matching, sorting, and authentication. In this section, we will discuss various ways to compare
string in Java.

We can compare String in Java on the basis of content and reference.

String comparision used in authentication (by the equals() method), sorting (by the compareTo()
method), reference matching (by the == operator), etc.

There are three ways to compare String in Java:

1.​ By Using equals() Method

2.​ By Using == Operator
3.​ By compareTo() Method
4.​ Using startsWith() and endsWith() Method

1) By Using equals() Method

 The String class equals() method compares the original content of the string. It compares values
of string for equality. String class provides the following two methods: Additionally, the
equalsIgnoreCase() method performs a case-insensitive comparison.

String class provides the following two methods:

o​ public boolean equals(Object another) compares this string to the specified object.
o​ public boolean equalsIgnoreCase(String another) compares this string to another
string, ignoring case.

StringComparisonUsingEqualsMethod.java

1.​ class StringComparisonUsingEqualsMethod{

2.​ public static void main(String args[]){
3.​ String s1="Sachin";
4.​ String s2="Sachin";
5.​ String s3=new String("Sachin");
6.​ String s4="Saurav";
7.​ System.out.println(s1.equals(s2));//true
8.​ System.out.println(s1.equals(s3));//true
9.​ System.out.println(s1.equals(s4));//false
10.​ }
11.​}
Output:

true
true
false
Explanation

S1 and S2 relate to the same string pool object since they are string literals. As a result,
s1.equals(s2) gives true. Despite S3 being developed with the new keyword, S1 and S3 had the
 same content. Since only the content is compared using the equals() method, s1.equals(s3) is
true; however, s1.equals(s4) is false because the contents of s1 and s4 differ.

In the above program, the methods of String class are used. The equals() method returns true if
String objects are matching and both strings are of same case. equalsIgnoreCase() returns true
regardless of cases of strings.

StringComparisonUsingequalsIgnoreCase.java

1.​ class StringComparisonUsingequalsIgnoreCase {

2.​ public static void main(String[] args) {
3.​ String s1 = "Ram";
4.​ String s2 = "rAm";
5.​ // Using equals() method for case-sensitive comparison
6.​ boolean equalsResult = s1.equals(s2);
7.​ System.out.println("Using equals() method: " + equalsResult); // Output: false
8.​ // Using equalsIgnoreCase() method for case-insensitive comparison
9.​ boolean equalsIgnoreCaseResult = s1.equalsIgnoreCase(s2);
10.​ System.out.println("Using equalsIgnoreCase() method: " + equalsIgnoreCaseResult); // Out
put: true
11.​ }
12.​}
Output:

false
true
Explanation

There are two strings specified, s1 and s2, with distinct cases ("Ram" and "rAm").

Use the equals() function to compare s1 and s2. Because the cases are different, this method
compares them in a case-sensitive fashion and returns false.
 The comparison between strings s1 and s2 is performed using the equalsIgnoreCase() function.
Because it treats the material equally and ignores case distinctions, this function returns true.

2) By Using == Operator

In Java, the == operator compares references rather than values.

StringCompare.java

1.​ class StringCompare {

2.​ public static void main(String[] args) {
3.​ String s1 = "Kohli";
4.​ String s2 = "Kohli";
5.​ String s3 = new String("Kohli");
6.​ System.out.println(s1 == s2); // true
7.​ System.out.println(s1 == s3); // false
8.​ }
9.​ }
Output:

true
false

3) String compare by compareTo() Method

The String class compareTo() method compares values lexicographically and returns an integer
value that describes if first string is less than, equal to or greater than second string.

Suppose s1 and s2 are two String objects. If:

o​ s1 == s2 : The method returns 0.

o​ s1 > s2 : The method returns a positive value.
o​ s1 < s2 : The method returns a negative value.
 StringComparisonUsingComapreto.java

1.​ class StringComparisonUsingComapreto {

2.​ public static void main(String[] args) {
3.​ String str1 = "Sachin";
4.​ String str2 = "Sachin";
5.​ String str3 = "Ratan";
6.​ System.out.println(str1.compareTo(str2)); // 0
7.​ System.out.println(str1.compareTo(str3)); // 1 (str1 > str3)
8.​ System.out.println(str3.compareTo(str1)); // -1 (str3 < str1)
9.​ }
10.​}
Output:

0
1
-1
Explanation

The content of str1 and str2 is the same-"Sachin," while str3 has the word "Ratan."

4) Using startsWith() and endsWith() Methods

If a string starts with a prefix and ends with a suffix, respectively, it may be determined using the
methods startsWith() and endsWith().

1.​ class StringCompare {

2.​ public static void main(String[] args) {
3.​ String str = "String Compare";
4.​ System.out.println(str.startsWith("String")); // true
5.​ System.out.println(str.endsWith("Compare")); // true
6.​ }
7.​ }
Output:

true
true
Explanation

startsWith("Hello") returns true if the string begins with the given prefix.

endsWith("World!") returns true if the string does, in fact, conclude with the designated suffix.

Conclusion

In summy, the compareTo() function offers a means of comparing strings according to their
lexicographical order. Developers can ascertain the ordering relationship between two strings by
comprearhending the return values (0, positive, or negative). The example shows the method's
behavior with various string inputs.