String Handling

String handling in Java is an essential part of programming, as strings are used extensively in applications. Java provides the String class and various methods to handle and manipulate strings efficiently. As string is probably the most commonly used class in java library. String class is encapsulated under java.lang package. In java, every string that you 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 altered.

What is an Immutable object?

An object whose state cannot be changed after it is created is known as an Immutable object. String, Integer, Byte, Short, Float, Double and all other wrapper classes objects are immutable.

Creating a String object

String can be created in number of ways, here are a few ways of creating string object.

1) Using a String literal : String literal is a simple string enclosed in double quotes ” “. A string literal is treated as a String object.
String str1 = “Hello”;

2) Using another String object
String str2 = new String(str1);

3) Using new Keyword
String str3 = new String(“Java”);

4) Using + operator (Concatenation)
String str4 = str1 + str2;
or,
String str5 = “hello”+”Java”;

Each time you create a String literal, the JVM checks the string pool first. If the string literal already exists in the pool, a reference to the pool instance is returned. If string does not exist in the pool, a new string object is created, and is placed in the pool. String objects are stored in a special memory area known as string constant pool inside the heap memory.

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”;

Creating String in heap

When we create another object with same string, then a reference of the string literal
already present in string pool is returned.
String str2=str;

But if we change the new string, its reference gets modified.
str2=str2.concat(“world”);

Concatenating String

There are 2 methods to concatenate two or more string.

1) Using concat() method :

string s = "Hello";
string str = "Java";
string str2 = s.concat(str);
String str1 = "Hello".concat("Java");  //works with string literals too.

2) Using + operator :

string str = "Rahul";
string str1 = "Dravid";
string str2 = str + str1;
string st = "Rahul" + "Dravid";

String Comparison

String comparison can be done in 3 ways.

1. Using equals() method : equals() method compares two strings for equality. It compares the content of the strings. It will return true if string matches, else returns false. Its general syntax is,

boolean equals (Object str)

String s = "Hell";
String s1 = "Hello";
String s2 = "Hello";
s1.equals(s2); //true
s.equals(s1) ; //false

2. Using == operator : == operator compares two object references to check whether they refer to same instance. This also, will return true on successful match.

String s1 = "Java";
String s2 = "Java";
String s3 = new string ("Java");
test(s1 == s2) //true
test(s1 == s3) //false

3. By compareTo() method : compareTo() method compares values and returns an int which tells if the string compared is less than, equal to or greater than the other string. It compares the String based on natural ordering i.e alphabetically. Its general syntax is,

int compareTo(String str)

String s1 = "Abhi;
String s2 = "Viraaj";
String s3 = "Abhi;
s1.compareTo(S2);     //return -1 because s1 < s2
s1.compareTo(S3);     //return 0 because s1 == s3
s2.compareTo(s1);     //return 1 because s2 > s1

String class function

The following methods are some of the most commonly used methods of String class.

charAt() : charAt() function returns the character located at the specified index.

String str = "studytonight";
System.out.println(str.charAt(2));
Output : u

Note: Index of a String starts from 0, hence str.charAt(2) means third character of the String str.

equalsIgnoreCase() : equalsIgnoreCase() determines the equality of two Strings, ignoring thier case (upper or lower
case doesn’t matters with this fuction ).

String str = "java";
System.out.println(str.equalsIgnoreCase("JAVA"));
Output : true

indexOf() : indexOf() function returns the index of first occurrence of a substring or a character.

indexOf() method has four forms:

• int indexOf(String str) : It returns the index within this string of the first occurrence of the specified substring.
• int indexOf(int ch, int fromIndex) : It returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
• int indexOf(int ch) : It returns the index within this string of the first occurrence of the specified character.
• int indexOf(String str, int fromIndex) : It returns the index within this string of the first occurrence of the specified substring, starting at the specified index.

public class StudyTonight {
  public static void main(String[] args) {

String str="StudyTonight";
System.out.println(str.indexOf('u')); //3rd form
          System.out.println(str.indexOf('t', 3)); //2nd form

          String subString="Ton";
System.out.println(str.indexOf(subString)); //1st form

System.out.println(str.indexOf(subString,7)); //4th form
  }
}
Output:
2
11
5
-1

Note: -1 indicates that the substring/Character is not found in the given String.

length() : length() function returns the number of characters in a String.

String str = "Count me";
System.out.println(str.length());
Output : 8

replace() : replace() method replaces occurances of character with a specified new character.

String str = "Change me";
System.out.println(str.replace('m','M'));
Output : Change Me

substring() : substring() method returns a part of the string.

substring() method has two forms,

• public String substring(int begin) : It represents the starting point of the subtring. If the substring() method is
  called with only one argument, the subtring returned, will contain characters from specified
  starting point to the end of original string.
• public String substring(int begin, int end) : If the substring() method has two arguments, the second argument specify the end point of substring. Hence, this method is used to return a new String object that includes a substring of the given string with their indexes lying between start point and end point.

String str = "0123456789";
System.out.println(str.substring(4));
Output : 456789

System.out.println(str.substring(4,7));
Output : 456

toLowerCase() : toLowerCase() method returns string with all uppercase characters converted to lowercase.

String str = "ABCDEF";
System.out.println(str.toLowerCase());
Output : abcdef

toUpperCase() : This method returns string with all lowercase character changed to uppercase.

String str = "abcdef";
System.out.println(str.toUpperCase());
Output : ABCDEF

valueOf() : Overloaded version of valueOf() method is present in String class for all primitive data types and for type Object.

public class Example{
public static void main(String args[]){
int num=35;
String s1=String.valueOf(num);      //converting int to String
System.out.println(s1+"IAmAString");
}}
Output: 35IAmAString

But for objects, valueOf() method calls toString() function.

NOTE : valueOf() function is used to convert primitive data types into Strings.

toString() : toString() method returns the string representation of the object used to invoke this method. toString() is used to represent any Java Object into a meaningful string representation. It is declared in the Object class, hence can be overrided by any java class. (Object class is super class of all java classes.)

public class Car {
public static void main(String args[])
{
Car c=new Car();
System.out.println(c);
}
public String toString()
{
return "This is my car object";
}
}
Output : This is my car object

Whenever we will try to print any object of class Car, its toString() function will be called.

toString() : toString() can also be used with normal string objects.

String str = "Hello World";
System.out.println(str.toString());
Output : Hello World

Note: If we don’t override the toString() method and directly print the object, then it would print the object id.

trim() : This method returns a string from which any leading and trailing whitespaces has been removed.

String str = " hello ";
System.out.println(str.trim());
Output : hello

Note: If the whitespaces are between the string ,for example: String s1 = “study tonight”; then
System.out.println(s1.trim()); will output “study tonight”.

Also, trim() method removes only the leading and trailing whitespaces.

StringBuffer class

StringBuffer class is used to create a mutable string object i.e its state can be changed after it is created. It represents growable and writable character sequence. As we know that String objects are immutable, so if we do a lot of changes with String objects, we will end up with a lot of memory leak. So StringBuffer class is used when we have to make lot of modifications to our string. It is also thread safe i.e multiple threads cannot access it simultaneously.

StringBuffer defines 4 constructors :

• StringBuffer ( ) : creates an empty string buffer and reserves room for 16 characters.
• StringBuffer ( int size ) : creates an empty string and takes an integer argument to set capacity of the buffer.
• StringBuffer ( String str ) : Constructs a string buffer initialized to the contents of the specified string.
• StringBuffer ( charSequence [ ]ch ) : Constructs a string buffer that contains the same characters as the specified CharSequence.

class Test {
public static void main(String args[])
{
String str = "study";
str.concat("tonight");
System.out.println(str);          // Output: study

StringBuffer strB = new StringBuffer("study");
strB.append("tonight");
System.out.println(strB);        // Output: studytonight
}
}

Reason : Output is such because String objects are immutable objects. Hence, if we concatenate on the
same String object, it won’t be altered(Output: study). But StringBuffer creates mutable objects.
Hence, it can be altered(Output: studytonight).

Important methods of StringBuffer class :

Modifier and Type	Method and Description
StringBuffer	append(String str) Appends the specified string to this character sequence.
StringBuffer	append(int n) Appends the string representation of the int argument to this sequence.
StringBuffer	append(Object obj) Appends the string representation of the Object argument.
StringBuffer	insert(int index, String str) Inserts the specified string (str) into the StringBuffer object at the specified index position (index).
StringBuffer	insert(int index, int num) Used for inserting a numerical value at a specific position within a string.
StringBuffer	insert(int index, Object obj) Inserts the string representation of the specified object into the StringBuffer at the specified index.
StringBuffer	reverse() This method reverses the characters within a StringBuffer object.
StringBuffer	replace() This method replaces the string from specified start index to the end index.
int	capacity() This method returns the current capacity of StringBuffer object.
void	ensureCapacity() This method is used to ensure minimum capacity of StringBuffer object.

StringTokenizer Class

The java.util.StringTokenizer class allows an application to break a string into tokens.

Constructor	Description
StringTokenizer(String str)	This constructor a string tokenizer for the specified string.
StringTokenizer(String str, String delim)	Creates a StringTokenizer object. This object is used to break a given string (str) into tokens using the specified delimiters (delim).
StringTokenizer(String str, String delim, boolean returnDelims)	This creates a string tokenizer for a specified string, and tokens will be generated based on a specified delimiter. The third parameter is a boolean value that specifies whether delimiters are required as tokens.

Method	Description
int countTokens()	This method calculates the number of times that this tokenizer’s nextToken method can be called before it generates an exception.
boolean hasMoreElements()	This method returns the same value as the hasMoreTokens method.
boolean hasMoreTokens()	This method tests if there are more tokens available from this tokenizer’s string.
Object nextElement()	This method returns the same value as the nextToken method, except that its declared return value is Object rather than String.
String nextToken()	This method returns the next token from this string tokenizer.
String nextToken(String delim)	This method returns the next token in this string tokenizer’s string.