[C#]几种字符串反转方法效率比较

下面是实现字符串反转的四种方法：

            static string Reverse1(string original)
            ...{
                char[] arr = original.ToCharArray();
                Array.Reverse(arr);
                return new string(arr);
            }

            static string Revease21(string original)
            ...{
                int length = original.Length;
                char[] arr = new char[length];
                for (int i = 0; i < (length & (~3)); i += 4)
                ...{
                    arr[i] = original[length - i - 1];
                    arr[i+1] = original[length - i - 2];
                    arr[i+2] = original[length - i - 3];
                    arr[i+3] = original[length - i - 4];
                }
                for (int i = length & (~3); i < length; i++)
                ...{
                    arr[i] = original[length - i - 1];
                }
                return new string(arr);
            }

            static string Revease22(string original)
            ...{
                int length = original.Length;
                char[] arr = new char[length];
                for (int i = 0; i < length; i++)
                ...{
                    arr[i] = original[length - i - 1];
                }
                return new string(arr);
            }

            static string Revease3(string original)
            ...{
                int length = original.Length;
                StringBuilder sb = new StringBuilder(length);
                for (int i = length-1; i >= 0; i--)
                sb.Append(original[i]);
                return sb.ToString();
            }

 Revease1()中对char[]进行了两次赋值(ToCharArray()和Array.Revease)，所以我有想到了Revease2和Revease3()两种方法，下面是对这四种方法进行简单性能测试的代码：

　　　static void Main(string[] args)
            ...{
                string testString = "测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转";
                DateTime start = DateTime.Now;
                for (int i = 0; i < 3000000; i++)
                ...{
                    string s = Reverse1(testString);
                }
                DateTime end = DateTime.Now;
                Console.WriteLine("1 :  "+(end - start));

                start = DateTime.Now;
                for (int i = 0; i < 3000000; i++)
                ...{
                    string s = Revease21(testString);
                }
                end = DateTime.Now;
                Console.WriteLine("21:  " + (end - start));

                start = DateTime.Now;
                for (int i = 0; i < 3000000; i++)
                ...{
                    string s = Revease22(testString);
                }
                end = DateTime.Now;
                Console.WriteLine("22:  " + (end - start));

                start = DateTime.Now;
                for (int i = 0; i < 3000000; i++)
                ...{
                    string s = Revease3(testString);
                }
                end = DateTime.Now;
                Console.WriteLine("3 :  " + (end - start));

                Console.ReadLine();
            }

测试结果是Revease1()代码最简洁，运行速度也最快，Revease21()和Revease22()其次，Revease3()最慢。可见.net framework中实现的ToCharArray()和Array.Revease()效率还是蛮高的^_^

但还有个奇怪的问题，就是Debug版本中的Revease1()和Revease21()运行起来要比Release版本中的要快，而Revease22()和Revease3()就比较正常。按说Release时做了更多的优化工作，运行起来更快才对，迷惑ing...，下面是测试结果：

Debug：

1 :  00:00:03.4375000
21:  00:00:06.1250000
22:  00:00:09.9687500
3 :  00:01:05.5468750

 

Release：

1 :  00:00:05.7812500
21:  00:00:07.4218750
22:  00:00:08.2500000
3 :  00:00:50.3593750

 

 

附1：Array.Revease()方法的源码(由Reflector.exe反汇编得到)：

[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
public static void Reverse(Array array)
...{
      if (array == null)
      ...{
            throw new ArgumentNullException("array");
      }
      Array.Reverse(array, array.GetLowerBound(0), array.Length);
}

[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
public static void Reverse(Array array, int index, int length)
...{
      int num1;
      int num2;
      if (array == null)
      ...{
            throw new ArgumentNullException("array");
      }
      if ((index < array.GetLowerBound(0)) || (length < 0))
      ...{
            throw new ArgumentOutOfRangeException((index < 0) ? "index" : "length", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
      }
      if ((array.Length - (index - array.GetLowerBound(0))) < length)
      ...{
            throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
      }
      if (array.Rank != 1)
      ...{
            throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
      }
      if (!Array.TrySZReverse(array, index, length))
      ...{
            num1 = index;
            num2 = (index + length) - 1;
            object[] objArray1 = array as object[];
            if (objArray1 == null)
            ...{
                  goto Label_00DE;
            }
            while (num1 < num2)
            ...{
                  object obj1 = objArray1[num1];
                  objArray1[num1] = objArray1[num2];
                  objArray1[num2] = obj1;
                  num1++;
                  num2--;
            }
      }
      return;
Label_00DE:
      if (num1 >= num2)
      ...{
            return;
      }
      object obj2 = array.GetValue(num1);
      array.SetValue(array.GetValue(num2), num1);
      array.SetValue(obj2, num2);
      num1++;
      num2--;
      goto Label_00DE;
}

 

 

附2：StringBuilder.Append()方法的源码(由Reflector.exe反汇编得到)：

public StringBuilder Append(string value)
...{
      if (value != null)
      ...{
            string text1 = this.m_StringValue;
            IntPtr ptr1 = Thread.InternalGetCurrentThread();
            if (this.m_currentThread != ptr1)
            ...{
                  text1 = string.GetStringForStringBuilder(text1, text1.Capacity);
            }
            int num1 = text1.Length;
            int num2 = num1 + value.Length;
            if (this.NeedsAllocation(text1, num2))
            ...{
                  string text2 = this.GetNewString(text1, num2);
                  text2.AppendInPlace(value, num1);
                  this.ReplaceString(ptr1, text2);
            }
            else
            ...{
                  text1.AppendInPlace(value, num1);
                  this.ReplaceString(ptr1, text1);
            }
      }
      return this;
}

private bool NeedsAllocation(string currentString, int requiredLength)
...{
      return (currentString.ArrayLength <= requiredLength);
} 

internal unsafe void AppendInPlace(string value, int currentLength)
...{
      int num1 = value.Length;
      int num2 = currentLength + num1;
      fixed (char* chRef1 = &this.m_firstChar)
      ...{
            fixed (char* chRef2 = &value.m_firstChar)
            ...{
                  string.wstrcpy(chRef1 + currentLength, chRef2, num1);
            }
            chRef1[num2] = '

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1357692