几种字符串反转方法效率比较

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

staticstringReverse1(stringoriginal)
...{
char[]arr=original.ToCharArray();
Array.Reverse(arr);
returnnewstring(arr);
}

staticstringRevease21(stringoriginal)
...{
intlength=original.Length;
char[]arr=newchar[length];
for(inti=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(inti=length&(~3);i<length;i++)
...{
arr[i]=original[length-i-1];
}
returnnewstring(arr);
}

staticstringRevease22(stringoriginal)
...{
intlength=original.Length;
char[]arr=newchar[length];
for(inti=0;i<length;i++)
...{
arr[i]=original[length-i-1];
}
returnnewstring(arr);
}

staticstringRevease3(stringoriginal)
...{
intlength=original.Length;
StringBuildersb=newStringBuilder(length);
for(inti=length-1;i>=0;i--)
sb.Append(original[i]);
returnsb.ToString();
}

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

　　　staticvoidMain(string[]args)
...{
stringtestString="测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转测试字符串反转";
DateTimestart=DateTime.Now;
for(inti=0;i<3000000;i++)
...{
strings=Reverse1(testString);
}
DateTimeend=DateTime.Now;
Console.WriteLine("1:"+(end-start));

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

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

start=DateTime.Now;
for(inti=0;i<3000000;i++)
...{
strings=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)]
publicstaticvoidReverse(Arrayarray)
...{
if(array==null)
...{
thrownewArgumentNullException("array");
}
Array.Reverse(array,array.GetLowerBound(0),array.Length);
}

[ReliabilityContract(Consistency.MayCorruptInstance,Cer.MayFail)]
publicstaticvoidReverse(Arrayarray,intindex,intlength)
...{
intnum1;
intnum2;
if(array==null)
...{
thrownewArgumentNullException("array");
}
if((index<array.GetLowerBound(0))||(length<0))
...{
thrownewArgumentOutOfRangeException((index<0)?"index":"length",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if((array.Length-(index-array.GetLowerBound(0)))<length)
...{
thrownewArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
}
if(array.Rank!=1)
...{
thrownewRankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
}
if(!Array.TrySZReverse(array,index,length))
...{
num1=index;
num2=(index+length)-1;
object[]objArray1=arrayasobject[];
if(objArray1==null)
...{
gotoLabel_00DE;
}
while(num1<num2)
...{
objectobj1=objArray1[num1];
objArray1[num1]=objArray1[num2];
objArray1[num2]=obj1;
num1++;
num2--;
}
}
return;
Label_00DE:
if(num1>=num2)
...{
return;
}
objectobj2=array.GetValue(num1);
array.SetValue(array.GetValue(num2),num1);
array.SetValue(obj2,num2);
num1++;
num2--;
gotoLabel_00DE;
}

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

publicStringBuilderAppend(stringvalue)
...{
if(value!=null)
...{
stringtext1=this.m_StringValue;
IntPtrptr1=Thread.InternalGetCurrentThread();
if(this.m_currentThread!=ptr1)
...{
text1=string.GetStringForStringBuilder(text1,text1.Capacity);
}
intnum1=text1.Length;
intnum2=num1+value.Length;
if(this.NeedsAllocation(text1,num2))
...{
stringtext2=this.GetNewString(text1,num2);
text2.AppendInPlace(value,num1);
this.ReplaceString(ptr1,text2);
}
else
...{
text1.AppendInPlace(value,num1);
this.ReplaceString(ptr1,text1);
}
}
returnthis;
}

privateboolNeedsAllocation(stringcurrentString,intrequiredLength)
...{
return(currentString.ArrayLength<=requiredLength);
}

internalunsafevoidAppendInPlace(stringvalue,intcurrentLength)
...{
intnum1=value.Length;
intnum2=currentLength+num1;
fixed(char*chRef1=&this.m_firstChar)
...{
fixed(char*chRef2=&value.m_firstChar)
...{
string.wstrcpy(chRef1+currentLength,chRef2,num1);
}
chRef1[num2]='