MODERN PROGRAMMING TOOLS AND TECHNIQUES-1 String and StringBuffer

string
• Unlike many other languages that implement strings as character arrays, Java implements strings as objects of type String. • Advantage of creating strings as objects is that String objects can be constructed a number of ways, making it easy to obtain a string when needed.

• Once a String object has been created, you cannot change the characters that comprise that string.
• You can still perform all types of string operations. The difference is that each time we need an altered version of an existing string, a new String object is created that contains the modifications. The original string is left unchanged. • This approach is used because fixed, immutable strings can be implemented more efficiently than changeable ones.

string
• For those cases in which a modifiable string is desired, Java provides two options: StringBuffer and StringBuilder. Both hold strings that can be modified after they are created. • The String, StringBuffer, and StringBuilder classes are defined in java.lang. Thus, they are available to all programs automatically.
• The String, StringBuffer, and StringBuilder classes are declared final, which means that none of these classes may be subclassed.

The String Constructors
• The String class supports several constructors. To create an empty String, you call the default constructor. For example, String s = new String(); will create an instance of String with no characters in it.

• Frequently, we want to create strings that have initial values. The String class provides a variety of constructors to handle this. To create a String initialized by an array of characters, use the constructor shown here: String(char chars[ ]) Here is an example: char chars[] = { 'a', 'b', 'c' }; String s = new String(chars); This constructor initializes s with the string “abc”.

The String Constructors
• We can specify a subrange of a character array as an initializer using the following constructor: String(char chars[ ], int startIndex, int numChars) Here, startIndex specifies the index at which the subrange begins, and numChars specifies the number of characters to use. Here is an example: char chars[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; String s = new String(chars, 2, 3);

The String Constructors
• We can construct a String object that contains the same character sequence as another String object using this constructor: String(String strObj) Here, strObj is a String object. Consider this example: // Construct one String from another. class MakeString { public static void main(String args[]) { char c[] = {'J', 'a', 'v', 'a'}; String s1 = new String(c); String s2 = new String(s1); System.out.println(s1); System.out.println(s2); } }

The String Constructors
• Because 8-bit ASCII strings are common, the String class provides constructors that initialize a string when given a byte array. Their forms are shown here:

String(byte asciiChars[ ]) String(byte asciiChars[ ], int startIndex, int numChars) Here, asciiChars specifies the array of bytes. The second form allows us to specify a subrange. In each of these constructors, the byte-to-character conversion is done by using the default character encoding of the platform. The following program illustrates these constructors: // Construct string from subset of char array. class SubStringCons { public static void main(String args[]) { byte ascii[] = {65, 66, 67, 68, 69, 70 }; String s1 = new String(ascii); System.out.println(s1); String s2 = new String(ascii, 2, 3); System.out.println(s2);

The String Constructors
• The contents of the array are copied whenever we create a String object from an array. If we modify the contents of the array after we have created the string, the String will be unchanged.

String Length
• The length of a string is the number of characters that it contains. To obtain this value, call the length( ) method, shown here: int length( ) • The following fragment prints “3”, since there are three characters in the string s: char chars[] = { 'a', 'b', 'c' }; String s = new String(chars); System.out.println(s.length());

String Literals
• The earlier examples showed how to explicitly create a String instance from an array of characters by using the new operator. However, there is an easier way to do this using a string literal. • For each string literal in your program, Java automatically constructs a String object. Thus, you can use a string literal to initialize a String object. For example, the following code fragment creates two equivalent strings: char chars[] = { 'a', 'b', 'c' }; String s1 = new String(chars); String s2 = "abc"; // use string literal It calls the length( ) method on the string “abc”. As expected, it prints “3”. System.out.println("abc".length());

String Concatenation with Other Data Types int age = 9; String s = "He is " + age + " years old."; System.out.println(s); String s = "four: " + 2 + 2; System.out.println(s);

Character Extraction charAt( )
To extract a single character from a String, you can refer directly to an individual character via the charAt( ) method. It has this general form: char charAt(int where) Here, where is the index of the character that you want to obtain. The value of here must be nonnegative and specify a location within the string. charAt( ) returns the character at the specified location. For example, char ch; ch = "abc".charAt(1); assigns the value “b” to ch.

Character Extraction getChars( ) If you need to extract more than one character at a time, you can use the getChars( ) method. It has this general form: void getChars(int sourceStart, int sourceEnd, char target[ ], int targetStart)

class getCharsDemo { public static void main(String args[]) { String s = "This is a demo of the getChars method."; int start = 10; int end = 14; char buf[] = new char[end - start]; s.getChars(start, end, buf, 0); System.out.println(buf); } }

Character Extraction getBytes( ) getBytes( ) uses the default character-to-byte conversions provided by the platform. Here is its simplest form: byte[ ] getBytes( ) getBytes( ) is most useful when you are exporting a String value into an environment that does not support 16-bit Unicode characters. For example, most Internet protocols and text file formats use 8-bit ASCII for all text interchange. toCharArray( ) If you want to convert all the characters in a String object into a character array, the easiest way is to call toCharArray( ). It returns an array of characters for the entire string. Its general form is: char[ ] toCharArray( ) This function is provided as a convenience, since it is possible to use getChars( ) to achieve the same result.

Byte Extraction class TestingByteArrayCharArray { public static void main(String[] args) { String a=new String(); a="testing get bytes"; byte charArray[]=new byte[a.length()]; charArray=a.getBytes(); for(byte i: charArray) { System.out.println(i); } } }

class TestingByteArrayCharArray { public static void main(String[] args) { String a=new String(); a="testing get bytes"; byte byteArray[]=new byte[a.length()]; byteArray=a.getBytes(); for(byte i: byteArray) { System.out.println(i); } //System.out.println(a[5]); char charArray[]=new char[a.length()]; charArray=a.toCharArray(); for(int i=0; i 0) { String t = arr[j]; arr[j] = arr[i]; arr[i] = t; } } System.out.println(arr[i]); } } }

compareTo( )
• compareTo( ) takes into account uppercase and lowercase letters. The word “Now” came out before all the others because it begins with an uppercase letter, which means it has a lower value in the ASCII character set. • If we want to ignore case differences when comparing two strings, use compareToIgnoreCase( ), as shown here: int compareToIgnoreCase(String str)

Searching Strings
• The String class provides two methods that allow you to search a string for a specified character or substring: • indexOf( ) Searches for the first occurrence of a character or substring. • lastIndexOf( ) Searches for the last occurrence of a character or substring.

Searching Strings
• To search for the first occurrence of a character, use int indexOf(int ch) • To search for the last occurrence of a character, use int lastIndexOf(int ch) Here, ch is the character being sought. • To search for the first or last occurrence of a substring, use int indexOf(String str) int lastIndexOf(String str) Here, str specifies the substring. • You can specify a starting point for the search using these forms: int indexOf(int ch, int startIndex) int lastIndexOf(int ch, int startIndex) int indexOf(String str, int startIndex) int lastIndexOf(String str, int startIndex)

Searching Strings
// Demonstrate indexOf() and lastIndexOf(). class indexOfDemo { public static void main(String args[]) { String s = "Now is the time for all good men " + "to come to the aid of their country."; System.out.println(s); System.out.println("indexOf(t) = " +s.indexOf('t')); System.out.println("lastIndexOf(t) = " +s.lastIndexOf('t')); System.out.println("indexOf(the) = " +s.indexOf("the")); System.out.println("lastIndexOf(the) = " +s.lastIndexOf("the")); System.out.println("indexOf(t, 10) = " +s.indexOf('t', 10)); System.out.println("lastIndexOf(t, 60) = " +s.lastIndexOf('t', 60)); System.out.println("indexOf(the, 10) = " +s.indexOf("the", 10)); System.out.println("lastIndexOf(the, 60) = " + s.lastIndexOf("the", 60)); } }

Searching Strings indexOf(t) = 7 lastIndexOf(t) = 65 indexOf(the) = 7 lastIndexOf(the) = 55 indexOf(t, 10) = 11 lastIndexOf(t, 60) = 55 indexOf(the, 10) = 44 lastIndexOf(the, 60) = 55

Modifying a String
• Because String objects are immutable, whenever we want to modify a String, you must either copy it into a StringBuffer or StringBuilder, or use one of the following String methods, which will construct a new copy of the string with your modifications complete. • substring( )

• You can extract a substring using substring( ). It has two forms. The first is String substring(int startIndex). Here, startIndex specifies the index at which the substring will begin. This form returns a copy of the substring that begins at startIndex and runs to the end of the invoking string. • The second form of substring( ) allows us to specify both the beginning and ending index of the substring: String substring(int startIndex, int endIndex)
• Here, startIndex specifies the beginning index, and endIndex specifies the stopping point. The string returned contains all the characters from the beginning index, up to, but not including, the ending index.

Modifying a String
// Substring replacement. class StringReplace { public static void main(String args[]) { String org = "This is a test. This is, too."; String search = "is"; String sub = "was"; String result = ""; int i; do { // replace all matching substrings System.out.println(org); i = org.indexOf(search); if(i != -1) { result = org.substring(0, i); result = result + sub; result = result + org.substring(i + search.length()); org = result; } } while(i != -1); } }

concat
We can concatenate two strings using concat( ), shown here: String concat(String str) This method creates a new object that contains the invoking string with the contents of str appended to the end. concat( ) performs the same function as +. For example, String s1 = "one"; String s2 = s1.concat("two"); puts the string “onetwo” into s2. It generates the same result as the following sequence: String s1 = "one"; String s2 = s1 + "two";

replace( )
The replace( ) method has two forms. The first replaces all occurrences of one character in the invoking string with another character. It has the following general form: String replace(char original, char replacement)

Here, original specifies the character to be replaced by the character specified by replacement. The resulting string is returned. For example, String s = "Hello".replace('l', 'w'); puts the string “Hewwo” into s. The second form of replace( ) replaces one character sequence with another. It has this general form: String replace(CharSequence original, CharSequence replacement)

trim( )
The trim( ) method returns a copy of the invoking string from which any leading and trailing whitespace has been removed. It has this general form: String trim( ) Here is an example: String s = " Hello World ".trim(); This puts the string “Hello World” into s. The trim( ) method is quite useful when you process user commands.

Changing the Case of Characters Within a String
String toLowerCase( ) String toUpperCase( ) // Demonstrate toUpperCase() and toLowerCase(). class ChangeCase { public static void main(String args[]) { String s = "This is a test."; System.out.println("Original: " + s); String upper = s.toUpperCase(); String lower = s.toLowerCase(); System.out.println("Uppercase: " + upper); System.out.println("Lowercase: " + lower); } }

StringBuffer
• String represents fixed-length, immutable character sequences. • In contrast, StringBuffer represents growable and writeable character sequences. StringBuffer may have characters and substrings inserted in the middle or appended to the end.
• StringBuffer will automatically grow to make room for such additions and often has more characters pre-allocated than are actually needed, to allow room for growth.

StringBuffer Constructors
• StringBuffer defines these four constructors: StringBuffer( ) StringBuffer(int size) StringBuffer(String str) StringBuffer(CharSequence chars)
The default constructor (the one with no parameters) reserves room for 16 characters without reallocation. The second version accepts an integer argument that explicitly sets the size of the buffer.

•

•

•

The third version accepts a String argument that sets the initial contents of the StringBuffer object and reserves room for 16 more characters without reallocation.
The fourth constructor creates an object that contains the character sequence contained in chars.

•

length( ) and capacity( )
The current length of a StringBuffer can be found via the length( ) method, while the total allocated capacity can be found through the capacity( ) method. They have the following. general forms: int length( ) int capacity( )

// StringBuffer length vs. capacity. class StringBufferDemo { public static void main(String args[]) { StringBuffer sb = new StringBuffer("Hello"); System.out.println("buffer = " + sb); System.out.println("length = " + sb.length()); System.out.println("capacity = " + sb.capacity()); } }

ensureCapacity( )
• If we want to preallocate room for a certain number of characters after a StringBuffer has been constructed, you can use ensureCapacity( ) to set the size of the buffer. This is useful if you know in advance that you will be appending a large number of small strings to a StringBuffer.
• ensureCapacity( ) has this general form: void ensureCapacity(int capacity) Here, capacity specifies the size of the buffer.

setLength( )
• To set the length of the buffer within a StringBuffer object, use setLength( ). Its general form is: void setLength(int len) • len specifies the length of the buffer. This value must be nonnegative. • When we increase the size of the buffer, null characters are added to the end of the existing buffer. • If we call setLength( ) with a value less than the current value returned by length( ), then the characters stored beyond the new length will be lost.

charAt( ) and setCharAt( )
• The value of a single character can be obtained from a StringBuffer via the charAt( ) method. You can set the value of a character within a StringBuffer using setCharAt( ). Their general forms are shown here: char charAt(int where) void setCharAt(int where, char ch)
// Demonstrate charAt() and setCharAt(). class setCharAtDemo { public static void main(String args[]) { StringBuffer sb = new StringBuffer("Hello"); System.out.println("buffer before = " + sb); System.out.println("charAt(1) before = " + sb.charAt(1)); sb.setCharAt(1, 'i'); sb.setLength(2); System.out.println("buffer after = " + sb); System.out.println("charAt(1) after = " + sb.charAt(1)); } }

getChars( )
• To copy a substring of a StringBuffer into an array, use the getChars( ) method. It has this general form: void getChars(int sourceStart, int sourceEnd, char target[ ], int targetStart)

append( )
•

•

The append( ) method concatenates the string representation of any other type of data to the end of the invoking StringBuffer object. It has several overloaded versions. Here are a few of its forms:

StringBuffer append(String str) StringBuffer append(int num) StringBuffer append(Object obj) • String.valueOf( ) is called for each parameter to obtain its string representation. The result is appended to the current StringBuffer object. // Demonstrate append(). class appendDemo { public static void main(String args[]) { String s; int a = 42; StringBuffer sb = new StringBuffer(40); s = sb.append("a = ").append(a).append("!").toString(); System.out.println(s); } }

insert( )
The insert( ) method inserts one string into another. It is overloaded to accept values of all the simple types, plus Strings, Objects, and CharSequences. It calls String.valueOf( ) to obtain the string representation of the value it is called with. This string is then inserted into the invoking StringBuffer object. These are a few of its forms: StringBuffer insert(int index, String str) StringBuffer insert(int index, char ch) StringBuffer insert(int index, Object obj) class insertDemo { public static void main(String args[]) { StringBuffer sb = new StringBuffer("I Java!"); sb.insert(2, "like "); System.out.println(sb); } }

reverse( )
// Using reverse() to reverse a StringBuffer. class ReverseDemo { public static void main(String args[]) { StringBuffer s = new StringBuffer("abcdef"); System.out.println(s); s.reverse(); System.out.println(s); } }

delete( ) and deleteCharAt( )
• StringBuffer delete(int startIndex, int endIndex) • StringBuffer deleteCharAt(int loc) class deleteDemo { public static void main(String args[]) { StringBuffer sb = new StringBuffer("This is a test."); sb.delete(4, 7); System.out.println("After delete: " + sb); sb.deleteCharAt(0); System.out.println("After deleteCharAt: " + sb); } }

replace( )
• We can replace one set of characters with another set inside a StringBuffer object by calling replace( ). Its signature is shown here:
StringBuffer replace(int startIndex, int endIndex, String str) • The substring being replaced is specified by the indexes startIndex and endIndex. Thus, the substring at startIndex through endIndex–1 is replaced. The replacement string is passed in str. • The resulting StringBuffer object is returned. // Demonstrate replace() class replaceDemo { public static void main(String args[]) { StringBuffer sb = new StringBuffer("This is a test."); sb.replace(5, 7, "was"); System.out.println("After replace: " + sb); } }

substring( )
• substring( ) has the following two forms:
String substring(int startIndex) String substring(int startIndex, int endIndex)

indexOf( ) and lastIndexOf( ) class IndexOfDemo { public static void main(String args[]) { StringBuffer sb = new StringBuffer("one two one"); int i; i = sb.indexOf("one"); System.out.println("First index: " + i); i = sb.lastIndexOf("one"); System.out.println("Last index: " + i); } }