12.1. The System.String Class

Java and C# strings are immutable, and therefore the string instance cannot be modified. Instead, a new instance containing the modification is created whenever a method is called on a string instance that tries to modify it. The .NET Framework class library gives the following class declaration for the System.String class. (If you prefer, you can skip this section and use it as a reference when you start using some of the methods in this class.)

[Serializable]
public sealed class String : IComparable, ICloneable,
IConvertible, IEnumerable

The IComparable interface is similar to the java.lang.Comparable interface. An object implements this interface in order to compare itself to another object of the same type. The interface contains a CompareTo method, which returns a value of –1, 0, or 1 depending on whether the instance is less than, equal to, or greater than the object passed to the argument. Because a string is a sequence of characters, this class implements the IEnumerable interface, which returns an IEnumerator. This interface lets you iterate over the sequence of characters. The IConvertible interface defines methods that convert the value of the implementing reference or value type to a Common Language Runtime type that has an equivalent value. The CLR typically exposes the IConvertible interface through the Convert class.

Listing 12.1 shows how the String interfaces can be useful.

Listing 12.1. Using the System.String Interfaces (C#)

using System;
using System.Collections;

public class Test {

  public static void Main(string[] args) {

    TestIComparable();
    TestIEnumerable();
    TestICloneable();
    TestIConvertible();
  }
  private static void TestIComparable() {
    String s1 = "C#";
    String s2 = "Java";
    Console.WriteLine("Comparing C# and Java
                       "+s1.CompareTo(s2));
  }
  private static void TestICloneable() {
    String s1 = "C#";
    String s2 = (String) s1.Clone();
    Console.WriteLine("(s1 Equals s2)? "+s1.Equals(s2));
    Console.WriteLine("(s1 == s2)? " + (s1 == s2));
  }
  private static void TestIEnumerable() {
    String s1 = "abcdefghijklmnopqrstuvwxyz";
    IEnumerator enums = s1.GetEnumerator();
    while (enums.MoveNext()) {
      Console.Write(enums.Current);
    }
  }
  private static void TestIConvertible() {
    String s = "12345";
    try {
      Console.WriteLine(Convert.ToInt16(s));
      Console.WriteLine(Convert.ToInt32(s));
      Console.WriteLine(Convert.ToInt64(s));
      Console.WriteLine(Convert.ToDecimal(s));
      Console.WriteLine(Convert.ToDouble(s));
      Console.WriteLine(Convert.ToBoolean(s));
    } catch (Exception e) {
      Console.WriteLine(e.Message);
    }
  }
}

The output of Listing 12.1 is as follows:

Comparing C# and Java -1
abcdefghijklmnopqrstuvwxyz(s1 Equals s2)? True
(s1 == s2)? True
12345
12345
12345
12345
12345
String was not recognized as a valid Boolean.

Note that the Convert class is a utility class found in the System namespace that can be used to convert from one data type to another. Converting the string 12345 to a bool throws an exception, and this is indicated by the last line of the output.

The String class is declared as sealed, which is similar to the final declaration of Java strings. The System.String class cannot be subclassed. The System.String class is thread-safe. Thread safety may be inconsequential for this class, considering that objects of this class cannot be changed by any thread. Tables 12.1 and 12.2 list the constructors and methods, respectively, of the System.String class.

String constructors are seldom used to initialize strings. A traditional approach is to assign the string reference to a string literal; the runtime automatically creates a string object and makes the reference point to this string object. The C# runtime optimizes creation of Strings (just as the JVM does) through the process of interning; essentially, this means that strings with the same value are represented by one object in the runtime, with multiple references pointing to the same object. This technique minimizes object creation, given that Strings are ubiquitous. Both the CLR and the JVM perform this optimization internally. One constructor that Java programmers may miss in C# is the one that takes a string literal.

Table 12.2 shows the CLS-compliant public methods of the String class. The compare methods make a lexical comparison of the compared string instances. The int returned in all the compare methods is 0 if the strings are equal, –1 if the first string is less than the second one, and 1 if the first string is greater than the second string. Note that all the compare methods base their comparison on comparing the values of the strings.

Table 12.3 shows the compare methods of the String class. The CompareTo method compares one String instance to another. Note that this method is not static and is defined on the string object itself. Again, the method makes a lexical comparison, resulting in 0 if the two objects are equal, –1 if the instance is less than the value, and 1 if the instance is greater than the value.

Table 12.4 shows the concatenation methods of the String class. Notice that the Concat methods are all static. Two strings concatenated twice by the same method will yield two different string instances. You can test this by using the = = operator to compare the object instances, as shown in Listing 12.2.

Listing 12.2. Comparing Concatenated Instances of a String (C#)

using System;
public class Test {
  public static void Main(string[] args) {
    String s = String.Concat("a", "b");
    String t = String.Concat("a", "b");
    Console.WriteLine(s == t);
  }
}

public static string
  Concat(params object[])

public static string
  Concat(params string[]);

public static string
  Concat(object, object)

public static string Concat(string,
  string)

public static string
  Concat(object, object, object)

public static string Concat(string,
  string, string);

public static string Concat(string,
  string, string, string)

The output of Listing 12.2 is

True

The CLR does string interning in which String instances are reused. In Listing 12.2 we created two different strings (s and t) by concatenating the string literals a and b. The two string instances s and t point to the same string object.

Table 12.5 shows an assortment of methods in the String class. Most of the methods in Table 12.5 are self-explanatory, and therefore we will not give examples for each of the member methods. Remember that methods that seem to modify the string return a new string that is different from the original string. Listing 12.3 demonstrates this point.

Listing 12.3. Testing String Equality (C#)

using System;

public class StringTest {

  public static void Main(string[] args) {
    string s = "hello ";
    String t = s.Insert(s.Length-1, "World").Remove(s.Length-
    1,5);
    Console.WriteLine(s == t);
    Console.WriteLine(s.Equals(t));
    Console.WriteLine((object)s == (object)t);
  }
}

The output of Listing 12.3 is as follows:

True
True
False

Although s and t have the same value, they are two different string object instances (not interned) because we made some modifications on the string instance s.

public static string
  Copy(string str)

public void CopyTo (
  int sourceIndex,
  char[] destination,
  int destinationIndex,
  int count
  )

public bool EndsWith(
  string value
  )

public override bool
  Equals(object)

public override bool
  Equals(string)

public static bool
  Equals(string, string)

public static string
  Format(string, object)

public static string
  Format(string, params
  object[])

public static string
  Format(IFormatProvider,
  string, params object[])

public static string
  Format(string, object,
  object)

public static string
  Format(string, object,
  object, object)

public CharEnumerator
  GetEnumerator()

public override int
  GetHashCode()

public TypeCode
  GetTypeCode()

public int
  IndexOf(char)

public int
  IndexOf(string)

public int IndexOf(char,
  int)

public int
  IndexOf(string, int)

public int IndexOf(char,
  int, int)

public int
  IndexOf(string,
  int, int)

public int
  IndexOfAny(char[])

public int
  IndexOfAny(char[], int)

public int
  IndexOfAny(char[],
  int, int)

public string Insert(
  int startIndex,
  string value)

public static string
  IsInterned(string str)

public static string
  Join (string
  separator, string[]
  value, int startIndex,
  int count
  )

public static string
  Join(string, string[],
  int, int)

public int
  LastIndexOf(char)

public int
  LastIndexOf(string)

public int
  LastIndexOf(char,
  int)

public int
  LastIndexOf(string,
  int)

public int
  LastIndexOf(char,
  int, int)

public int
  LastIndexOf(string,
  int, int)

public int
  LastIndexOfAny(char[])

public int
  LastIndexOfAny
  (char[], int)

public int
  LastIndexOfAny(char[],
  int, int)

public string
  PadLeft(int)

public string
  PadLeft(int, char)

public string
  PadRight(int)

public string
  PadRight(int, char)

public string Remove(
  int startIndex,
  int count
  )

public string
  Replace(char, char)

public string
  Replace(string, string)

public string[]
  Split(char[])

public string[]
  Split(char[], int)

public bool
  StartsWith(string
  value)

public string
  Substring(int)

public string
  Substring(int, int)

public char[]
  ToCharArray()

public char[]
  ToCharArray(int, int)

public string
  ToLower(CultureInfo)

public override
  string ToString()

public string
  ToString(IFormat
  Provider)

public string
  ToUpper(CultureInfo)

public string
  Trim(params char[])

public string TrimEnd(
  params char[]
  trimChars)

public string
  TrimStart(params
  char[] trimChars)