1

Object Oriented
Programming
Techniques
Lecture 6: String and StringBuffer
 2

Strings
• Strings are fundamental part of all computing
languages.
• At the basic level, they are just a data structure that
can hold a series of characters
• However, strings are not implemented as a
character array in Java as in other languages.
 3

Strings
• Java string is a sequence of characters. They are
objects of type String.
• Once a String object is created it cannot be changed.
Stings are Immutable.
• To get changeable strings use the class called
StringBuffer.
• String and StringBuffer classes are declared final, so
there cannot be subclasses of these classes.
• The default constructor creates an empty string.
String s = new String();
 4

Creating Strings
• String str = "abc"; is equivalent to:

char data[] = {'a', 'b', 'c'};

String str = new String(data);

• If data array in the above example is modified after

the string object str is created, then str remains
unchanged.
• Construct a string object by passing another string
object.
String str2 = new String(str);
 5

String Operations
• The length() method returns the length of the string.

Eg: System.out.println(“Hello”.length()); // prints 5

• The + operator is used to concatenate two or more
strings.
Eg: String myname = “Harry”
String str = “My name is” + myname+ “.”;
• For string concatenation the Java compiler converts an
operand to a String whenever the other operand of the + is
a String object.
 6

String Operations
• Characters in a string can be extracted in a
number of ways.
public char charAt(int index)
• Returns the character at the specified index.
An index ranges from 0 to length() - 1. The
first character of the sequence is at index 0,
the next at index 1, and so on, as for array
indexing.
char ch;
ch = “abc”.charAt(1); // ch = “b”
 7

String Operations
• getChars() - Copies characters from this string into the
destination character array.
public void getChars(int srcBegin, int srcEnd,
char[] dst, int dstBegin)

• srcBegin - index of the first character in the string to copy.

• srcEnd - index after the last character in the string to copy.
• dst - the destination array.
• dstBegin - the start offset in the destination array.
 8

String Operations
• equals() - Compares the invoking string to the
specified object. The result is true if and only if the
argument is not null and is a String object that
represents the same sequence of characters as the
invoking object.
public boolean equals(Object anObject)

• equalsIgnoreCase()- Compares this String to

another String, ignoring case considerations. Two
strings are considered equal ignoring case if they
are of the same length, and corresponding
characters in the two strings are equal ignoring
case.
public boolean equalsIgnoreCase(String
anotherString)
 9
String Examples

String name = "Craig";

String name2 = "Craig";

if (name.equals(name2))
System.out.println("The names are the same");

String name = "Craig Schock";

int lastNameIndex = name.indexOf("Schock");

String grade = "B+";

double gpa = 0.0;

if (grade.charAt(0) == 'B')
gpa = 3.0;

if (grade.charAt(1) == '+')
gpa = gpa + 0.3;
 10
Testing Strings for Equality

Important note: The == operator cannot be used to test String

objects for equality
Variables of type String are references to objects (ie. memory
addresses)
Comparing two String objects using == actually compares their memory
addresses. Two separate String objects may contain the equivalent
text, but reside at different memory locations.
• Use the equals method to test for equality.
 11

String Operations
• startsWith() – Tests if this string starts with the
specified prefix.
public boolean startsWith(String prefix)
“Figure”.startsWith(“Fig”); // true

• endsWith() - Tests if this string ends with the

specified suffix.

public boolean endsWith(String suffix)

“Figure”.endsWith(“re”); // true
 12

String Operations

• startsWith() -Tests if this string starts with

the specified prefix beginning at a specified
index.
public boolean startsWith(String prefix,
int toffset)
prefix - the prefix.
toffset - where to begin looking
in the string.

“figure”.startsWith(“gure”, 2); // true

 13

String Operations

• compareTo() - Compares two strings

lexicographically.
• The result is a negative integer if this String object
lexicographically precedes the argument string.
• The result is a positive integer if this String object
lexicographically follows the argument string.
• The result is zero if the strings are equal.
• compareTo returns 0 exactly when the equals(Object)
method would return true.
public int compareTo(String anotherString)
public int compareToIgnoreCase(String str)
 14

String Operations
indexOf – Searches for the first occurrence of a character or
substring. Returns -1 if the character does not occur.

public int indexOf(int ch)- Returns the index within

this string of the first occurrence of the specified character.
public int indexOf(String str) - Returns the index
within this string of the first occurrence of the specified
substring.

String str = “How was your day today?”;

str.indexof(‘t’);
str(“was”);
 15

String Operations
public int indexOf(int ch, int fromIndex)-
Returns the index within this string of the first
occurrence of the specified character, starting the
search at the specified index.

public int indexOf(String str, int fromIndex) -

Returns the index within this string of the first
occurrence of the specified substring, starting at the
specified index.

String str = “How was your day today?”;

str.indexof(‘a’, 6);
str(“was”, 2);
 16

String Operations
lastIndexOf() –Searches for the last occurrence of
a character or substring. The methods are similar
to indexOf().
substring() - Returns a new string that is a
substring of this string. The substring begins with
the character at the specified index and extends
to the end of this string.
public String substring(int beginIndex)
Eg: "unhappy".substring(2) returns "happy"
 17

String Operations
• public String
substring(int beginIndex,
int endIndex)
Eg: "smiles".substring(1, 5) returns
"mile“
 18

String Operations
concat() - Concatenates the specified string to
the end of this string.
If the length of the argument string is 0, then
this String object is returned.
Otherwise, a new String object is created,
containing the invoking string with the
contents of the str appended to it.

public String concat(String str)

"to".concat("get").concat("her") returns
"together"
 19

String Operations
• replace()- Returns a new string resulting from
replacing all occurrences of oldChar in this
string with newChar.

public String replace(char oldChar,

char newChar)

"mesquite in your cellar".replace('e', 'o')

returns "mosquito in your collar"
 20

String Operations
• trim() - Returns a copy of the string, with leading
and trailing whitespace omitted.
public String trim()

String s = “ Hi Mom! “.trim();

S = “Hi Mom!”

• valueOf() – Returns the string representation of

the char array argument.

public static String valueOf(char[] data)

 21

String Operations
• The contents of the character array are copied;
subsequent modification of the character array does not
affect the newly created string.

Other forms are:

public static String valueOf(char c)
public static String valueOf(boolean b)
public static String valueOf(int i)
public static String valueOf(long l)
public static String valueOf(float f)
public static String valueOf(double d)

• Conversion from primitive to string

toString();
 22

String Operations
• toLowerCase(): Converts all of the characters in a
String to lower case.
• toUpperCase(): Converts all of the characters in this
String to upper case.

public String toLowerCase()

public String toUpperCase()

Eg: “HELLO THERE”.toLowerCase();

“hello there”.toUpperCase();
 23

Immutability
• Once created, a string cannot be changed:
none of its methods changes the string.
• Such objects are called immutable.
• Immutable objects are convenient because
several references can point to the same
object safely: there is no danger of changing
an object through one reference without the
others being aware of the change.
 24

Advantages Of Immutability

Uses less memory.

String word1 = "Java"; String word1 = “Java";

String word2 = word1; String word2 = new String(word1);

word word “Java"

1 1
“Java" word “Java"
word 2
2 Less efficient:
OK wastes memory
 25

Disadvantages of Immutability
Less efficient — you need to create a new string and
throw away the old one even for small changes.

String word = “Java";

char ch = Character.toUpperCase(word.charAt (0));
word = ch + word.substring (1);

word “java"

“Java"
 26

Empty Strings

• An empty String has no characters. It’s

length is 0.
String word1 = ""; Empty strings
String word2 = new String();

• Notprivate String errorMsg;

the same errorMsg
as an uninitialized String.
is null
 27
Example String str1
public class MatchStrings Too many
{static String str1 = "Too many"; Str2
public static void main(String[] args)
{ String str2 = "Too many"; Too many
String str3 = new String(str2);
System.out.println("1: " + str1==str2);// Check reference
System.out.println("2: " + str1.equals(str2));
System.out.println("3: " + str2==str3);
System.out.println("4: " + str2.equals(str3)); str3
System.out.println(str1.startsWith("Too"));
System.out.println(str1.startsWith("many",4));
System.out.println(str1.substring(2,7));// extract from 2 to 6}}
1:true True
2: true True
3:false o man
4: true
StringBuffer & StringBuilder 28

String and StringBuffer both are final classes(can’t

subclassed)
StringBuffer
•StringBuffer is mutable means one can change the value of the object . The
object created through StringBuffer is stored in the heap .
•StringBuffer has the same methods as the StringBuilder , but each method
in StringBuffer is synchronized that is StringBuffer is thread safe .
• StringBuilder is faster than the StringBuffer because thread safe has
disadvantages of performance degradation.

StringBuilder
•StringBuilder is same as the StringBuffer , that is it stores the object in heap
and it can also be modified . The main difference between the StringBuffer and
StringBuilder is that StringBuilder is also not thread safe.
StringBuilder is fast as it is not thread safe .

•Note: StringBuilder was introduced in Java 1.5 (so if you happen to

use versions 1.4 or below you’ll have to use StringBuffer)
 29

StringBuilder

StringBuilder()
This constructs a string builder with no characters in it and an initial
capacity of 16 characters.

StringBuilder(CharSequence seq)
This constructs a string builder that contains the same characters
as the specified CharSequence.

StringBuilder(int capacity)
This constructs a string builder with no characters in it and an initial
capacity specified by the capacity argument. capacity is the
available rooms cannot be less than zero.

StringBuilder(String str)
This constructs a string builder initialized to the contents of the
specified string.
Capacity= length+16 more characters
 30

StringBuffer
• A StringBuffer is like a String, but can be
modified.
• The length and content of the StringBuffer
sequence can be changed through certain
method calls.
• StringBuffer defines three constructors:

• StringBuffer()
• StringBuffer(int size)
• StringBuffer(String str)
 31

StringBuffer Operations
• The principal operations on a StringBuffer are
the append and insert methods, which are
overloaded so as to accept data of any type.

Here are few append methods:

StringBuffer append(String str)
StringBuffer append(int num)

• The append method always adds these

characters at the end of the buffer.
 32

StringBuffer Operations

• The insert method adds the characters at a

specified point.

Here are few insert methods:

StringBuffer insert(int index, String str)
StringBuffer append(int index, char ch)

Index specifies at which point the string will

be inserted into the invoking StringBuffer
object.
 33

StringBuffer Operations

• delete() - Removes the characters in a

substring of this StringBuffer. The substring
begins at the specified start and extends to the
character at index end - 1 or to the end of the
StringBuffer if no such character exists. If start
is equal to end, no changes are made.

public StringBuffer delete(int start, int end)

 34

StringBuffer Operations
• replace() - Replaces the characters in a substring of
this StringBuffer with characters in the specified
String.
public StringBuffer replace(int start, int end, String
str)

• substring() - Returns a new String that contains a

subsequence of characters currently contained in this
StringBuffer. The substring begins at the specified
index and extends to the end of the StringBuffer.
public String substring(int start)
 35

StringBuffer Operations
• reverse() - The character sequence
contained in this string buffer is replaced
by the reverse of the sequence.
public StringBuffer reverse()

• length() - Returns the length of this string

buffer.
public int length()
 36

StringBuffer Operations

• capacity() - Returns the current capacity of

the String buffer. The capacity is the amount
of storage available for newly inserted
characters.
public int capacity()
• charAt() - The specified character of the
sequence currently represented by the string
buffer, as indicated by the index argument, is
returned.
public char charAt(int index)
 37

StringBuffer Operations
• ensureCapacity() method of StringBuffer
class ensures the capacity to at least equal to the
specified minimumCapacity.
• If the current capacity of StringBuffer < the argument
minimumCapacity, then a new internal array is allocated with
greater capacity.
• If the minimumCapacity argument > twice the old capacity,
plus 2 then new capacity is equal to minimumCapacity else
new capacity is equal to twice the old capacity, plus 2.
• If the minimumCapacity argument passed as parameter < 0,
this method takes no action.

• public void ensureCapacity(int minimumCapacity)

ensureCapacity(40)larger between two(32+32+2=66)
 38

StringBuffer Operations
• getChars() - Characters are copied from this string
buffer into the destination character array dst. The
first character to be copied is at index srcBegin; the
last character to be copied is at index srcEnd-1.
public void getChars(int srcBegin, int srcEnd,
char[] dst, int dstBegin)

• setLength() - Sets the length of the StringBuffer.

public void setLength(int newLength)
 39

Examples: StringBuffer
StringBuffer sb = new StringBuffer(“Hello”);

sb.length(); // 5

sb.capacity(); // 21 (16 characters room is

added if no size is specified)

sb.charAt(1); // e

sb.setCharAt(1,’i’); // Hillo

sb.setLength(2); // Hi

sb.append(“l”).append(“l”); // Hill

sb.insert(0, “Big “); // Big Hill

 40

Examples: StringBuffer

sb.replace(3, 11, “”); // Big

sb.reverse(); // gib
 41
Example StringBuilder

public class Exampel

{public static void main(String[] args)
{StringBuilder buffer=new StringBuilder ("banana split")
buffer. delete (4,12) // 12-4=8 // bana
buffer. append (42) // bana42
buffer. insert (4,"na"); //bana42
buffer.setcharAt(0,'s') //sbanana42
buffer.reverse (); // 24 ananas
}}
StringBuilder StrBuf =new StringBuilder ("Javv") //Cap 20
StrBuf . setcharAt(StrBuf.lengh ()-1, StrBuf.charAt(1));
o/p Java