{"id":3463,"date":"2019-06-20T11:45:57","date_gmt":"2019-06-20T11:45:57","guid":{"rendered":"http:\/\/softlect.in\/?p=3463"},"modified":"2019-06-20T12:03:35","modified_gmt":"2019-06-20T12:03:35","slug":"java-string-handling","status":"publish","type":"post","link":"http:\/\/softlect.com\/index.php\/java-string-handling\/","title":{"rendered":"Java String Handling"},"content":{"rendered":"

String Handling<\/h1>\n

 <\/p>\n

In Java a string <\/em>is a sequence of characters. Java implements strings as objects of type String<\/strong>. For example, Java has methods to compare two strings, search for a substring, concatenate two strings, and change the case of letters within a string. Also, String <\/strong>objects can be constructed a number of ways. Somewhat unexpectedly, when you create a String <\/strong>object, you are creating a string that cannot be changed. That is, once a String <\/strong>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 you need an altered version of an existing string; a new String <\/strong>object is created that contains the modifications. For those cases in which a modifiable string is desired, there is a companion class to String <\/strong>called StringBuffer<\/strong>, whose objects contain strings that can be modified after they are created. Both the String <\/strong>and StringBuffer <\/strong>classes are defined in java.lang<\/strong>.<\/p>\n

 <\/p>\n

The String Constructors<\/h2>\n

The String <\/strong>class supports several constructors. To create an empty String<\/strong>, you call the default constructor. For example,<\/p>\n

String s = new String();<\/p>\n

 <\/p>\n

Will create an instance of String <\/strong>with no characters in it. Frequently, you will want to create strings that have initial values. To create a String <\/strong>initialized by an array of characters, use the constructor shown here:<\/p>\n

 <\/p>\n

String(char chars<\/em>[ ])<\/p>\n

 <\/p>\n

Here is an example:<\/p>\n

 <\/p>\n

char chars[] = { ‘a’, ‘b’, ‘c’ };<\/p>\n

String s = new String(chars);<\/p>\n

 <\/p>\n

This constructor initializes s <\/strong>with the string \u201cabc\u201d. You can specify a subrange of a character array as an initializer using the following constructor:<\/p>\n

 <\/p>\n

String(char chars<\/em>[ ], int startIndex<\/em>, int numChars<\/em>)<\/p>\n

 <\/p>\n

Here, startIndex <\/em>specifies the index at which the sub range begins, and numChars <\/em>specifies the number of characters to use. Here is an example:<\/p>\n

 <\/p>\n

char chars[] = { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’ };<\/p>\n

String s = new String(chars, 2, 3);<\/p>\n

 <\/p>\n

This initializes s <\/strong>with the characters cde<\/strong>. You can construct a String <\/strong>object that contains the same character sequence as another String <\/strong>object using this constructor:<\/p>\n

 <\/p>\n

String(String strObj<\/em>)<\/p>\n

 <\/p>\n

Here, strObj <\/em>is a String <\/strong>object. Consider this example:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Construct one String from another.<\/p>\n

class MakeString {<\/p>\n

public static void main(String args[]) {<\/p>\n

char c[] = {‘J’, ‘a’, ‘v’, ‘a’};<\/p>\n

String s1 = new String(c);<\/p>\n

String s2 = new String(s1);<\/p>\n

System.out.println(s1);<\/p>\n

System.out.println(s2);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output from this program is as follows:<\/p>\n

Java<\/p>\n

Java<\/p>\n

 <\/p>\n

As you can see, s1 <\/strong>and s2 <\/strong>contain the same string. The String <\/strong>class provides constructors that initialize a string when given a byte <\/strong>array. Their forms are shown here:<\/p>\n

 <\/p>\n

String(byte asciiChars<\/em>[ ])<\/p>\n

String(byte asciiChars<\/em>[ ], int startIndex<\/em>, int numChars<\/em>)<\/p>\n

 <\/p>\n

Here, asciiChars <\/em>specifies the array of bytes. The second form allows you 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:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Construct string from subset of char array.<\/p>\n

class SubStringCons {<\/p>\n

public static void main(String args[]) {<\/p>\n

byte ascii[] = {65, 66, 67, 68, 69, 70 };<\/p>\n

String s1 = new String(ascii);<\/p>\n

System.out.println(s1);<\/p>\n

String s2 = new String(ascii, 2, 3);<\/p>\n

System.out.println(s2);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

This program generates the following output:<\/p>\n

ABCDEF<\/p>\n

CDE<\/p>\n

 <\/p>\n

Extended versions of the byte-to-string constructors are also defined in which you can specify the character encoding that determines how bytes are converted to characters. However, most of the time, you will want to use the default encoding provided by the platform.<\/p>\n

 <\/p>\n

String Length<\/h3>\n

The length of a string is the number of characters that it contains. To obtain this value, call the length( ) <\/strong>method, shown here:<\/p>\n

 <\/p>\n

int length( )<\/p>\n

 <\/p>\n

The following fragment prints \u201c3\u201d, since there are three characters in the string s<\/strong>:<\/p>\n

char chars[] = { ‘a’, ‘b’, ‘c’ };<\/p>\n

String s = new String(chars);<\/p>\n

System.out.println(s.length());<\/p>\n

 <\/p>\n

Special String Operations<\/h2>\n

 <\/p>\n

Java has added special support for several string operations within the syntax of the language. These operations include the automatic creation of new String <\/strong>instances from string literals, concatenation of multiple String <\/strong>objects by use of the + <\/strong>operator, and the conversion of other data types to a string representation. There are explicit methods available to perform all of these functions.<\/p>\n

 <\/p>\n

String Literals<\/h3>\n

The earlier examples showed how to explicitly create a String <\/strong>instance from an array of characters by using the new <\/strong>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 <\/strong>object. Thus, you can use a string literal to initialize a String <\/strong>object. For example, the following code fragment creates two equivalent strings:<\/p>\n

 <\/p>\n

char chars[] = { ‘a’, ‘b’, ‘c’ };<\/p>\n

String s1 = new String(chars);<\/p>\n

String s2 = “abc”; \/\/ use string literal<\/p>\n

 <\/p>\n

Because a String <\/strong>object is created for every string literal, you can use a string literal any place you can use a String <\/strong>object. For example, you can call methods directly on a quoted string as if it were an object reference, as the following statement shows. It calls the length( ) <\/strong>method on the string \u201cabc\u201d. As expected, it prints \u201c3\u201d<\/p>\n

 <\/p>\n

System.out.println(“abc”.length());<\/p>\n

 <\/p>\n

String Concatenation<\/h3>\n

In general, Java does not allow operators to be applied to String <\/strong>objects. The one exception to this rule is the + <\/strong>operator, which concatenates two strings, producing a String <\/strong>object as the result. This allows you to chain together a series of + <\/strong>operations. For example, the following fragment concatenates three strings:<\/p>\n

 <\/p>\n

String age = “9”;<\/p>\n

String s = “He is ” + age + ” years old.”;<\/p>\n

System.out.println(s);<\/p>\n

 <\/p>\n

This displays the string \u201cHe is 9 years old.\u201d Here is another an example:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Using concatenation to prevent long lines.<\/p>\n

class ConCat {<\/p>\n

public static void main(String args[]) {<\/p>\n

String longStr = “This could have been ” +<\/p>\n

“a very long line that would have ” +<\/p>\n

“wrapped around. But string concatenation ” +<\/p>\n

“prevents this.”;<\/p>\n

System.out.println(longStr);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

String Concatenation with Other Data Types<\/h3>\n

You can concatenate strings with other types of data. For example, consider this slightly different version of the earlier example:<\/p>\n

 <\/p>\n

int age = 9;<\/p>\n

String s = “He is ” + age + ” years old.”;<\/p>\n

System.out.println(s);<\/p>\n

 <\/p>\n

In this case, age <\/strong>is an int <\/strong>rather than another String<\/strong>, but the output produced is the same as before. This is because the int <\/strong>value in age <\/strong>is automatically converted into its string representation within a String <\/strong>object. This string is then concatenated as before. The compiler will convert an operand to its string equivalent whenever the other operand of the + <\/strong>is an instance of String<\/strong>. Be careful when you mix other types of operations with string concatenation expressions, however. You might get surprising results. Consider the following:<\/p>\n

 <\/p>\n

String s = “four: ” + 2 + 2;<\/p>\n

System.out.println(s);<\/p>\n

 <\/p>\n

This fragment displays four: 22<\/p>\n

rather than the four: 4<\/p>\n

 <\/p>\n

Operator precedence causes the concatenation of \u201cfour\u201d with the string equivalent of 2 to take place first. This result is then concatenated with the string equivalent of 2 a second time. To complete the integer addition first, you must use parentheses, like this:<\/p>\n

 <\/p>\n

String s = “four: ” + (2 + 2);<\/p>\n

 <\/p>\n

Now s <\/strong>contains the string \u201cfour: 4\u201d.<\/p>\n

 <\/p>\n

String Conversion and toString( )<\/h3>\n

When Java converts data into its string representation during concatenation, it does so by calling one of the overloaded versions of the string conversion method valueOf( ) <\/strong>defined by String<\/strong>. valueOf( ) <\/strong>is overloaded for all the simple types and for type Object<\/strong>. For the simple types, valueOf( ) <\/strong>returns a string that contains the human-readable equivalent of the value with which it is called. For objects, valueOf( ) <\/strong>calls the toString( ) <\/strong>method on the object. Here, let\u2019s examine the toString( ) <\/strong>method, because it is the means by which you can determine the string representation for objects of classes that you create. Every class implements toString( ) <\/strong>because it is defined by Object<\/strong>. Fortunately, this is easy to do. The toString( ) <\/strong>method has this general form:<\/p>\n

 <\/p>\n

String toString( )<\/p>\n

 <\/p>\n

To implement toString( )<\/strong>, simply return a String <\/strong>object that contains the humanreadable string that appropriately describes an object of your class. By overriding toString( ) <\/strong>for classes that you create, you allow them to be fully integrated into Java\u2019s programming environment. For example, they can be used in print( ) <\/strong>and println( ) <\/strong>statements and in concatenation expressions. The following program demonstrates this by overriding toString( ) <\/strong>for the Box <\/strong>class:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Override toString() for Box class.<\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

Box(double w, double h, double d) {<\/p>\n

width = w;<\/p>\n

height = h;<\/p>\n

depth = d;<\/p>\n

}<\/p>\n

public String toString() {<\/p>\n

return “Dimensions are ” + width + ” by ” +<\/p>\n

depth + ” by ” + height + “.”;<\/p>\n

}<\/p>\n

}<\/p>\n

class toStringDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

Box b = new Box(10, 12, 14);<\/p>\n

String s = “Box b: ” + b; \/\/ concatenate Box object<\/p>\n

System.out.println(b); \/\/ convert Box to string<\/p>\n

System.out.println(s);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output of this program is shown here:<\/p>\n

Dimensions are 10.0 by 14.0 by 12.0<\/p>\n

Box b: Dimensions are 10.0 by 14.0 by 12.0<\/p>\n

 <\/p>\n

As you can see, Box<\/strong>\u2019s toString( ) <\/strong>method is automatically invoked when a Box <\/strong>object is used in a concatenation expression or in a call to println( )<\/strong>.<\/p>\n

 <\/p>\n

Character Extraction<\/h2>\n

The String <\/strong>class provides a number of ways in which characters can be extracted from a String <\/strong>object. Each is examined here. Although the characters that comprise a string within a String <\/strong>object cannot be indexed as if they were a character array, many of the String <\/strong>methods employ an index (or offset) into the string for their operation. Like arrays, the string indexes begin at zero.<\/p>\n

 <\/p>\n

charAt( )<\/h3>\n

To extract a single character from a String<\/strong>, you can refer directly to an individual character via the charAt() <\/strong>method. It has this general form:<\/p>\n

 <\/p>\n

char charAt(int where<\/em>)<\/p>\n

 <\/p>\n

Here, where <\/em>is the index of the character that you want to obtain. The value of where <\/em>must be nonnegative and specify a location within the string. charAt( ) <\/strong>returns the character at the specified location. For example,<\/p>\n

 <\/p>\n

char ch;<\/p>\n

ch = “abc”.charAt(1);<\/p>\n

 <\/p>\n

assigns the value \u201cb<\/strong>\u201d to ch<\/strong>.<\/p>\n

 <\/p>\n

getChars( )<\/h3>\n

If you need to extract more than one character at a time, you can use the getChars( ) <\/strong>method. It has this general form:<\/p>\n

 <\/p>\n

void getChars(int sourceStart<\/em>, int sourceEnd<\/em>, char target<\/em>[ ], int targetStart<\/em>)<\/p>\n

 <\/p>\n

Here, sourceStart <\/em>specifies the index of the beginning of the substring, and sourceEnd <\/em>specifies an index that is one past the end of the desired substring. Thus, the substring contains the characters from sourceStart <\/em>through sourceEnd<\/em>\u20131. The array that will receive the characters is specified by target. <\/em>The index within target <\/em>at which the substring will be copied is passed in targetStart. <\/em>Care must be taken to assure that the target <\/em>array is large enough to hold the number of characters in the specified substring. The following program demonstrates getChars( )<\/strong>:<\/p>\n

 <\/p>\n\n\n\n
class getCharsDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

String s = “This is a demo of the getChars method.”;<\/p>\n

int start = 10;<\/p>\n

int end = 14;<\/p>\n

char buf[] = new char[end – start];<\/p>\n

s.getChars(start, end, buf, 0);<\/p>\n

System.out.println(buf);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Here is the output of this program:<\/p>\n

demo<\/p>\n

 <\/p>\n

getBytes( )<\/h3>\n

There is an alternative to getChars( ) <\/strong>that stores the characters in an array of bytes. This method is called getBytes( )<\/strong>, and it uses the default character-to-byte conversions provided by the platform. Here is its simplest form:<\/p>\n

 <\/p>\n

byte[ ] getBytes( )<\/p>\n

 <\/p>\n

Other forms of getBytes( ) <\/strong>are also available. getBytes( ) <\/strong>is most useful when you are exporting a String <\/strong>value into an environment that does not support 16-bit Unicode characters.<\/p>\n

 <\/p>\n

toCharArray( )<\/h3>\n

If you want to convert all the characters in a String <\/strong>object into a character array, the easiest way is to call toCharArray( )<\/strong>. It returns an array of characters for the entire string. It has this general form:<\/p>\n

 <\/p>\n

char[ ] toCharArray( )<\/p>\n

 <\/p>\n

This function is provided as a convenience, since it is possible to use getChars( ) <\/strong>to achieve the same result.<\/p>\n

 <\/p>\n

String Comparison<\/h2>\n

The String <\/strong>class includes several methods that compare strings or substrings within strings. Each is examined here.<\/p>\n

 <\/p>\n

equals( ) and equalsIgnoreCase( )<\/h3>\n

To compare two strings for equality, use equals( )<\/strong>. It has this general form:<\/p>\n

 <\/p>\n

boolean equals(Object str<\/em>)<\/p>\n

 <\/p>\n

Here, str <\/em>is the String <\/strong>object being compared with the invoking String <\/strong>object. It returns true <\/strong>if the strings contain the same characters in the same order, and false <\/strong>otherwise. The comparison is case-sensitive. To perform a comparison that ignores case differences, call equalsIgnoreCase( )<\/strong>. When it compares two strings, it considers A-Z <\/strong>to be the same as a-z<\/strong>. It has this general form:<\/p>\n

 <\/p>\n

boolean equalsIgnoreCase(String str<\/em>)<\/p>\n

 <\/p>\n

Here, str <\/em>is the String <\/strong>object being compared with the invoking String <\/strong>object. It, too, returns true <\/strong>if the strings contain the same characters in the same order, and false <\/strong>otherwise. Here is an example that demonstrates equals( ) <\/strong>and equalsIgnoreCase( )<\/strong>:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate equals() and equalsIgnoreCase().<\/p>\n

class equalsDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

String s1 = “Hello”;<\/p>\n

String s2 = “Hello”;<\/p>\n

String s3 = “Good-bye”;<\/p>\n

String s4 = “HELLO”;<\/p>\n

System.out.println(s1 + ” equals ” + s2 + ” -> ” +<\/p>\n

s1.equals(s2));<\/p>\n

System.out.println(s1 + ” equals ” + s3 + ” -> ” +<\/p>\n

s1.equals(s3));<\/p>\n

System.out.println(s1 + ” equals ” + s4 + ” -> ” +<\/p>\n

s1.equals(s4));<\/p>\n

System.out.println(s1 + ” equalsIgnoreCase ” + s4 + ” -> ” +<\/p>\n

s1.equalsIgnoreCase(s4));<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output from the program is shown here:<\/p>\n

Hello equals Hello -> true<\/p>\n

Hello equals Good-bye -> false<\/p>\n

Hello equals HELLO -> false<\/p>\n

Hello equalsIgnoreCase HELLO -> true<\/p>\n

 <\/p>\n

regionMatches( )<\/h3>\n

The regionMatches( ) <\/strong>method compares a specific region inside a string with another specific region in another string. There is an overloaded form that allows you to ignore case in such comparisons. Here are the general forms for these two methods:<\/p>\n

 <\/p>\n

boolean regionMatches(int startIndex<\/em>, String str2<\/em>,<\/p>\n

int str2StartIndex<\/em>, int numChars<\/em>)<\/p>\n

boolean regionMatches(boolean ignoreCase<\/em>,<\/p>\n

int startIndex<\/em>, String str2<\/em>,<\/p>\n

int str2StartIndex<\/em>, int numChars<\/em>)<\/p>\n

 <\/p>\n

For both versions, startIndex <\/em>specifies the index at which the region begins within the invoking String <\/strong>object. The String <\/strong>being compared is specified by str2<\/em>. The index at which the comparison will start within str2 <\/em>is specified by str2StartIndex<\/em>. The length of the substring being compared is passed in numChars<\/em>. In the second version, if ignoreCase <\/em>is true<\/strong>, the case of the characters is ignored. Otherwise, case is significant.<\/p>\n

 <\/p>\n

startsWith( ) and endsWith( )<\/h3>\n

String <\/strong>defines two routines that are, more or less, specialized forms of regionMatches( )<\/strong>. The startsWith( ) <\/strong>method determines whether a given String <\/strong>begins with a specified string. Conversely, endsWith( ) <\/strong>determines whether the String <\/strong>in question ends with a specified string. They have the following general forms:<\/p>\n

 <\/p>\n

boolean startsWith(String str<\/em>)<\/p>\n

boolean endsWith(String str<\/em>)<\/p>\n

 <\/p>\n

Here, str <\/em>is the String <\/strong>being tested. If the string matches, true <\/strong>is returned. Otherwise, false <\/strong>is returned. For example,<\/p>\n

 <\/p>\n

“Foobar”.endsWith(“bar”)<\/p>\n

and<\/p>\n

“Foobar”.startsWith(“Foo”)<\/p>\n

are both true<\/strong>.<\/p>\n

 <\/p>\n

A second form of startsWith( )<\/strong>, shown here, lets you specify a starting point:<\/p>\n

 <\/p>\n

boolean startsWith(String str<\/em>, int startIndex<\/em>)<\/p>\n

 <\/p>\n

Here, startIndex <\/em>specifies the index into the invoking string at which point the search will begin. For example,<\/p>\n

“Foobar”.startsWith(“bar”, 3)<\/p>\n

 <\/p>\n

returns true<\/strong>.<\/p>\n

 <\/p>\n

equals( ) Versus ==<\/h3>\n

It is important to understand that the equals( ) <\/strong>method and the == <\/strong>operator perform two different operations. As just explained, the equals( ) <\/strong>method compares the characters inside a String <\/strong>object. The == <\/strong>operator compares two object references to see whether they refer to the same instance. The following program shows how two different String <\/strong>objects can contain the same characters, but references to these objects will not compare as equal:<\/p>\n

 <\/p>\n\n\n\n
\/\/ equals() vs ==<\/p>\n

class EqualsNotEqualTo {<\/p>\n

public static void main(String args[]) {<\/p>\n

String s1 = “Hello”;<\/p>\n

String s2 = new String(s1);<\/p>\n

System.out.println(s1 + ” equals ” + s2 + ” -> ” +<\/p>\n

s1.equals(s2));<\/p>\n

System.out.println(s1 + ” == ” + s2 + ” -> ” + (s1 == s2));<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The variable s1 <\/strong>refers to the String <\/strong>instance created by \u201cHello<\/strong>\u201d. The object referred to by s2 <\/strong>is created with s1 <\/strong>as an initializer. Thus, the contents of the two String <\/strong>objects are identical, but they are distinct objects. This means that s1 <\/strong>and s2 <\/strong>do not refer to the same objects and are, therefore, not ==<\/strong>, as is shown here by the output of the preceding example:<\/p>\n

 <\/p>\n

Hello equals Hello -> true<\/p>\n

Hello == Hello -> false<\/p>\n

 <\/p>\n

compareTo( )<\/h3>\n

Often, it is not enough to simply know whether two strings are identical. For sorting applications, you need to know which is less than, equal to, <\/em>or greater than <\/em>the next. A string is less than another if it comes before the other in dictionary order. A string is greater than another if it comes after the other in dictionary order. The String <\/strong>method compareTo( ) <\/strong>serves this purpose. It has this general form:<\/p>\n

 <\/p>\n

int compareTo(String str<\/em>)<\/p>\n

 <\/p>\n

Here, str <\/em>is the String <\/strong>being compared with the invoking String<\/strong>. The result of the comparison is returned and is interpreted as shown here:<\/p>\n

 <\/p>\n

Value Meaning<\/p>\n

Less than zero \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0The invoking string is less than str.<\/em><\/p>\n

Greater than zero \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0The invoking string is greater than str.<\/em><\/p>\n

Zero \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0The two strings are equal.<\/p>\n

 <\/p>\n

Here is a sample program that sorts an array of strings. The program uses compareTo( ) <\/strong>to determine sort ordering for a bubble sort:<\/p>\n

 <\/p>\n\n\n\n
\/\/ A bubble sort for Strings.<\/p>\n

class SortString {<\/p>\n

static String arr[] = {<\/p>\n

“Now”, “is”, “the”, “time”, “for”, “all”, “good”, “men”,<\/p>\n

“to”, “come”, “to”, “the”, “aid”, “of”, “their”, “country”<\/p>\n

};<\/p>\n

public static void main(String args[]) {<\/p>\n

for(int j = 0; j < arr.length; j++) {<\/p>\n

for(int i = j + 1; i < arr.length; i++) {<\/p>\n

if(arr[i].compareTo(arr[j]) < 0) {<\/p>\n

String t = arr[j];<\/p>\n

arr[j] = arr[i];<\/p>\n

arr[i] = t;<\/p>\n

}<\/p>\n

}<\/p>\n

System.out.println(arr[j]);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output of this program is the list of words:<\/p>\n\n\n\n
Now<\/p>\n

aid<\/p>\n

all<\/p>\n

come<\/p>\n

country<\/p>\n

for<\/p>\n

good<\/p>\n

is<\/p>\n

men<\/p>\n

of<\/p>\n

the<\/p>\n

the<\/p>\n

their<\/p>\n

time<\/p>\n

to<\/p>\n

to<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

As you can see from the output of this example, compareTo( ) <\/strong>takes into account uppercase and lowercase letters. The word \u201cNow\u201d 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 you want to ignore case differences when comparing two strings, use compareToIgnoreCase( )<\/strong>, shown here:<\/p>\n

 <\/p>\n

int compareToIgnoreCase(String str<\/em>)<\/p>\n

 <\/p>\n

This method returns the same results as compareTo( )<\/strong>, except that case differences are ignored. This method was added by Java 2. You might want to try substituting it into the previous program. After doing so, \u201cNow\u201d will no longer be first.<\/p>\n

 <\/p>\n

Searching Strings<\/h2>\n

 <\/p>\n

The String <\/strong>class provides two methods that allow you to search a string for a specified character or substring:<\/p>\n

 <\/p>\n

indexOf( ) <\/strong>Searches for the first occurrence of a character or substring.<\/p>\n

lastIndexOf( ) <\/strong>Searches for the last occurrence of a character or substring.<\/p>\n

 <\/p>\n

These two methods are overloaded in several different ways. In all cases, the methods return the index at which the character or substring was found, or \u20131 on failure. To search for the first occurrence of a character, use<\/p>\n

 <\/p>\n

int indexOf(int ch<\/em>)<\/p>\n

 <\/p>\n

To search for the last occurrence of a character, use<\/p>\n

int lastIndexOf(int ch<\/em>)<\/p>\n

 <\/p>\n

Here, ch <\/em>is the character being sought. To search for the first or last occurrence of a substring, use<\/p>\n

 <\/p>\n

int indexOf(String str<\/em>)<\/p>\n

int lastIndexOf(String str<\/em>)<\/p>\n

 <\/p>\n

Here, str <\/em>specifies the substring. You can specify a starting point for the search using these forms:<\/p>\n

 <\/p>\n

int indexOf(int ch<\/em>, int startIndex<\/em>)<\/p>\n

int lastIndexOf(int ch<\/em>, int startIndex<\/em>)<\/p>\n

int indexOf(String str<\/em>, int startIndex<\/em>)<\/p>\n

int lastIndexOf(String str<\/em>, int startIndex<\/em>)<\/p>\n

 <\/p>\n

Here, startIndex <\/em>specifies the index at which point the search begins. For indexOf( )<\/strong>, the search runs from startIndex <\/em>to the end of the string. For lastIndexOf( )<\/strong>, the search runs from startIndex <\/em>to zero. The following example shows how to use the various index methods to search inside of String<\/strong>s:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate indexOf() and lastIndexOf().<\/p>\n

class indexOfDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

String s = “Now is the time for all good men ” +<\/p>\n

“to come to the aid of their country.”;<\/p>\n

System.out.println(s);<\/p>\n

System.out.println(“indexOf(t) = ” +<\/p>\n

s.indexOf(‘t’));<\/p>\n

System.out.println(“lastIndexOf(t) = ” +<\/p>\n

s.lastIndexOf(‘t’));<\/p>\n

System.out.println(“indexOf(the) = ” +<\/p>\n

s.indexOf(“the”));<\/p>\n

System.out.println(“lastIndexOf(the) = ” +<\/p>\n

s.lastIndexOf(“the”));<\/p>\n

System.out.println(“indexOf(t, 10) = ” +<\/p>\n

s.indexOf(‘t’, 10));<\/p>\n

System.out.println(“lastIndexOf(t, 60) = ” +<\/p>\n

s.lastIndexOf(‘t’, 60));<\/p>\n

System.out.println(“indexOf(the, 10) = ” +<\/p>\n

s.indexOf(“the”, 10));<\/p>\n

System.out.println(“lastIndexOf(the, 60) = ” +<\/p>\n

s.lastIndexOf(“the”, 60));<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Here is the output of this program:<\/p>\n

Now is the time for all good men to come to the aid of their country.<\/p>\n

indexOf(t) = 7<\/p>\n

lastIndexOf(t) = 65<\/p>\n

indexOf(the) = 7<\/p>\n

lastIndexOf(the) = 55<\/p>\n

indexOf(t, 10) = 11<\/p>\n

lastIndexOf(t, 60) = 55<\/p>\n

indexOf(the, 10) = 44<\/p>\n

lastIndexOf(the, 60) = 55<\/p>\n

 <\/p>\n

Modifying a String<\/h2>\n

Because String <\/strong>objects are immutable, whenever you want to modify a String<\/strong>, you must either copy it into a StringBuffer <\/strong>or use one of the following String <\/strong>methods, which will construct a new copy of the string with your modifications complete.<\/p>\n

 <\/p>\n

substring( )<\/h3>\n

You can extract a substring using substring( )<\/strong>. It has two forms. The first is String substring(int startIndex<\/em>) Here, startIndex <\/em>specifies the index at which the substring will begin. This form returns a copy of the substring that begins at startIndex <\/em>and runs to the end of the invoking string. The second form of substring( ) <\/strong>allows you to specify both the beginning and ending index of the substring:<\/p>\n

 <\/p>\n

String substring(int startIndex<\/em>, int endIndex<\/em>)<\/p>\n

 <\/p>\n

Here, startIndex <\/em>specifies the beginning index, and endIndex <\/em>specifies the stopping point. The string returned contains all the characters from the beginning index, up to, but not including, the ending index. The following program uses substring( ) <\/strong>to replace all instances of one substring with another within a string:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Substring replacement.<\/p>\n

class StringReplace {<\/p>\n

public static void main(String args[]) {<\/p>\n

String org = “This is a test. This is, too.”;<\/p>\n

String search = “is”;<\/p>\n

String sub = “was”;<\/p>\n

String result = “”;<\/p>\n

int i;<\/p>\n

do { \/\/ replace all matching substrings<\/p>\n

System.out.println(org);<\/p>\n

i = org.indexOf(search);<\/p>\n

if(i != -1) {<\/p>\n

result = org.substring(0, i);<\/p>\n

result = result + sub;<\/p>\n

result = result + org.substring(i + search.length());<\/p>\n

org = result;<\/p>\n

}<\/p>\n

} while(i != -1);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output from this program is shown here:<\/p>\n

This is a test. This is, too.<\/p>\n

Thwas is a test. This is, too.<\/p>\n

Thwas was a test. This is, too.<\/p>\n

Thwas was a test. Thwas is, too.<\/p>\n

Thwas was a test. Thwas was, too.<\/p>\n

 <\/p>\n

concat( )<\/h3>\n

You can concatenate two strings using concat( )<\/strong>, shown here:<\/p>\n

 <\/p>\n

String concat(String str<\/em>)<\/p>\n

 <\/p>\n

This method creates a new object that contains the invoking string with the contents of str <\/em>appended to the end. concat( ) <\/strong>performs the same function as +<\/strong>. For example,<\/p>\n

 <\/p>\n

String s1 = “one”;<\/p>\n

String s2 = s1.concat(“two”);<\/p>\n

puts the string \u201conetwo\u201d into s2<\/strong>. It generates the same result as the following sequence:<\/p>\n

String s1 = “one”;<\/p>\n

String s2 = s1 + “two”;<\/p>\n

 <\/p>\n

replace( )<\/h3>\n

The replace( ) <\/strong>method replaces all occurrences of one character in the invoking string with another character. It has the following general form:<\/p>\n

 <\/p>\n

String replace(char original<\/em>, char replacement<\/em>)<\/p>\n

 <\/p>\n

Here, original <\/em>specifies the character to be replaced by the character specified by replacement. <\/em>The resulting string is returned. For example,<\/p>\n

 <\/p>\n

String s = “Hello”.replace(‘l’, ‘w’);<\/p>\n

puts the string \u201cHewwo\u201d into s<\/strong>.<\/p>\n

 <\/p>\n

trim( )<\/h3>\n

The trim( ) <\/strong>method returns a copy of the invoking string from which any leading and trailing whitespace has been removed. It has this general form:<\/p>\n

 <\/p>\n

String trim( )<\/p>\n

 <\/p>\n

Here is an example:<\/p>\n

String s = ” Hello World “.trim();<\/p>\n

 <\/p>\n

This puts the string \u201cHello World\u201d into s<\/strong>. The trim( ) <\/strong>method is quite useful when you process user commands. For example, the following program prompts the user for the name of a state and then displays that state\u2019s capital. It uses trim( ) <\/strong>to remove any leading or trailing whitespace that may have inadvertently been entered by the user.<\/p>\n

 <\/p>\n\n\n\n
\/\/ Using trim() to process commands.<\/p>\n

import java.io.*;<\/p>\n

class UseTrim {<\/p>\n

public static void main(String args[])<\/p>\n

throws IOException<\/p>\n

{<\/p>\n

\/\/ create a BufferedReader using System.in<\/p>\n

BufferedReader br = new<\/p>\n

BufferedReader(new InputStreamReader(System.in));<\/p>\n

String str;<\/p>\n

System.out.println(“Enter ‘stop’ to quit.”);<\/p>\n

System.out.println(“Enter State: “);<\/p>\n

do {<\/p>\n

str = br.readLine();<\/p>\n

str = str.trim(); \/\/ remove whitespace<\/p>\n

if(str.equals(“Illinois”))<\/p>\n

System.out.println(“Capital is Springfield.”);<\/p>\n

else if(str.equals(“Missouri”))<\/p>\n

System.out.println(“Capital is Jefferson City.”);<\/p>\n

else if(str.equals(“California”))<\/p>\n

System.out.println(“Capital is Sacramento.”);<\/p>\n

else if(str.equals(“Washington”))<\/p>\n

System.out.println(“Capital is Olympia.”);<\/p>\n

\/\/ …<\/p>\n

} while(!str.equals(“stop”));<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Data Conversion Using valueOf( )<\/h2>\n

The valueOf( ) <\/strong>method converts data from its internal format into a human-readable form. It is a static method that is overloaded within String <\/strong>for all of Java\u2019s built-in types, so that each type can be converted properly into a string. valueOf( ) <\/strong>is also overloaded for type Object<\/strong>, so an object of any class type you create can also be used as an argument. (Recall that Object <\/strong>is a superclass for all classes.) Here are a few of its forms:<\/p>\n

 <\/p>\n

static String valueOf(double num<\/em>)<\/p>\n

static String valueOf(long num<\/em>)<\/p>\n

static String valueOf(Object ob<\/em>)<\/p>\n

static String valueOf(char chars<\/em>[ ])<\/p>\n

 <\/p>\n

As we discussed earlier, valueOf( ) <\/strong>is called when a string representation of some other type of data is needed for example, during concatenation operations. You can call this method directly with any data type and get a reasonable String <\/strong>representation. All of the simple types are converted to their common String <\/strong>representation. Any object that you pass to valueOf( ) <\/strong>will return the result of a call to the object\u2019s toString( ) <\/strong>method. In fact, you could just call toString( ) <\/strong>directly and get the same result. For most arrays, valueOf( ) <\/strong>returns a rather cryptic string, which indicates that it is an array of some type. For arrays of char<\/strong>, however, a String <\/strong>object is created that contains the characters in the char <\/strong>array. There is a special version of valueOf( ) <\/strong>that allows you to specify a subset of a char <\/strong>array. It has this general form:<\/p>\n

 <\/p>\n

static String valueOf(char chars<\/em>[ ], int startIndex<\/em>, int numChars<\/em>)<\/p>\n

 <\/p>\n

Here, chars <\/em>is the array that holds the characters, startIndex <\/em>is the index into the array of characters at which the desired substring begins, and numChars <\/em>specifies the length of the substring.<\/p>\n

 <\/p>\n

Changing the Case of Characters Within a String<\/h2>\n

The method toLowerCase( ) <\/strong>converts all the characters in a string from uppercase to lowercase. The toUpperCase( ) <\/strong>method converts all the characters in a string from lowercase to uppercase. \u00a0Nonalphabetical characters, such as digits, are unaffected. \u00a0Here are the general forms of these methods:<\/p>\n

 <\/p>\n

String toLowerCase( )<\/p>\n

String toUpperCase( )<\/p>\n

 <\/p>\n

Both methods return a String <\/strong>object that contains the uppercase or lowercase equivalent of the invoking String<\/strong>. Here is an example that uses toLowerCase( ) <\/strong>and toUpperCase( )<\/strong>:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate toUpperCase() and toLowerCase().<\/p>\n

class ChangeCase {<\/p>\n

public static void main(String args[])<\/p>\n

{<\/p>\n

String s = “This is a test.”;<\/p>\n

System.out.println(“Original: ” + s);<\/p>\n

String upper = s.toUpperCase();<\/p>\n

String lower = s.toLowerCase();<\/p>\n

System.out.println(“Uppercase: ” + upper);<\/p>\n

System.out.println(“Lowercase: ” + lower);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output produced by the program is shown here:<\/p>\n

Original: This is a test.<\/p>\n

Uppercase: THIS IS A TEST.<\/p>\n

Lowercase: this is a test.<\/p>\n

 <\/p>\n

String Methods Added by Java 2, Version 1.4<\/h2>\n

Java 2, version 1.4 adds several methods to the String <\/strong>class. These are summarized in the following table.<\/p>\n

 <\/p>\n\n\n\n\n\n\n\n\n\n\n
Method<\/td>\nDescription<\/td>\n<\/tr>\n
boolean contentEquals(StringBuffer str<\/em>)<\/p>\n

 <\/td>\n

Returns true <\/strong>if the invoking string contains the same string as str<\/em>. Otherwise, returns false<\/strong>.<\/td>\n<\/tr>\n
CharSequence subSequence(int startIndex<\/em>,<\/p>\n

int stopIndex<\/em>)<\/p>\n

 <\/td>\n

Returns a substring of the invoking string, beginning at startIndex <\/em>and stopping at stopIndex<\/em>. This method is required by the CharSequence <\/strong>interface, which is now implemented by String<\/strong>.<\/p>\n

 <\/td>\n<\/tr>\n

boolean matches(string regExp<\/em>)<\/p>\n

 <\/td>\n

Returns true <\/strong>if the invoking string matches the regular expression passed in regExp<\/em>. Otherwise, returns false<\/strong>.<\/td>\n<\/tr>\n
String replaceFirst(String regExp<\/em>,<\/p>\n

String newStr<\/em>)<\/p>\n

 <\/td>\n

Returns a string in which the first substring that matches the regular expression specified by regExp <\/em>is replaced by newStr<\/em>.<\/p>\n

String<\/p>\n

 <\/td>\n<\/tr>\n

replaceAll(String regExp<\/em>, String newStr<\/em>)<\/p>\n

 <\/td>\n

Returns a string in which all substrings that match the regular expression specified by regExp <\/em>are replaced by newStr<\/em>.<\/p>\n

 <\/td>\n<\/tr>\n

String[ ] split(String regExp<\/em>)<\/p>\n

 <\/td>\n

Decomposes the invoking string into parts and returns an array that contains the result. Each part is delimited by the regular expression passed in regExp<\/em>.<\/td>\n<\/tr>\n
String[ ] split(String regExp<\/em>, int max<\/em>)<\/p>\n

 <\/td>\n

Decomposes the invoking string into parts and returns an array that contains the result. Each part is delimited by the regular expression passed in regExp<\/em>. The number of pieces is specified by max<\/em>. If max <\/em>is negative, then the invoking string is fully decomposed. Otherwise, if max <\/em>contains a non-zero value, the last entry in the returned array contains the remainder of the invoking string. If max <\/em>is zero, the invoking string is fully decomposed.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

 <\/p>\n

StringBuffer<\/h2>\n

StringBuffer <\/strong>is a peer class of String <\/strong>that provides much of the functionality of strings. As you know, String <\/strong>represents fixed-length, immutable character sequences. In contrast, StringBuffer <\/strong>represents growable and writeable character sequences. StringBuffer <\/strong>may have characters and substrings inserted in the middle or appended to the end. StringBuffer <\/strong>will automatically grow to make room for such additions and often has more characters preallocated than are actually needed, to allow room for growth. Java uses both classes heavily, but many programmers deal only with String <\/strong>and let Java manipulate StringBuffer<\/strong>s behind the scenes by using the overloaded + <\/strong>operator.<\/p>\n

 <\/p>\n

StringBuffer Constructors<\/h3>\n

StringBuffer <\/strong>defines these three constructors:<\/p>\n

 <\/p>\n

StringBuffer( )<\/p>\n

StringBuffer(int size<\/em>)<\/p>\n

StringBuffer(String str<\/em>)<\/p>\n

 <\/p>\n

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 <\/strong>argument that sets the initial contents of the StringBuffer <\/strong>object and reserves room for 16 more characters without reallocation. StringBuffer <\/strong>allocates room for 16 additional characters when no specific buffer length is requested, because reallocation is a costly process in terms of time. Also, frequent reallocations can fragment memory. By allocating room for a few extra characters, StringBuffer <\/strong>reduces the number of reallocations that take place.<\/p>\n

 <\/p>\n

length( ) and capacity( )<\/h3>\n

The current length of a StringBuffer <\/strong>can be found via the length( ) <\/strong>method, while the total allocated capacity can be found through the capacity( ) <\/strong>method. They have the following general forms:<\/p>\n

 <\/p>\n

int length( )<\/p>\n

int capacity( )<\/p>\n

 <\/p>\n

Here is an example:<\/p>\n

 <\/p>\n\n\n\n
\/\/ StringBuffer length vs. capacity.<\/p>\n

class StringBufferDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer sb = new StringBuffer(“Hello”);<\/p>\n

System.out.println(“buffer = ” + sb);<\/p>\n

System.out.println(“length = ” + sb.length());<\/p>\n

System.out.println(“capacity = ” + sb.capacity());<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Here is the output of this program, which shows how StringBuffer <\/strong>reserves extra space for additional manipulations:<\/p>\n

buffer = Hello<\/p>\n

length = 5<\/p>\n

capacity = 21<\/p>\n

Since sb <\/strong>is initialized with the string \u201cHello\u201d when it is created, its length is 5. Its capacity is 21 because room for 16 additional characters is automatically added.<\/p>\n

 <\/p>\n

ensureCapacity( )<\/h3>\n

If you want to preallocate room for a certain number of characters after a StringBuffer <\/strong>has been constructed, you can use ensureCapacity( ) <\/strong>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<\/strong>. ensureCapacity( ) <\/strong>has this general form:<\/p>\n

 <\/p>\n

void ensureCapacity(int capacity<\/em>)<\/p>\n

 <\/p>\n

Here, capacity <\/em>specifies the size of the buffer.<\/p>\n

 <\/p>\n

setLength( )<\/h3>\n

To set the length of the buffer within a StringBuffer <\/strong>object, use setLength( )<\/strong>. Its general form is shown here:<\/p>\n

 <\/p>\n

void setLength(int len<\/em>)<\/p>\n

 <\/p>\n

Here, len <\/em>specifies the length of the buffer. This value must be nonnegative. When you increase the size of the buffer, null characters are added to the end of the existing buffer. If you call setLength( ) <\/strong>with a value less than the current value returned by length( )<\/strong>, then the characters stored beyond the new length will be lost. The setCharAtDemo <\/strong>sample program in the following section uses setLength( ) <\/strong>to shorten a StringBuffer<\/strong>.<\/p>\n

 <\/p>\n

charAt( ) and setCharAt( )<\/h3>\n

The value of a single character can be obtained from a StringBuffer <\/strong>via the charAt( ) <\/strong>method. You can set the value of a character within a StringBuffer <\/strong>using setCharAt( )<\/strong>.\u00a0 Their general forms are shown here:<\/p>\n

 <\/p>\n

char charAt(int where<\/em>)<\/p>\n

void setCharAt(int where<\/em>, char ch<\/em>)<\/p>\n

 <\/p>\n

For charAt( )<\/strong>, where <\/em>specifies the index of the character being obtained. For setCharAt( )<\/strong>, where <\/em>specifies the index of the character being set, and ch <\/em>specifies the new value of that character. For both methods, where <\/em>must be nonnegative and must not specify a location beyond the end of the buffer. The following example demonstrates charAt( ) <\/strong>and setCharAt( )<\/strong>:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate charAt() and setCharAt().<\/p>\n

class setCharAtDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer sb = new StringBuffer(“Hello”);<\/p>\n

System.out.println(“buffer before = ” + sb);<\/p>\n

System.out.println(“charAt(1) before = ” + sb.charAt(1));<\/p>\n

sb.setCharAt(1, ‘i’);<\/p>\n

sb.setLength(2);<\/p>\n

System.out.println(“buffer after = ” + sb);<\/p>\n

System.out.println(“charAt(1) after = ” + sb.charAt(1));<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Here is the output generated by this program:<\/p>\n

 <\/p>\n

buffer before = Hello<\/p>\n

charAt(1) before = e<\/p>\n

buffer after = Hi<\/p>\n

charAt(1) after = i<\/p>\n

 <\/p>\n

getChars( )<\/h3>\n

 <\/p>\n

To copy a substring of a StringBuffer <\/strong>into an array, use the getChars( ) <\/strong>method. It has this general form:<\/p>\n

 <\/p>\n

void getChars(int sourceStart<\/em>, int sourceEnd<\/em>, char target<\/em>[ ], int targetStart<\/em>)<\/p>\n

 <\/p>\n

Here, sourceStart <\/em>specifies the index of the beginning of the substring, and sourceEnd <\/em>specifies an index that is one past the end of the desired substring. This means that the substring contains the characters from sourceStart <\/em>through sourceEnd<\/em>\u20131. The array that will receive the characters is specified by target. <\/em>The index within target <\/em>at which the substring will be copied is passed in targetStart. <\/em>Care must be taken to assure that the target <\/em>array is large enough to hold the number of characters in the specified substring.<\/p>\n

 <\/p>\n

append( )<\/h3>\n

The append( ) <\/strong>method concatenates the string representation of any other type of data to the end of the invoking StringBuffer <\/strong>object. It has overloaded versions for all the built-in types and for Object<\/strong>. Here are a few of its forms:<\/p>\n

 <\/p>\n

StringBuffer append(String str<\/em>)<\/p>\n

StringBuffer append(int num<\/em>)<\/p>\n

StringBuffer append(Object obj<\/em>)<\/p>\n

\u00a0<\/strong><\/p>\n

String.valueOf( ) <\/strong>is called for each parameter to obtain its string representation. The result is appended to the current StringBuffer <\/strong>object. The buffer itself is returned by each version of append( )<\/strong>. This allows subsequent calls to be chained together, as shown in the following example:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate append().<\/p>\n

class appendDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

String s;<\/p>\n

int a = 42;<\/p>\n

StringBuffer sb = new StringBuffer(40);<\/p>\n

s = sb.append(“a = “).append(a).append(“!”).toString();<\/p>\n

System.out.println(s);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output of this example is shown here:<\/p>\n

a = 42!<\/p>\n

 <\/p>\n

The append( ) <\/strong>method is most often called when the + <\/strong>operator is used on String <\/strong>objects. Java automatically changes modifications to a String <\/strong>instance into similar operations on a StringBuffer <\/strong>instance. Thus, a concatenation invokes append( ) <\/strong>on a StringBuffer <\/strong>object. After the concatenation has been performed, the compiler inserts a call to toString( ) <\/strong>to turn the modifiable StringBuffer <\/strong>back into a constant String<\/strong>. All of this may seem unreasonably complicated. Why not just have one string class and have it behave more or less like StringBuffer<\/strong>? The answer is performance. There are many optimizations that the Java run time can make knowing that String <\/strong>objects are immutable. Thankfully, Java hides most of the complexity of conversion between String<\/strong>s and StringBuffer<\/strong>s. Actually, many programmers will never feel the need to use StringBuffer <\/strong>directly and will be able to express most operations in terms of the + <\/strong>operator on String <\/strong>variables.<\/p>\n

 <\/p>\n

insert( )<\/h3>\n

The insert( ) <\/strong>method inserts one string into another. It is overloaded to accept values of all the simple types, plus String<\/strong>s and Object<\/strong>s. Like append( )<\/strong>, it calls String.valueOf( ) <\/strong>to obtain the string representation of the value it is called with. This string is then inserted into the invoking StringBuffer <\/strong>object. These are a few of its forms:<\/p>\n

 <\/p>\n

StringBuffer insert(int index<\/em>, String str<\/em>)<\/p>\n

StringBuffer insert(int index<\/em>, char ch<\/em>)<\/p>\n

StringBuffer insert(int index<\/em>, Object obj<\/em>)<\/p>\n

 <\/p>\n

Here, index <\/em>specifies the index at which point the string will be inserted into the invoking StringBuffer <\/strong>object. The following sample program inserts \u201clike\u201d between \u201cI\u201d and \u201cJava\u201d:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate insert().<\/p>\n

class insertDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer sb = new StringBuffer(“I Java!”);<\/p>\n

sb.insert(2, “like “);<\/p>\n

System.out.println(sb);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output of this example is shown here:<\/p>\n

I like Java!<\/p>\n

 <\/p>\n

reverse( )<\/h3>\n

You can reverse the characters within a StringBuffer <\/strong>object using reverse( )<\/strong>, shown here:<\/p>\n

 <\/p>\n

StringBuffer reverse( )<\/p>\n

 <\/p>\n

This method returns the reversed object on which it was called. The following program demonstrates reverse( )<\/strong>:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Using reverse() to reverse a StringBuffer.<\/p>\n

class ReverseDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer s = new StringBuffer(“abcdef”);<\/p>\n

System.out.println(s);<\/p>\n

s.reverse();<\/p>\n

System.out.println(s);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Here is the output produced by the program:<\/p>\n

abcdef<\/p>\n

fedcba<\/p>\n

 <\/p>\n

delete( ) and deleteCharAt( )<\/h3>\n

Java 2 added to StringBuffer <\/strong>the ability to delete characters using the methods delete( ) <\/strong>and deleteCharAt( )<\/strong>. These methods are shown here:<\/p>\n

 <\/p>\n

StringBuffer delete(int startIndex<\/em>, int endIndex<\/em>)<\/p>\n

StringBuffer deleteCharAt(int loc<\/em>)<\/p>\n

 <\/p>\n

The delete( ) <\/strong>method deletes a sequence of characters from the invoking object. Here, startIndex <\/em>specifies the index of the first character to remove, and endIndex <\/em>specifies an index one past the last character to remove. Thus, the substring deleted runs from startIndex <\/em>to endIndex<\/em>\u20131. The resulting StringBuffer <\/strong>object is returned. The deleteCharAt( ) <\/strong>method deletes the character at the index specified by loc<\/em>. It returns the resulting StringBuffer <\/strong>object. Here is a program that demonstrates the delete( ) <\/strong>and deleteCharAt( ) <\/strong>methods:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate delete() and deleteCharAt()<\/p>\n

class deleteDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer sb = new StringBuffer(“This is a test.”);<\/p>\n

sb.delete(4, 7);<\/p>\n

System.out.println(“After delete: ” + sb);<\/p>\n

sb.deleteCharAt(0);<\/p>\n

System.out.println(“After deleteCharAt: ” + sb);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The following output is produced:<\/p>\n

After delete: This a test.<\/p>\n

After deleteCharAt: his a test.<\/p>\n

 <\/p>\n

replace( )<\/h3>\n

Another method added to StringBuffer <\/strong>by Java 2 is replace( )<\/strong>. It replaces one set of characters with another set inside a StringBuffer <\/strong>object. Its signature is shown here: StringBuffer replace(int startIndex<\/em>, int endIndex<\/em>, String str<\/em>) The substring being replaced is specified by the indexes startIndex <\/em>and endIndex<\/em>. Thus, the substring at startIndex <\/em>through endIndex<\/em>\u20131 is replaced. The replacement string is passed in str<\/em>. The resulting StringBuffer <\/strong>object is returned. The following program demonstrates replace( )<\/strong>:<\/p>\n

 <\/p>\n\n\n\n
\/\/ Demonstrate replace()<\/p>\n

class replaceDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer sb = new StringBuffer(“This is a test.”);<\/p>\n

sb.replace(5, 7, “was”);<\/p>\n

System.out.println(“After replace: ” + sb);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Here is the output:<\/p>\n

After replace: This was a test.<\/p>\n

 <\/p>\n

substring( )<\/h3>\n

Java 2 also added the substring( ) <\/strong>method, which returns a portion of a StringBuffer<\/strong>. It has the following two forms:<\/p>\n

 <\/p>\n

String substring(int startIndex<\/em>)<\/p>\n

String substring(int startIndex<\/em>, int endIndex<\/em>)<\/p>\n

 <\/p>\n

The first form returns the substring that starts at startIndex <\/em>and runs to the end of the invoking StringBuffer <\/strong>object. The second form returns the substring that starts at startIndex <\/em>and runs through endIndex<\/em>\u20131. These methods work just like those defined for String <\/strong>that were described earlier.<\/p>\n

 <\/p>\n

StringBuffer Methods Added by Java 2, Version 1.4<\/h2>\n

 <\/p>\n

Java 2, version 1.4 added several new methods to StringBuffer<\/strong>. They are summarized in the following table.<\/p>\n

 <\/p>\n\n\n\n\n\n\n\n\n
Method<\/td>\nDescription<\/td>\n<\/tr>\n
CharSequence subSequence(int startIndex<\/em>,<\/p>\n

int stopIndex<\/em>)<\/p>\n

 <\/td>\n

Returns a substring of the invoking string, beginning at startIndex <\/em>and stopping at stopIndex<\/em>. This method is<\/p>\n

required by the CharSequence <\/strong>interface, which is now implemented by StringBuffer<\/strong>.<\/p>\n

 <\/td>\n<\/tr>\n

int indexOf(String str<\/em>)<\/p>\n

 <\/td>\n

Searches the invoking StringBuffer <\/strong>for the first occurrence of str<\/em>. Returns the index of the match, or \u20131 if no match is found.<\/td>\n<\/tr>\n
int indexOf(String str<\/em>, int startIndex<\/em>)<\/p>\n

 <\/td>\n

Searches the invoking StringBuffer <\/strong>for the first occurrence of str<\/em>, beginning at startIndex<\/em>. Returns the index of the match, or \u20131 if no match is found.<\/td>\n<\/tr>\n
int lastIndexOf(String str<\/em>)<\/p>\n

 <\/td>\n

Searches the invoking StringBuffer <\/strong>for the last occurrence of str. Returns the index of the match, or \u20131 if no match is found.<\/td>\n<\/tr>\n
int lastIndexOf(String str<\/em>, int startIndex<\/em>)<\/p>\n

 <\/td>\n

Searches the invoking StringBuffer <\/strong>for the last occurrence of str<\/em>, beginning at startIndex<\/em>. Returns the index of the match, or \u20131 if no match is found.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Aside from subSequence( )<\/strong>, which implements a method required by the CharSequence <\/strong>interface, the other methods allow a StringBuffer <\/strong>to be searched for an occurrence of a String<\/strong>. The following program demonstrates indexOf( ) <\/strong>and lastIndexOf( )<\/strong>.<\/p>\n

 <\/p>\n\n\n\n
class IndexOfDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

StringBuffer sb = new StringBuffer(“one two one”);<\/p>\n

int i;<\/p>\n

i = sb.indexOf(“one”);<\/p>\n

System.out.println(“First index: ” + i);<\/p>\n

i = sb.lastIndexOf(“one”);<\/p>\n

System.out.println(“Last index: ” + i);<\/p>\n

}<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The output is shown here.<\/p>\n

First index: 0<\/p>\n

Last index: 8<\/p>\n

 <\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

String Handling   In Java a string is a sequence of characters. Java implements strings as objects of type String. For example, Java has methods to compare two strings, search… <\/p>\n","protected":false},"author":1,"featured_media":3477,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[83],"tags":[],"aioseo_notices":[],"amp_enabled":true,"_links":{"self":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3463"}],"collection":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/comments?post=3463"}],"version-history":[{"count":2,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3463\/revisions"}],"predecessor-version":[{"id":3489,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3463\/revisions\/3489"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/media\/3477"}],"wp:attachment":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/media?parent=3463"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/categories?post=3463"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/tags?post=3463"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}