STRING AND STRING
MANIPULATION
Contents:
1. What Is String?
2. Creating and Using Strings
Declaring, Initializing, Reading and Printing
3. Manipulating Strings
Comparing, Concatenating, Searching, Extracting Substrings,
Splitting
4. Other String Operations
Replacing Substrings, Deleting Substrings, Changing Character
Casing, Trimming
5. Building and Modifying Strings
Using StringBuilder Class
6. Formatting Strings
WHAT IS STRING?
String is:
A sequence of characters
Each character is a Unicode character
Represented by the String (java.lang.String) data type in Java
Example:
String s = "Hello, Java";
s H e l l o , J a v a
java.lang.String
We use java.lang.String to work with strings in Java
String objects contain an immutable (read-only) sequence of
characters
Use Unicode in order to support multiple languages and
alphabets
Stores strings in the dynamic memory (managed heap)
java.lang.String is class
It is reference type
java.lang.String
String objects are like arrays of characters (char[])
Have fixed length “string”.length()=6…
Elements can be accessed by index
Using charAt() method
The index is in the range 0...length()-1
String s = "Hello!";
int len = s.length(); // len = 6
char ch = s.charAt(1); // ch = 'e‘`
index = 0 1 2 3 4 5
s.charAt(index) = H e l l o !
java.lang.String
Example:
String s = "Hidaya Institute of Science & Tchnology.";
System.out.println("s= "+s);
System.out.println("Length= "+s.length());
for (int i = 0; i < s.length(); i++) {
System.out.println("s["+i+"] = "+ s.charAt(i));
}
DECLARING, INITIALIZING
Declaring
We use Java String class for declaring string variables:
String str;
Not initialized variables has value of null
Initializing
Assigning a string literal
String s = "I am string literal!";
Assigning another string variable
String s2 = s;
Assigning the result of string operation
String s = "I'm " + 42 + " years old.";
STRING OBJECTS ARE IMMUTABLE
String s1 = "Java"; //Statement 1 How many String objects and reference
String s2 = s1; //Statement 2 variables are created?
s2 = s1.concat("Is"); //Statement 3
s2 = s2 + "Fun"; //Statement 4 Two Reference Variables
System.out.println("s1 = " + s1);
System.out.println("s2 = " + s2); s1
s2
String s1=“Java”;
Five String Objects/literals
s1 “Java”
String Java “Is”
reference
variable s1 String Object “JavaIs”
“Fun”
s2 “JavaIsFun”
String s2=s1;
String
reference Statement 1 creates one reference variable s1, one string
variable s2 object “Java”
Statement 2 creates one reference variable s2
STRING OBJECTS ARE IMMUTABLE
Statement 3: s2=s1.concat(“Is”);
s1
String
reference Java
variable s1 Is
String Object
String Object
s2
String JavaIs
reference
variable s2 String Object
Statement 3 creates, Two String Objects, “Java” and “JavaIs”
and makes s2 refer to newly created object “JavaIs”
STRING OBJECTS ARE IMMUTABLE
Statement 3: s2=s2+”Fun”;
s1 Is
Java String Object
String
reference String Object
variable s1 JavaIs
String Object
s2
JavaIsFun
String Fun
reference String Object
String Object
variable s2
Statement 4 creates, Two String Objects, “Fun” and “JavaIsFun”
and makes s2 refer to newly created object “JavaIsFun”
READING AND PRINTING STRINGS
Reading strings from the console
java.util.Scanner input=new java.util.Scanner(System.in);
Use the method input.nextLine()
String s = input.nextLine();
Printng Strings to the console
Use methods print() and println()
System.out.print("Please enter your name: ");
String name = input.nextLine();
System.out.println(name);
MANIPULATING STRINGS
Comparing, Concatenating, Searching, Extracting Substrings, Splitting
Comparing Strings:
There are a number of ways to compare two strings:
Dictionary-based string comparison
Case-insensitive
int result = str1.compareToIgnoreCase(str2);
// result == 0 if str1 equals str2
// result < 0 if str1 if before str2
// result > 0 if str1 if after str2
Case-sensitive
str1.compareTo(str2);
COMPARING STRINGS (2)
Equality checking by equalsIgnoreCase()
Performs case-insensitive compare
Returns boolean value
if (str1.equalsIgnoreCase(str2)){
…
}
The case-sensitive equals() method
if (str1.equals(str2)){
…
}
COMPARING STRINGS – EXAMPLE
Finding the first in a lexicographical order string from a given list of
strings
String[] towns = {"Jamshoro", “Hyderabad",
"Qasimabad","Latifabad", "Kotri", "Heerabad"};
String firstTown = towns[0];
for (int i=1; i<towns.length; i++) {
String currentTown = towns[i];
if (currentTown.compareTo(firstTown) < 0) {
firstTown = currentTown;
}
}
System.out.println("First town: " + firstTown);
java.lang.STRING
Operators == and != does not check for equality!
These operators returns boolean value, but check if the
addresses of the object are equal
Use equals() and equalsIgnoreCase() instead
String str1 = new String("Hello");
String str2 = str1;
System.out.println((str1==str2)); // true
String str1 = "Hello";
String str2 = "Hello";
System.out.println((str1==str2)); // true!!!
String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println((str1==str2)); // This is false!
CONCATENATING STRINGS
There are two ways to combine strings:
Using the concat() method
String str = str1.concat(str2);
Using the + or the += operator
String str = str1 + str2 + str3;
String str += str1;
Any object can be appended to string
String name = “Asad";
int age = 23;
String s = name +" "+ age;// “Asad 23"
CONCATENATING STRINGS – EXAMPLE
String firstName = “Asad";
String lastName = “Khan";
String fullName = firstName + " " + lastName;
int age = 23;
String nameAndAge = "Name: " + fullName +
"\nAge: " + age;
System.out.println(nameAndAge);
// Name: Asad Khan
// Age: 23
SEARCHING STRINGS
Finding a character or substring within given string
First occurrence
indexOf(String str)
First occurrence starting at given position
indexOf(String str, int fromIndex)
Last occurrence
lastIndexOf(String)
Last occurrence before given position
lastIndexOf(String, int fromIndex)
SEARCHING STRINGS – EXAMPLE
String str = "Java Programming Course";
int index = str.indexOf("Java"); // index = 0
index = str.indexOf("Course"); // index = 17
index = str.indexOf("COURSE"); // index = -1
// indexOf is case sensetive. -1 means not found
index = str.indexOf("ram"); // index = 9
index = str.indexOf("r"); // index = 6
index = str.indexOf("r", 7); // index = 9
index = str.indexOf("r", 10); // index = 20
i = 0 1 2 3 4 5 6 7 8 9 10 11 12 …
s.charAt(i) = J a v a P r o g r a m m …
EXTRACTING SUBSTRINGS
Extracting substrings
str.substring(int beginIndex, int endIndex)
lastIndex is not included
String filename = "C:\\Pics\\Rila2005.jpg";
String name = filename.substring(8, 16);
// name is Rila2005
str.substring(int beginIndex)
String filename = "C:\\Pics\\Raila2005.jpg";
String nameAndExtension = filename.substring(8);
// nameAndExtension is Rila2005.jpg
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
C : \\ P i c s \\ R i l a 2 0 0 5 . j p g
SPLITTING STRINGS
To split a string by given separator(s) use the following
method:
String[] split(String regex)
String regex – String with special format
We can list the character which we want to use for
separator in square brackets […]
String[] parts = "Ivan; Petar,Gosho".split("[;,]");
// this wil separate the stirng into three parts
// "Ivan", " Petar" and "Gosho"
SPLITTING STRINGS - EXAMPLE
String ListOfCourses = "Java, ASP, PHP, Linux.";
String[] Courses = ListOfCourses.split("[ ,.]");
System.out.println("Available Courses are:");
for (String Course : Courses)
System.out.println(Course);
OTHER STRING OPERATIONS
Replacing Substrings, Changing Character Casing, Trimming
REPLACING SUBSTRINGS
replace(String, String) – replaces all occurrences of
given string with another
The result is new string (strings are immutable)
String cocktail = "Vodka + Martini + Cherry";
String replaced = cocktail.replace("+", "and");
// Vodka and Martini and Cherry
CHANGING CHARACTER CASING
Using method toLowerCase()
String alpha = "aBcDeFg";
String lowerAlpha = alpha.toLowerCase(); // abcdefg
System.out.println(lowerAlpha);
Using method toUpperCase()
String alpha = "aBcDeFg";
String upperAlpha = alpha.toUpperCase(); // ABCDEFG
System.out.println(upperAlpha);
TRIMMING WHITE SPACE
Using method trim()
String s = " example of white space ";
String clean = s.trim();
System.out.println(clean);
BUILDING AND MODIFYING
STRINGS
Using StringBuilder Class
CONSTRUCTING STRINGS
Strings are immutable
concat(), replace(), trim(), ... return new string, do not modify
the old one
Do not use "+" for strings in a loop!
It runs very inefficiently!
public static string dupChar(char ch, int count){
String result = "";
for (int i=0; i<count; i++)
result += ch;
return result;
} Bad practice.
Avoid this!
CHANGING THE CONTENTS OF A
STRING – STRINGBUILDER
Use the java.lang.StringBuilder class for modifiable strings of
characters:
Use StringBuilder if you need to keep adding characters to a
string
public static String reverseIt(String s) {
StringBuilder sb = new StringBuilder();
for (int i = s.length()-1; i >= 0; i--)
sb.append(s.charAt(i));
return sb.toString();
}
THE STRINGBUILDER CLASS
Capacity
StringBuilder: H e l l o , J a v a !
length() = 11
capacity() = 15 used buffer unused
(length()) buffer
StringBuilder keeps a buffer memory, allocated in advance
Most operations use the buffer memory and do not allocate new
objects
THE STRINGBUILDER CLASS (2)
StringBuilder(int capacity) constructor allocates in advance
buffer memory of a given size
By default 16 characters are allocated
capacity() holds the currently allocated space (in characters)
charAt(int index) gives access to the char value at given position
length() hold the length of the string in the buffer
THE STRINGBUILDER CLASS (3)
append(…) appends string or other object after the last character
in the buffer
delete(int start, int end) removes the characters in given
range
insert(int offset, String str) inserts given string (or object)
at given position
replace(int start, int end, String str) replaces all
occurrences of a substring with given string
toString() converts the StringBuilder to String object
STRINGBUILDER – EXAMPLE
Extracting all capital letters from a string
public static String extractCapitals(String s) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
if (Character.isUpperCase(ch)) {
result.append(ch);
}
}
return result.toString();
}
HOW THE + OPERATOR DOES STRING
CONCATENATIONS?
Consider following string concatenation:
String result = str1 + str2;
It is equivalent to this code:
StringBuffer sb = new StringBuffer();
sb.append(str1);
sb.append(str2);
String result = sb.toString();
Actually several new objects are created and leaved to the
garbage collector
What happens when using + in a loop?
FORMATTING STRINGS
Using toString()
METHOD toString()
All classes have this public virtual method derived from
Object class
Returns a human-readable, culture-sensitive string representing
the object
Most Java Platform types have own implementation of
toString()
