String is an
object that represents sequence of characters. In Java,
String is represented by String class which is located
into java.lang package
In java, every string that we create is actually an object of
type String. One important thing to notice about string object is that
string objects are immutable that means once a string object is
created it cannot be changed.
The Java String class implements Serializable, Comparable and
CharSequence interface.
CharSequence Interface is used for representing a sequence of
characters. CharSequence interface is implemented by String,
StringBuffer and StringBuilder classes. This three classes can be used
for creating strings in java.
Creating a String object
1) Using a String literal
2) Using new Keyword
Using a String literal:
String literal is a simple string enclosed in double quotes " ". A string
literal is treated as a String object.
public class Demo{
public static void main(String[] args) {
String s1 = "Hello Java";
System.out.println(s1);
}
}
Using new Keyword:
We can create a new string object by using new operator that
allocates memory for the object.
public class Demo{
public static void main(String[] args) {
String s1 = new String("Hello Java");
System.out.println(s1);
}
}
String object and How they are stored
When we create a new string object using string literal, that string
literal is added to the string pool, if it is not present there already.
String str= "Hello";
CharSequence interface in java
java.lang.CharSequence is an interface in the Java programming
language that represents a sequence of characters. It defines a set of
methods for accessing the characters in a string or other character
sequence, without specifying the underlying implementation.
The CharSequence interface is implemented by many classes in the
Java Standard Library, including String, StringBuilder, StringBuffer,
and CharBuffer. It provides a uniform way to work with character
sequences, regardless of the specific implementation.
Some of the methods defined by the CharSequence interface
include charAt(), length(), and subSequence(), which allow you to
access and manipulate the characters in a character sequence. These
methods are used extensively in Java programming for tasks such as
searching, sorting, and manipulating strings.
import java.lang.CharSequence;
import java.lang.String;
class Example
{
public static void main(String[] args)
{
CharSequence x = new String("ABCDE");
// Interface method
System.out.println(x.toString());
System.out.println(x.charAt(0));
System.out.println(x.length());
System.out.println(x.subSequence(0, 2));
// IntStream of Unicode code points from this sequence
System.out.println(x.codePoints());
// IntStream of char values from this sequence
System.out.println(x.chars());
}
}
Implementation of Serializable interface by string class in java
In Java, the Serializable interface is used to indicate that a class can
be serialized, which means that its objects can be converted into a
stream of bytes and then saved to a file or sent over a network.
However, the String class in Java is already serializable, which means
that it can be saved to a file or sent over a network without any
additional implementation of the Serializable interface.
Here is an example of how to serialize a String object:
java
import java.io.*;
public class SerializationExample {
public static void main(String[] args) {
String message = "Hello World!";
try {
// Serialize the object
ObjectOutputStream out = new ObjectOutputStream(new
FileOutputStream("message.ser"));
out.writeObject(message);
out.close();
// Deserialize the object
ObjectInputStream in = new ObjectInputStream(new
FileInputStream("message.ser"));
String deserializedMessage = (String) in.readObject();
in.close();
System.out.println(deserializedMessage);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
Implementation of comparable interface by string class in java
In Java, the java.lang.String class already implements the
java.lang.Comparable interface, which means that instances of the
String class can be compared using the compareTo() method.
The compareTo() method is used to compare two strings
lexicographically. It returns an integer value that indicates whether
the string being compared is less than, equal to, or greater than the
other string. The method signature is as follows:
public int compareTo(String anotherString)
Concatenating String:
1. Using concat() method
2. Using + operator
Using concat() method:
public class Demo{
public static void main(String[] args) {
String s = "Hello";
String str = "Java";
String str1 = s.concat(str);
System.out.println(str1);
} }
Using + operator:
public class Demo{
public static void main(String[] args) {
String s = "Hello";
String str = "Java";
String str1 = s+str;
String str2 = "Java"+11;
System.out.println(str1);
System.out.println(str2);
} }
String Comparison
To compare string objects, Java provides methods and operators
both. So we can compare string in following three ways.
1. Using equals() method
2. Using == operator
3. By CompareTo() method
Using equals() method:
public class Demo{
public static void main(String[] args) {
String s = "Hell";
String s1 = "Hello";
String s2 = "Hello";
boolean b = s1.equals(s2); //true
System.out.println(b);
b = s.equals(s1) ; //false
System.out.println(b);
} }
Using == operator
public class Demo{
public static void main(String[] args) {
String s1 = "Java";
String s2 = "Java";
String s3 = new String ("Java");
boolean b = (s1 == s2); //true
System.out.println(b);
b = (s1 == s3); //false
System.out.println(b);
}
}
By CompareTo() method
public class HelloWorld{
public static void main(String[] args) {
String s1 = "Abhi";
String s2 = "Viraaj";
String s3 = "Abhi";
int a = s1.compareTo(s2); //return -21 because s1 < s2
System.out.println(a);
a = s1.compareTo(s3); //return 0 because s1 == s3
System.out.println(a);
a = s2.compareTo(s1); //return 21 because s2 > s1
System.out.println(a);
}
}
Methods of String:
charAt(): It returns a character at a specified position.
equals(): It compares the two given strings and returns
a Boolean, that is, True or False.
concat(): Appends one string to the end of another.
length(): Returns the length of a specified string.
toLowerCase(): Converts the string to lowercase letters.
toUpperCase(): Converts the string to uppercase letters.
indexOf(): Returns the first found position of a character.
substring(): Extracts the substring based on index values,
passed as an argument.
Program:
class Main{
public static void main(String []args)
{
String s1="Adithya";
String s2="Adithya";
String s3="Adi";
boolean x=s1.equals(s2);
System.out.println("Compare s1 and s2:"+x);
System.out.println("Character at given position is:"+s1.charAt(5));
System.out.println(s1.concat(" the author"));
System.out.println(s1.length());
System.out.println(s1.toLowerCase());
System.out.println(s1.toUpperCase());
System.out.println(s1.indexOf('a'));
System.out.println(s1.substring(0,4));
System.out.println(s1.substring(4));
}
}
