Section 16.2. Manipulating Strings | Learning Visual Basic .Net

16.2 Manipulating Strings

The String class provides a host of methods for comparing, searching, and manipulating strings, the most important of which are shown in Table 16-1.

Table 16-1. String class methods

Method or field	Explanation
Chars	The string indexer
Compare( )	Overloaded public shared method that compares two strings
Copy( )	Public shared method that creates a new string by copying another
Equals( )	Overloaded public shared and instance method that determines if two strings have the same value
Format( )	Overloaded public shared method that formats a string using a format specification
Length	The number of characters in the instance
PadLeft( )	Right-aligns the characters in the string, padding to the left with spaces or a specified character
PadRight( )	Left-aligns the characters in the string, padding to the right with spaces or a specified character
Remove( )	Deletes the specified number of characters
Split( )	Divides a string, returning the substrings delimited by the specified characters
StartsWith( )	Indicates if the string starts with the specified characters
SubString( )	Retrieves a substring
ToCharArray( )	Copies the characters from the string to a character array
ToLower( )	Returns a copy of the string in lowercase
ToUpper( )	Returns a copy of the string in uppercase
Trim( )	Removes all occurrences of a set of specified characters from beginning and end of the string
TrimEnd( )	Behaves like Trim( ), but only at the end
TrimStart( )	Behaves like Trim( ), but only at the start

16.2.1 Comparing Strings

The Compare( ) method is overloaded. The first version takes two strings and returns a negative number if the first string is alphabetically before the second, a positive number if the first string is alphabetically after the second, and zero if they are equal. The second version works just like the first but is case insensitive. Example 16-1 illustrates the use of Compare( ).

Example 16-1. Compare( ) method

 Namespace StringManipulation     Class Tester         Public Sub Run( )             ' create some Strings to work with             Dim s1 As [String] = "abcd"             Dim s2 As [String] = "ABCD"             Dim result As Integer ' hold the results of comparisons             ' compare two Strings, case sensitive             result = [String].Compare(s1, s2)             Console.WriteLine( _               "compare s1: {0}, s2: {1}, result: {2}" _                & Environment.NewLine, s1, s2, result)             ' overloaded compare, takes boolean "ignore case"              '(true = ignore case)             result = [String].Compare(s1, s2, True)             Console.WriteLine("Compare insensitive. result: {0}" _                & Environment.NewLine, result)         End Sub 'Run         Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringManipulation

  Output:  compare s1: abcd, s2: ABCD, result: -1 Compare insensitive. result: 0

This code uses the Shared NewLine property of the Environment class to create a new line in the output. This is a very general way to ensure that the correct code sequence is sent to create the newline on the current operating system.

Example 16-1 begins by declaring two strings, s1 and s2, initialized with string literals:

 Dim s1 As [String] = "abcd" Dim s2 As [String] = "ABCD"

Compare( ) is used with many types. A negative return value indicates that the first parameter is less than the second; a positive result indicates the first parameter is greater than the second, and a zero indicates they are equal.

In Unicode (as in ASCII), a lowercase letter has a smaller value than an uppercase letter. Thus, the output properly indicates that s1 (abcd) is "less than" s2 (ABCB):

 compare s1: abcd, s2: ABCD, result: -1

The second comparison uses an overloaded version of Compare, which takes a third, Boolean parameter, the value of which determines whether case should be ignored in the comparison. If the value of this "ignore case" parameter is true, the comparison is made without regard to case. This time the result is 0, indicating that the two strings are identical (without regard to case):

 Compare insensitive. result: 0

16.2.2 Concatenating Strings

There are a couple ways to concatenate strings in VB.NET. You can use the Concat( ) method, which is a shared public method of the String class:

 Dim s3 As String = String.Concat(s1, s2)

or you can simply use the concatenation ( & ) operator:

 Dim s4 As String = s1 & s2

These two methods are demonstrated in Example 16-2.

Example 16-2. Concatenation

 Option Strict On Imports System Namespace StringManipulation     Class Tester         Public Sub Run( )             Dim s1 As String = "abcd"             Dim s2 As String = "ABCD"             ' concatenation method             Dim s3 As String = String.Concat(s1, s2)             Console.WriteLine("s3 concatenated from s1 and s2: {0}", s3)             ' use the overloaded operator             Dim s4 As String = s1 & s2             Console.WriteLine("s4 concatenated from s1 & s2: {0}", s4)         End Sub 'Run         Public Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringManipulation

  Output:  s3 concatenated from s1 and s2: abcdABCD s4 concatenated from s1 & s2: abcdABCD

In Example 16-2, the new string s3 is created by calling the shared Concat( ) method and passing in s1 and s2, while the string s4 is created by using the overloaded concatenation ( & ) operator that concatenates two strings and returns a string as a result.

VB.NET supports two concatenation operators (+ and &), however the plus sign is also used for adding numeric values, and Microsoft documentation suggests using the ampersand to reduce ambiguity.

16.2.3 Copying Strings

Similarly, creating a new copy of a string can be accomplished in two ways. First, you can use the shared Copy( ) method:

 Dim s5 As String = String.Copy(s2)

or for convenience, you might instead use the assignment operator (=), which will implicitly make a copy:

 Dim s6 As String = s5

When you assign one string to another, the two reference types refer to the same String in memory. This implies that altering one would alter the other because they refer to the same String object. However, this is not the case. The String type is immutable. Thus, if after assigning s5 to s6, you alter s6, the two strings will actually be different.

Example 16-3 illustrates how to copy strings.

Example 16-3. Copying strings

 Option Strict On Imports System Namespace StringManipulation         Class Tester              Public Sub Run( )          Dim s1 As String = "abcd"          Dim s2 As String = "ABCD"                    ' the String copy method          Dim s5 As String = String.Copy(s2)          Console.WriteLine("s5 copied from s2: {0}", s5)                    ' use the overloaded operator          Dim s6 As String = s5          Console.WriteLine("s6 = s5: {0}", s6)       End Sub 'Run                     Public Shared Sub Main( )          Dim t As New Tester( )          t.Run( )       End Sub 'Main    End Class 'Tester End Namespace 'StringManipulation

  Output:  s5 copied from s2: ABCD s6 = s5: ABCD

16.2.4 Testing for Equality

The .NET String class provides two ways to test for the equality of two strings. First, you can use the overloaded Equals( ) method and ask one string (say, s6) directly whether another string (s5) is of equal value:

 Console.WriteLine("Does s6.Equals(s5)?: {0}", s6.Equals(s5))

A second technique is to pass both strings to the String class's shared method Equals( ):

 Console.WriteLine("Does Equals(s6,s5)?: {0}", _     String.Equals(s6, s5))

In each of these cases, the returned result is a Boolean value (true for equal and false for unequal ). These techniques are demonstrated in Example 16-4.

Example 16-4. Are all strings created equal?

 Option Strict On Imports System Namespace StringManipulation     Class Tester         Public Sub Run( )             Dim s1 As String = "abcd"             Dim s2 As String = "ABCD"             ' the String copy method             Dim s5 As String = String.Copy(s2)             Console.WriteLine("s5 copied from s2: {0}", s5)             ' copy with the overloaded operator             Dim s6 As String = s5             Console.WriteLine("s6 = s5: {0}", s6)             ' member method             Console.WriteLine("Does s6.Equals(s5)?: {0}", s6.Equals(s5))             ' shared method             Console.WriteLine("Does Equals(s6,s5)?: {0}", _                 String.Equals(s6, s5))         End Sub 'Run         Public Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringManipulation

  Output:  s5 copied from s2: ABCD s6 = s5: ABCD Does s6.Equals(s5)?: True Does Equals(s6,s5)?: True Does s6==s5?: True

16.2.5 Other Useful String Methods

The String class includes a number of useful methods and properties for finding specific characters or substrings within a string, as well as for manipulating the contents of the string. A few such methods are demonstrated in Example 16-5. Following the output is a complete analysis.

Example 16-5. Useful string methods

 Option Strict On Imports System Namespace StringManipulation          Class Tester         Public Sub Run( )             Dim s1 As String = "abcd"             Dim s2 As String = "ABCD"             Dim s3 As String = "Liberty Associates, Inc. provides "             s3 = s3 & "custom .NET development"             ' the String copy method             Dim s5 As String = String.Copy(s2) '             Console.WriteLine("s5 copied from s2: {0}", s5)             ' The length             Console.WriteLine("String s3 is {0} characters long. ", _                s5.Length)             Console.WriteLine( )             Console.WriteLine("s3: {0}", s3)             ' test whether a String ends with a set of characters             Console.WriteLine("s3: ends with Training?: {0}", _                s3.EndsWith("Training"))             Console.WriteLine("Ends with developement?: {0}", _                 s3.EndsWith("development"))             Console.WriteLine( )             ' return the index of the string             Console.Write("The first occurrence of provides ")             Console.WriteLine("in s3 is {0}", s3.IndexOf("provides"))             ' hold the location of provides as an integer             Dim location As Integer = s3.IndexOf("provides")             ' insert the word usually before "provides"             Dim s10 As String = s3.Insert(location, "usually ")             Console.WriteLine("s10: {0}", s10)             ' you can combine the two as follows:             Dim s11 As String = _                 s3.Insert(s3.IndexOf("provides"), "usually ")             Console.WriteLine("s11: {0}", s11)             Console.WriteLine( )             'Use the Mid function to replace within the string             Mid(s11, s11.IndexOf("usually") + 1, 9) = "always!"             Console.WriteLine("s11 now: {0}", s11)         End Sub 'Run         Public Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringManipulation

  Output:  s5 copied from s2: ABCD String s3 is 4 characters long. s3: Liberty Associates, Inc. provides custom .NET development s3: ends with Training?: False Ends with developement?: True The first occurrence of provides in s3 is 25 s10: Liberty Associates, Inc. usually provides custom .NET development s11: Liberty Associates, Inc. usually provides custom .NET development s11 now: Liberty Associates, Inc. always! provides custom .NET development

The Length property returns the length of the entire string:

 Console.WriteLine("String s3 is {0} characters long. ", _    s5.Length)

Here's the output:

 String s3 is 4 characters long.

The EndsWith( ) method asks a string whether a substring is found at the end of the string. Thus, you might ask s3 first if it ends with "Training" (which it does not) and then if it ends with "Consulting" (which it does):

 Console.WriteLine("s3: ends with Training?: {0}", _    s3.EndsWith("Training")) Console.WriteLine("Ends with developement?: {0}", _     s3.EndsWith("development"))

The output reflects that the first test fails and the second succeeds:

 s3: ends with Training?: False Ends with developement?: True

The IndexOf( ) method locates a substring within our string, and the Insert( ) method inserts a new substring into a copy of the original string. The following code locates the first occurrence of "provides" in s3:

 Console.Write("The first occurrence of provides ") Console.WriteLine("in s3 is {0}", s3.IndexOf("provides"))

The output indicates that the offset is 25:

 The first occurrence of provides in s3 is 25

You can then use that value to insert the word "usually", followed by a space, into that string. Actually the insertion is into a copy of the string returned by the Insert( ) method and assigned to s10:

 Dim s10 As String = s3.Insert(location, "usually ") Console.WriteLine("s10: {0}", s10)

Here's the output:

 s10: Liberty Associates, Inc. usually provides custom .NET development

Finally, you can combine these operations to make a more efficient insertion statement:

 Dim s11 As String = s3.Insert(s3.IndexOf("provides"), "usually ")

16.2.6 Finding Substrings

The String class has methods for finding and extracting substrings. For example, the IndexOf( ) method returns the index of the first occurrence of a string (or one or more characters) within a target string.

For example, given the definition of the string s1 as:

 Dim s1 As String = "One Two Three Four"

You can find the first instance of the characters "hre" by writing:

 Dim index as Integer = s1.IndexOf("hre")

This code will set the integer variable index to 9, which is the offset of the letters "hre" in the string s1.

Similarly, the LastIndexOf( ) method returns the index of the last occurrence of a string or substring. While the following code:

 s1.IndexOf("o")

will return the value 6 (the first occurrence of the lowercase letter "o" is at the end of the word Two), the method call:

 s1.LastIndexOf("o")

will return the value 15, the last occurrence of "o" is in the word Four.

The Substring( ) method return a series of characters. You can ask it for all the characters starting at a particular offset and ending either with the end of the string or with an offset you ( optionally ) provide.

The Substring( ) method is illustrated in Example 16-6.

Example 16-6. Finding Substrings by index

 Option Strict On Imports System Namespace StringSearch     Class Tester         Public Sub Run( )             ' create some strings to work with             Dim s1 As String = "One Two Three Four"             Dim index As Integer             ' get the index of the last space             index = s1.LastIndexOf(" ")             ' get the last word.             Dim s2 As String = s1.Substring((index + 1))             ' set s1 to the substring starting at 0             ' and ending at index (the start of the last word             ' thus s1 has One Two Three             s1 = s1.Substring(0, index)             ' find the last space in s1 (after "Two")             index = s1.LastIndexOf(" ")             ' set s3 to the substring starting at              ' index, the space after "Two" plus one more             ' thus s3 = "three"             Dim s3 As String = s1.Substring((index + 1))             ' reset s1 to the substring starting at 0             ' and ending at index, thus the String "One Two"             s1 = s1.Substring(0, index)             ' reset index to the space between              ' "One" and "Two"             index = s1.LastIndexOf(" ")             ' set s4 to the substring starting one             ' space after index, thus the substring "Two"             Dim s4 As String = s1.Substring((index + 1))             ' reset s1 to the substring starting at 0             ' and ending at index, thus "One"             s1 = s1.Substring(0, index)             ' set index to the last space, but there is              ' none so index now = -1             index = s1.LastIndexOf(" ")             ' set s5 to the substring at one past             ' the last space. there was no last space             ' so this sets s5 to the substring starting             ' at zero             Dim s5 As String = s1.Substring((index + 1))             Console.WriteLine("s1: {0}", s1)             Console.WriteLine("s2: {0}", s2)             Console.WriteLine("s3: {0}", s3)             Console.WriteLine("s4: {0}", s4)             Console.WriteLine("s5: {0}", s5)         End Sub 'Run         Public Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringSearch

  Output:  s1: One s2: Four s3: Three s4: Two s5: One

Example 16-6 is not the most elegant solution to the problem of extracting words from a string, but it is a good first approximation and it illustrates a useful technique. The example begins by creating a string, s1:

 Dim s1 As String = "One Two Three Four"

The local variable index is assigned the value of the last space in the string (which comes before the word Four):

 index = s1.LastIndexOf(" ")

The substring that begins one space later is assigned to the new string, s2:

 Dim s2 As String = s1.Substring((index + 1))

This extracts the characters from index +1 to the end of the line (i.e., the string "Four"), assigning the value "Four" to s2.

The next step is to remove the word Four from s1. You can do this by assigning to s1 the substring of s1 that begins at 0 and ends at the index:

 s1 = s1.SubString(0,index);

You reassign index to the last (remaining) space, which points you to the beginning of the word Three. You then extract the characters "Three" into string s3. You can continue like this until you've populated s4 and s5. Finally, you display the results:

 s1: One s2: Four s3: Three s4: Two s5: One

16.2.7 Splitting Strings

A more effective solution to the problem illustrated in Example 16-6 would be to use the Split( ) method of String, which parses a string into substrings. To use Split( ), you pass in an array of delimiters (characters that will indicate where to divide the words). The method returns an array of substrings, which Example 16-7 illustrates. The complete analysis follows the code.

Example 16-7. The Split( ) method

 Option Strict On Imports System Namespace StringSearch     Class Tester         Public Sub Run( )             ' create some Strings to work with             Dim s1 As String = "One,Two,Three Liberty Associates, Inc."             ' constants for the space and comma characters             Const Space As Char = " "c             Const Comma As Char = ","c             ' array of delimiters to split the sentence with             Dim delimiters( ) As Char = {Space, Comma}             Dim output As String = ""             Dim ctr As Integer = 0             ' split the String and then iterate over the             ' resulting array of strings             Dim resultArray As String( ) = s1.Split(delimiters)             Dim subString As String             For Each subString In resultArray                 ctr = ctr + 1                 output &= ctr.ToString( )                 output &= ": "                 output &= subString                 output &= Environment.NewLine             Next subString             Console.WriteLine(output)         End Sub 'Run         Public Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringSearch

  Output:  1: One 2: Two 3: Three 4: Liberty 5: Associates 6: 7: Inc.

Example 16-7 starts by creating a string to parse:

 Dim s1 As String = "One,Two,Three Liberty Associates, Inc."

The delimiters are set to the space and comma characters:

 Const Space As Char = " "c Const Comma As Char = ","c Dim delimiters( ) As Char = {Space, Comma}

Double quotes are used in VB.NET to signal a string constant. The c after the string literals establishes that these are characters, not strings.

You then call Split( ) on the string, passing in the delimiters:

 Dim resultArray As String( ) = s1.Split(delimiters)

Split( ) returns an array of the substrings that you can then iterate over using the For Each loop, as explained in Chapter 14.

 Dim subString As String For Each subString In resultArray     ctr = ctr + 1     output &= ctr.ToString( )     output &= ": "     output &= subString     output &= Environment.NewLine Next subString

You increment the counter variable, ctr. Then you build up the output string in four steps. You concatenate the string value of ctr. Next you add the colon , then the substring returned by Split( ), then the newline.

 ctr = ctr  1 output &= ctr.ToString( ) output &= ": " output &= subString output &= Environment.NewLine

With each concatenation, a new copy of the string is made, and all four steps are repeated for each substring found by Split( ). This repeated copying of the string is terribly inefficient.

The problem is that the String type is not designed for this kind of operation. What you want is to create a new string by appending a formatted string each time through the loop. The class you need is StringBuilder.

16.2.8 The StringBuilder Class

The System.Text.StringBuilder class is used for creating and modifying strings. Semantically, it is the encapsulation of a constructor for a string. The important members of StringBuilder are summarized in Table 16-2.

Table 16-2. StringBuilder members

Method or property	Explanation
Append( )	Overloaded public method that appends a typed object to the end of the current StringBuilder
AppendFormat( )	Overloaded public method that replaces format specifiers with the formatted value of an object
EnsureCapacity( )	Method that ensures that the current StringBuilder has a capacity at least as large as the specified value
Capacity	Property that retrieves or assigns the number of characters the StringBuilder is capable of holding
Chars	Property that contains the indexer
Insert( )	Overloaded public method that inserts an object at the specified position
Length	Property that retrieves or assigns the length of the StringBuilder
MaxCapacity	Property that retrieves the maximum capacity of the StringBuilder
Remove( )	Removes the specified characters
Replace( )	Overloaded public method that replaces all instances of specified characters with new characters

Unlike the String class, StringBuilder is mutable; when you modify an instance of the StringBuilder class, you modify the actual string, not a copy.

Example 16-8 replaces the String object in Example 16-7 with a StringBuilder object.

Example 16-8. The StringBuilder class

 Imports System.Text Namespace StringSearch     Class Tester         Public Sub Run( )             ' create some Strings to work with             Dim s1 As String = "One,Two,Three Liberty Associates, Inc."             ' constants for the space and comma characters             Const Space As Char = " "c             Const Comma As Char = ","c             ' array of delimiters to split the sentence with             Dim delimiters( ) As Char = {Space, Comma}             Dim output As New StringBuilder( )             Dim ctr As Integer = 0             ' split the String and then iterate over the             ' resulting array of Strings             Dim resultArray As String( ) = s1.Split(delimiters)             Dim subString As String             For Each subString In resultArray                 ctr = ctr + 1                 output.AppendFormat("{0} : {1}" & _                     Environment.NewLine, ctr, subString)             Next subString             Console.WriteLine(output)         End Sub 'Run         Public Shared Sub Main( )             Dim t As New Tester( )             t.Run( )         End Sub 'Main     End Class 'Tester End Namespace 'StringSearch

Only the last part of the program is modified from the previous example. Rather than using the concatenation operator to modify the string, you use the AppendFormat( ) method of StringBuilder to append new, formatted strings as you create them. This is much easier and far more efficient. The output is identical:

 1: One 2: Two 3: Three 4: Liberty 5: Associates 6: 7: Inc.

Delimiter Limitations

Because you passed in delimiters of both comma and space, the space after the comma between "Associates" and "Inc." is returned as a word, numbered 6 previously. That is not what you want. To eliminate this, you need to tell Split( ) to match a comma (as between "One", "Two", and "Three") or a space (as between "Liberty" and "Associates") or a comma followed by a space. It is that last bit that is tricky and requires that you use a regular expression.