String functions

Strings
•Zero or more characters put within
double quotes("")
•Examples:
i. "2"
ii. " "
iii. ""
iv. "dgsdgs"
v. "23 kjkg ,,..."

String is the name of a class present
inside java.lang package.

String s; or String s="";
s=“Good Morning!";
How to declare & initialise a string variable?
String s=“Good Morning!";

String s=new String(“Good Morning!";);
String p=“Good Morning!";
String s= new String(p);

String s="";
s=sc.next(); - to accept a word from
the user
s=sc.nextLine(); - to accept more than
one word from the user

String s= "Good begets Good";
Good begets Good
0 6
7
8
9
10
11
2 4
31 5 13 15
1412

length() – returns the no: of characters in the string.
Example:
String s=“Good begets Good”;
System.out.println(s.length());
Output:
Please Note:
We always say the positions in terms of index. Index always
starts from Zero, just like arrays.
Return type is intlength()
16

indexOf() Return type is int
indexOf() – returns the index of the first occurrence
of a particular character.
Examples:
s.indexOf('b') = 5
s.indexOf('g') = 7
s.indexOf('G') = ?
s.indexOf('e') = ?

s.indexOf('G') = 0
s.indexOf('e') = 6
s.indexOf('z')=?
s.indexOf('z')=-1;
Please Note:
If the character is not present in
the string, it always returns -1.

lastIndexOf() Return type is int
lastIndexOf() – returns the index of the last
occurrence of a particular character.
Examples:
s.lastIndexOf('b') = 5
s. lastIndexOf('g') = 7
s. lastIndexOf('G') = 12
s. lastIndexOf('e') = 8

Examples:
Examples:
1.System.out.println(s.charAt(9));
Output:
2.System.out.printl(“p”+s.charAt(4) +”q”);
Output:
Return type is charcharAt()
charAt() – returns the character at the given index.
t
p q

substring()– returns a part of the string.
substring() Return type is String
s.substring(i) - returns the string from
the index 'i' onwards.
Example:
System.out.println(s.substring(9));
Output: ts Good

Remember that substring() does not
take the character specified by the last
index.
Example:
System.out.println(s.substring(5,10));
Output:
Here 's' is not included because the last index 10 is
ignored.
s.substring(i,j) - returns the string from
index 'i' to 'j-1‘.
beget

trim()
String s=“ Welcome to Java “;
System.out.println(“Hello”+s.trim()+”World”);
Output:
String s=“ Welcome to Java “;
System.out.println(“Hello”+s+”World”);
Output:
trim() – removes all spaces at the beginning and end
of the string.
Hello Welcome to Java World
HelloWelcome to JavaWorld
Return type is String

toLowerCase()
Please Note:
Simply writing s.toLowerCase() will not change the original string. If
you want to change the original string, the statement is:
s = s.toLowerCase();
String s=“GooD MorninG“;
System.out.println(s.toLowerCase());
Output:
toLowerCase() – converts the characters in the
string into lowercase letters.
good morning

toUpperCase()
Please Note:
Simply writing s.toUpperCase() will not change the original string. If
you want to change the original string, the statement is:
s = s.toUpperCase();
String s=“GooD MorninG“;
System.out.println(s.toUpperCase());
Output:
toUpperCase() – converts the characters in the
string into uppercase letters.
GOOD MORNING

concat()
Please Note:
String s3= s1+s2;
The above statement also joins the two strings.
System.out.println(s3);
Output: GoodMorning
String s1=“Good”;
String s2=“Morning”;
System.out.println(s1.concat(s2));
Output:
concat() – joins two strings.
GoodMorning

replace()
Please Note:
s=s.replace(‘a’,’z’);
String s=“abcabcabcabcabcabc”;
System.out.println(s.replace(‘a’,’z’));
Output:
replace() – replaces all the occurrences of a
particular character with another character.
zbczbczbczbczbczbc

startsWith()
Please Note:
In the above example, C and c are different in case. So
the output is false.
String s1=“Computer”;
String s2=“com”;
System.out.println(s1.startsWith(s2));
OR
System.out.println(“Computer”.startsWith(“computer”));
Output:
startsWith() – checks whether the string starts with
a particular string. If yes, it returns true; otherwise
it returns false.
false
Return type is boolean

endsWith()
Please Note:
In the above example, C and c are different in case. So
the output is false.
String s2=“ter”;
System.out.println(s1.endsWith(s2));
Output:
endsWith() – checks whether the string ends with a
particular string. If yes, it returns true; otherwise it
returns false.
true

valueOf ()
Please Note:
Using valueOf(), we can convert int, long, boolean,
float, double etc. (all types) to string.
int x=10;
String s=String.valueOf(10);
System.out.println(x+9);
System.out.println(s+9);
Output:
valueOf() – converts different types of values into
string.
19
109

equals()
Please Note:
equals() is case sensitive.
String s2=“ComputerR”;
System.out.println(s1.equals(s2));
OR
System.out.println(“Computer”.equals(“ComputeR”));
Output:
eauals() – checks whether two strings are same or
not. If yes, it returns true; otherwise it returns false.
false

equalsIgnoreCase()
String s2=“ComputerR”;
System.out.println(s1.equals(s2));
Output:
eaualsIgnoreCase() – checks whether two strings are
same or not, irrespective of cases. If yes, it returns
true; otherwise it returns false.
true

compareTo()
 compareTo() – compares two strings
lexicographically.
 Each character of both the strings is converted
into a Unicode value for comparison.
 If both strings are equal, it returns 0; else it
returns a positive or negative value.
Return type is int

String s1=“abc”;

1. First it checks 97-97. It is zero.
2. Now it checks 98-98. It is zero.
4. Since all the values are zero, the strings are
equal. Hence it returns 0.

String s1=“abd”;

3. Now it checks 100-99. It is +1.
4. Since we get +1, we can say that the first string is
lexicographically greater than the second string.
Non-zero value indicates that the two strings are
not the same.

3. Now it checks 99-100. It is -1.
4. Since we get +1, we can say that the second
string is lexicographically greater than the first
string. Non-zero value indicates that the two
strings are not the same.

String s2=“agd”;

String s2=“agd”;
2. Now it checks 98-103. It is -5.
3. If the result is not zero, it stops further
comparison and returns the first difference got.
Here it return -5.

String s1=“Abc”;

1. First it checks 65-97. It is -32.
2. Since it is not zero, it stops further comaprison.
3. compareTo() is case sensitive.

String s1=“abcdef”;

4. The second string ends, but 3 more characters left in the first
string.
5. It returns the number of extra characters . Here it is +3 because
the first string is having more characters.

String s1=“abcd”;
4. The second string ends, but 3 more characters left in the second
string.
5. It returns the number of extra characters . Here it is -3 because
the second string is having more characters.

compareToIgnoreCase()
 compareToIgnoreCase() – compares two strings
lexicographically, irrespective of the cases.
Return type is int

1. s1.compareTo() returns -32 as the value.
2. s1.compareToIgnoreCase() returns 0 as the value.
3. To find s1.compareToIgnoreCase(), we can either take
the Unicode value of lower case letters for both
strings or upper case letters for both strings .
4. In the above example, either 65-65 or 97-97 can be
taken.

String functions

More Related Content

What's hot (19)

Similar to String functions (20)

Recently uploaded (20)

String functions