by Dinesh Thakur

Searching a string for finding the location of either a character or group of characters (substring) is a common task. For example: In some situations, usernames and passwords are stored in a single string in which they are separated from each other by a special character such as colon (Example: username : password). In order to get the username and password separately from such a string, there must be some method such that we can search the string and return the location of the colon character. The String class provides the following methods for performing these tasks,

indexOf();

lastIndexOf ();

int indexOf (int ch) : This method returns the index position of the first occurrence of the character ch in the string. If the specified character ch is not found within the string then -1 is returned. For example:

The statement, sl. indexOf ( 'e') will return 1as index starts from 0.

Another version of this method is int indexOf (String str)

It is same as above except that it accepts a string argument. For example,

s3.indexOf("there")

will return 6 i.e. the index position of the first occurrence of substring "there" in the string.

int indexOf (int ch, int fromIndex) : This method is same as the preceding method but the only difference is that the search will start from the specified index (i.e. fromIndex)

instead of 0. For example, s1. indexOf ( 'e' ,2) will return 6 as searching will start from index 2.

Another version of this method is int indexOf (String str, int fromIndex)

It is same as above except that it accepts a string as the first argument instead of a character.

For example, The statement s3.indexOf ("there", 8) will return 23.

The lastIndexOf () method also has four versions as that in case of indexOf () method. The four versions of lastIndexOf () method have the same parameters as the four versions of the indexOf ()method. The difference is that this method locates the last occurrence of the character or substring in the string depending upon the argument passed. This method performs the search from the end of the string towards the beginning of the string. If it finds the character or substring, the index is returned otherwise it returns -1. For example, consider the following statements.

sl.lastIndexOf('e') // returns 6

s2.lastIndexOf('e',3) // returns 1

s3.lastIndexOf("there") // returns -23

s3.lastIndexOf("there",20) // returns 6

s3.lastIndexOf("Hi",5) // returns -1

public class SearchingStrings 
{
      public static void main(String[] args)
      {
         String str = "Dinesh Thakur" ;
         System.out.println("str.indexOf('e') = "+ str.indexOf('e'));
         System.out.println("str.indexOf('e,3) = "+str.indexOf('e',3) );
         System.out.println("str.indexOf(\"Thakur\") = " +str.indexOf("Thakur"));
         System.out.println("str.indexOf(\"Thakur\",4) = "+str.indexOf("Thakur",4));
         System.out.println("str.lastindexOf('e') = "+str.lastIndexOf('e'));
         System.out.println("str.lastindexOf('e',3) = "+str.lastIndexOf('e',3));
         System.out.println("str.lastindexOf(\"Thakur\') = "+ str.lastIndexOf("Thakur") );
         System.out.println("str.lastindexOf(\"Thakur\",4) = "+str.lastIndexOf("Thakur",4) );
         }
}

Searching Strings in Java

public class SearchingStrings 

{
            public static void main(String args[])
            {
                        String s = "God is Great";
                        String t = " Beleive in God ";
                        int m,n;
                        System.out.println(s);
                        System.out.println(s.toUpperCase());
                        System.out.println(s.toLowerCase());
                        System.out.println(s+t);
                        t=t.trim();
                        System.out.println(t);
                        s=s.replace('i','I');
                        s=s.replace('s','S');
                        System.out.println(s);
                        m = s.indexOf('I');
                        n = s.indexOf('S');
                        char k[] = s.toCharArray();
                        k[m]='i';
                        k[n]='s';
                        s = new String(k);
                        System.out.println(s);
            }
}

Searching Strings