Java.lang.String class in Java | Set 2

Java.lang.String class in Java | Set 1
In this article we would be discussing different constructor and methods provided by java.lang.String. Strings in java are immutable.
Now lets discuss some of the methods provided by String class.
Methods:

public int codePointAt(int index) – It takes as parameter a index which must be from 0 to length() – 1. ad returns a character unicode point of a index.
public int codePointBefore(int index) – It takes as parameter a index which must be from 0 to length() – 1. and returns a unicode point of a character just before the index .
public int codePointCount(int start_index, int end_index) – It takes as parameter start_index and end_index and returns the count of Unicode code points between the range.

Lets see an example of the above methods:
Example:

// Java Program to demonstrate codePointAt 
// codePointBefore and codePointCount 
public class GFG_1 { 
public static void main(String[] args) 
    { 
  
        String s = "GeeksforGeeks"; 
  
        // codePointAt() 
        System.out.print("Character (unicode point) at index 1 : "
                         + s.codePointAt(1) + "  "); 
        System.out.println(s.codePointAt(5)); 
  
        // codePointBefore() 
        System.out.print("Character (unicode point) before index 1 : "
                         + s.codePointBefore(1) + "  "); 
        System.out.println(s.codePointBefore(7)); 
  
        // codePointCount() 
        s = "G eek123 G**k"; 
        System.out.println("Character code point count : "
                           + s.codePointCount(0, 5)); 
    } 
} 

Output:

Character (unicode point) at index 1 : 101  102
Character (unicode point) before index 1 : 71  111
Character code point count : 5

public CharSequence subSequence(int start_index, int end_index) – This method returns CharSequence which is a subsequence of the String on which this method is invoked.
Note: It behaves similarly to subString(int start_index, int end_index), but subString() returns String while subSequence returns CharSequence.
public boolean contains(CharSequence char_seq) – It returns true if the given CharSquence is present in the String on which its invoked.
public boolean contentEquals(CharSequence char_seq) – It returns true only if the given CharSequence exactly matches the String on which its invoked

Lets see an example of the above methods:
Example:

// Java Program to demonstrate subSequence 
// and contains and contentEquals 
public class GFG_2 { 
public static void main(String[] args) 
    { 
        String s = "geeksforgeeks"; 
  
        // subSequence() 
        // contains "for" 
        CharSequence cs = s.subSequence(5, 8); 
  
        // contains "geeks" 
        CharSequence cs1 = s.subSequence(0, 5); 
  
        String s_1 = "geekforgeek"; 
  
        // contains() 
        System.out.println("Reult of contains on s_1 "
                           + "with charSequence cs " + s_1.contains(cs)); 
        System.out.println("Reult of contains on s_1 "
                           + "with charSequence cs1 " + s_1.contains(cs1)); 
  
        // contentEqual() 
  
        System.out.print("Result of contentEqual "); 
        System.out.println("geeks".contentEquals(cs1)); 
  
        System.out.print("Result of contentEqual "); 
        System.out.println("geeksfor".contentEquals(cs1)); 
    } 
} 

Output:

Reult of contains on s_1 with charSequence cs true
Reult of contains on s_1 with charSequence cs1 false
Result of contentEqual true
Result of contentEqual false

public boolean endsWith(String suf) – It takes in parameter a String suffix and return true if the String has same suffix.
public boolean startsWith(String pre) – It takes in parameter a String prefix and returns true if the String has a same prefix

Lets see an example of the above methods:
Example:

// Java Program to demonstrate endsWith 
// and startWith 
public class GFG_3 { 
public static void main(String[] args) 
    { 
  
        String s = "geeksforgeeks"; 
  
        // endsWith 
        String ends_1 = "geeks"; 
        String ends_2 = "eks"; 
        String ends_3 = "for"; 
  
        System.out.println(s + "end with " + ends_1 + " " + s.endsWith(ends_1)); 
        System.out.println(s + "end with " + ends_2 + " " + s.endsWith(ends_2)); 
        System.out.println(s + "end with " + ends_3 + " " + s.endsWith(ends_3)); 
  
        // startWith 
        String start_1 = "geeks"; 
        String start_2 = "for"; 
  
        System.out.println(s + " starts with " + start_1 
                           + "  " + s.startsWith(start_1)); 
        System.out.println(s + " starts with " + start_2 
                           + "  " + s.startsWith(start_2)); 
    } 
} 

Output:

geeksforgeeksend with geeks true
geeksforgeeksend with eks true
geeksforgeeksend with for false
geeksforgeeks starts with geeks  true
geeksforgeeks starts with for  false

public void getChars(int start, int end, char[] destination, int destination_start) : It takes in four parameters, start and end refers to the range which is to copied to the character array, destination is the character array to be copied to, and destination_start is the starting location of the destination array.
public char[] toCharArray() – It coverts the entire String to the character array.
Note :- getChars provide more flexibility when, a range of characters is to be copied to an exiting array or a new array while toCharArray converts the entire string to a new character array.

Lets see an example of the above methods:
Example:

// Java Program to demonstrate getChars 
// and toCharArray 
public class GFG_4 { 
public static void main(String args[]) 
    { 
        String s = "geeksforgeeks"; 
  
        // toCharArray 
        char[] arr; 
        arr = s.toCharArray(); 
        System.out.println("String toCharArray: "); 
        for (char i : arr) 
            System.out.print(i + " "); 
  
        // getChars 
        s.getChars(5, 8, arr, 0); 
        System.out.println("
SubString to existing "
                           + "char array"); 
        for (char i : arr) 
            System.out.print(i + " "); 
    } 
} 

Output:

String toCharArray: 
g e e k s f o r g e e k s 
SubString to existing char array
f o r k s f o r g e e k s

public int hashCode() – It returns hashcode of the given String. There is predefined formula to compute the hashcode of the String:
```
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
where,
n - is the length of the String
i - is the ith character of the string
```
public String intern() – It returns the canonical form of the String object on which it is invoked.
” When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned. ” – Java String Documentation.

Lets see an example of the above method:-
To understand the example better refer to Initialize and compare String
Example:

// Java program to demostrate 
// hashCode and intern 
class GFG_5 { 
public static void main(String[] args) 
    { 
  
        // hashCode 
        String s = "geeks"; 
        System.out.println("Hashcode of String s is "
                           + s.hashCode()); 
  
        // intern() 
        String s_1 = "geeks"; 
        String s_2 = new String("geeks"); 
        String s_3 = s_2.intern(); 
  
        // returns true 
        System.out.println(s_1 == s_2); 
  
        // returns false 
        System.out.println(s_1 == s_3); 
    } 
} 

Output:

Hashcode of String s is 98232047
false
true

public boolean isEmpty() – It returns true if the length of the String is 0.
public static String format(String f, Object… arguments) – Returns the formatted String according to the format specifier f, the arguments should exactly equal to the number of format specifier used .
Variation:
public static String format(Locale l, String f, Object… arguments)– Returns the formatted String as per Locale used.

Lets see an example of the above methods:
Example:

import java.util.Locale; 
// Java program to demostrate 
// isEmpty and format 
class GFG_6 { 
public static void main(String[] args) 
    { 
  
        String s = "geeksforgeeks"; 
  
        // format() 
        String s1 = String.format("%s : %d", s, 10); 
        System.out.println(s1); 
  
        String s2 = String.format("%s = %f ", 
                                  "Value of PI is", Math.PI); 
        System.out.println(s2); 
  
        // format() with locale 
        // we are using the default locale here 
  
        String s3 = String.format(Locale.getDefault(), 
                                  "%s : %d", s, 10); 
        System.out.println(s3); 
  
        // isEmpty 
        String s4 = ""; 
        System.out.println("is String s empty "
                           + s.isEmpty()); 
  
        System.out.println("is String s4 empty? "
                           + s4.isEmpty()); 
    } 
} 

Output:

geeksforgeeks : 10
Value of PI is = 3.141593 
geeksforgeeks : 10
is String s empty false
is String s4 empty? true

public boolean matches(String reg_exp) – It returns true if the string matches the regular expression( reg_exp).
public boolean regionMatches(int start_OString, String another, int start_AString, int no_of_char) – It returns true if the region of original string staring with index start_OString matches with the region of another string starting with string_AString, and no_of_char refers to the number of character to be compared.
Variation :
public boolean regionMatches(boolean ignore_case, int start_OString, String another, int start_AString, int no_of_char) – This variation of a method provide flexibility when we want to ignore the case while comparing substring. If the first parameter i.e. ignore_case is true it neglects the case and compares but if it is false it behaves similarly as the first version of the method without ignore_case

Lets see an example of the above methods:
Example:

// Java Program to demonstrate 
// matches and regionMatches 
class GFG_7 { 
public static void main(String[] args) 
    { 
        String s = "geeksforGeeks"; 
  
        // matches 
        System.out.println("Matches 1 :"
                           + s.matches("(.*)Geeks")); 
        System.out.println("Matches 2 :"
                           + s.matches("(.*)for(.*)")); 
        System.out.println("Matches 3 :"
                           + s.matches("geeksfor")); 
  
        // regionMatches(int, String, int, int) 
  
        String s2 = "Geeksforgeeks"; 
  
        System.out.println("RegionMatches 1 :" + s.regionMatches(5, s2, 5, 3)); 
        System.out.println("RegionMatches 2 :" + s.regionMatches(5, s2, 6, 3)); 
  
        // regionMatches(boolean, int, String, int, int) 
        // ignore the case while comparing 
        System.out.println("Region Matches 3 :" + s.regionMatches(true, 0, s2, 0, 3)); 
  
        // consider the case while comparing 
        System.out.println("Region Matches 3 :" + s.regionMatches(false, 0, s2, 0, 3)); 
    } 
} 

Output:

Matches 1 :true
Matches 2 :true
Matches 3 :false
RegionMatches 1 :true
RegionMatches 2 :false
Region Matches 3 :true
Region Matches 3 :false

public String[] split(String reg_exp) – It splits the string around the regular expression and returns a String array.
Variation :
public String[] split(String reg_exp, int limit) – It splits the string around the regular expression and limit refers to the number of times the reg_exp is applied and it is the length of the resulting array and reg_exp is n is applied only length – 1 times.

Lets see an example of the above methods:
Example:

// Java Program to demonstrate 
// split 
class GFG_8 { 
public static void main(String[] args) 
    { 
        String s = "Geeks for Geeks"; 
  
        // split 
        System.out.println("Spliting the string a"
                           + "round spaces"); 
        String[] geek_arr = s.split("\s+"); 
        for (String i : geek_arr) 
            System.out.println(i); 
  
        System.out.println("
Spliting the string around the spaces"
                           + "
but controlling the length of resulting array :"); 
        String s_1 = "Geeks for Geeks Geeks for Geeks"; 
        String[] geek_arr1 = s_1.split("\s+", 2); 
        for (String i : geek_arr1) 
            System.out.println(i); 
  
        System.out.println("
Spliting the string around the spaces"
                           + "
but controlling the length of resulting array :"); 
        geek_arr1 = s_1.split("\s+", 4); 
        for (String i : geek_arr1) 
            System.out.println(i); 
    } 
} 

Output:

Spliting the string around spaces
Geeks
for
Geeks

Spliting the string around the spaces
but controlling the length of resultng array :
Geeks
for Geeks Geeks for Geeks

Spliting the string around the spaces
but controlling the length of resultng array :
Geeks
for
Geeks
Geeks for Geeks

public static String join(CharSequence de_limiter, CharSequence… elements) – It returns a string which contains all the elements joins by the de_limiter.
Variation:
public static String join(CharSequence de_limiter, Iterable elements) – It performs the same function but the second parameter is Iterable which makes it flexible to work with different collection classes.

Lets see an example of the above methods:
Example:

// Java Program to demonstrate 
// join 
import java.util.LinkedList; 
class GFG_9 { 
public static void main(String[] args) 
    { 
        // join() 
        System.out.print("Example of join 1 : "); 
        System.out.println( 
            String.join(", ", "Geeks", "for", "Geeks")); 
  
        System.out.print("Example of join 2 : "); 
        LinkedList<String> ll = new LinkedList<String>(); 
        ll.add("browsing"); 
        ll.add("geeks"); 
        ll.add("for"); 
        ll.add("geeks"); 
        ll.add("is"); 
        ll.add("fun"); 
        System.out.println(String.join("-a-", ll)); 
    } 
} 

Output:

Example of join 1 : Geeks, for, Geeks
Example of join 2 : browsing-a-geeks-a-for-a-geeks-a-is-a-fun

public String replaceAll(String reg_exp, String replacement) – It replaces all the Substring of the original string that matches the reg_exp with replacement and returns the modified String.
public String replaceFirst(String reg_exp, String replacement) – It replaces the first occurrence of the reg-exp in the original string with the replacement and returns the modified String.
Note :- replaceAll and replaceFirst does’nt changes the original String rather it creates a new string with modification.

Lets see an example of the above methods:
Example:

// Java Program to demonstrate 
// replaceAll and replaceFirst 
class GFG_10 { 
public static void main(String[] args) 
    { 
        String s = "GeeksforGeeks"; 
        ; 
  
        // replaceAll() 
        String s1 = s.replaceAll("Geeks", "Quiks"); 
        System.out.println("Replace all Geeks "
                           + "with Quiks :" + s1); 
  
        System.out.print("Replace any UpperCase letter "
                         + "with F :"); 
        System.out.println(s.replaceAll("[A-Z]+", "F")); 
  
        // replaceFirst() 
        String s2 = s.replaceFirst("Geeks", "Quiks"); 
        System.out.println("Replace first Occurance"
                           + "of Geeks with Quiks :" + s2); 
    } 
} 

Output:

Replace all Geeks with Quiks :QuiksforQuiks
Replace any UpperCase letter with F :FeeksforFeeks
Replace first Occuranceof Geeks with Quiks :QuiksforGeeks

For more methods on String refer to String class in java
Reference:
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Java.lang.String class in Java | Set 2

tags:

leave a comment

0 Comments

Subscribe to Our Newsletter

Top Followed books