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()