String.Join 和 StringBuilder：哪个更快？
98
- Hosam Aly
2
为了读者清晰起见，它是关于使用单个 StringBuilder 还是多个 string.Join，然后将它们连接起来的问题（n+1连接）. - Marc Gravell
2性能差异很快就会增加到几个数量级。如果你做了多个联接，通过切换到字符串构建器，你可以获得很多性能提升。 - jalf
5个回答
136
简短回答：取决于具体情况。
详细回答：如果你已经有一个字符串数组需要用定界符连接起来，String.Join是最快的方法。
String.Join可以查看所有字符串并计算出所需的精确长度，然后再复制所有数据。这意味着将不会存在额外的复制。唯一的缺点是它必须两次浏览这些字符串，这可能导致比必要更多次的内存缓存失效。
如果你事先没有字符串数组，使用StringBuilder 可能更快 - 但也有例外情况。如果使用StringBuilder意味着进行大量的复制，那么构建一个数组，然后调用String.Join可能会更快。
编辑：这是针对单个调用String.Join与大量调用StringBuilder.Append之间的比较。在原始问题中，我们有两个不同级别的String.Join调用，因此每个嵌套调用都会创建一个中间字符串。换句话说，这更加复杂，更难猜测。我想看到任何一种方式在典型数据的复杂度方面显著“胜出”都会感到惊讶。
编辑：当我回到家时，我将编写一个针对StringBuilder尽可能痛苦的基准测试。基本上，如果你有一个数组，其中每个元素大约是前一个元素的两倍大小，并且你做好了一切准备，应该能够在每个附加（元素而不是分隔符）时强制进行一次复制。这时它几乎和简单的字符串连接一样糟糕 - 但是String.Join没有问题。
- Jon Skeet
7
6即使我没有事先准备好字符串，使用String.Join似乎更快。请检查我的答案... - Hosam Aly
2这取决于数组是如何生成的，其大小等等。我很高兴给出一个相当明确的结论：“在<这个>情况下，String.Join 至少会和其他方法一样快” - 我不想反其道而行之。 - Jon Skeet
4特别是看一下马克的答案，在那里StringBuilder几乎超过了String.Join，生活就是这么复杂。 - Jon Skeet
2@BornToCode：你的意思是用原始字符串构建一个
StringBuilder，然后调用一次 Append 吗？是的，我希望 string.Join 在这方面胜出。 - Jon Skeet18[线程复活术]：目前（.NET 4.5）的
string.Join实现使用了StringBuilder。 - n0rd显示剩余2条评论
36
这是我的测试环境，为了简单起见使用 int[][]; 首先显示结果:
Join: 9420ms (chk: 210710000
OneBuilder: 9021ms (chk: 210710000
(双精度浮点数 double 结果的更新:)
Join: 11635ms (chk: 210710000
OneBuilder: 11385ms (chk: 210710000
(更新re 2048 * 64 * 150)
Join: 11620ms (chk: 206409600
OneBuilder: 11132ms (chk: 206409600
并启用了OptimizeForTesting：
Join: 11180ms (chk: 206409600
OneBuilder: 10784ms (chk: 206409600
速度更快，但并不是显著的；在控制台上以发布模式运行：
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
namespace ConsoleApplication2
{
class Program
{
static void Collect()
{
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
}
static void Main(string[] args)
{
const int ROWS = 500, COLS = 20, LOOPS = 2000;
int[][] data = new int[ROWS][];
Random rand = new Random(123456);
for (int row = 0; row < ROWS; row++)
{
int[] cells = new int[COLS];
for (int col = 0; col < COLS; col++)
{
cells[col] = rand.Next();
}
data[row] = cells;
}
Collect();
int chksum = 0;
Stopwatch watch = Stopwatch.StartNew();
for (int i = 0; i < LOOPS; i++)
{
chksum += Join(data).Length;
}
watch.Stop();
Console.WriteLine("Join: {0}ms (chk: {1}", watch.ElapsedMilliseconds, chksum);
Collect();
chksum = 0;
watch = Stopwatch.StartNew();
for (int i = 0; i < LOOPS; i++)
{
chksum += OneBuilder(data).Length;
}
watch.Stop();
Console.WriteLine("OneBuilder: {0}ms (chk: {1}", watch.ElapsedMilliseconds, chksum);
Console.WriteLine("done");
Console.ReadLine();
}
public static string Join(int[][] array)
{
return String.Join(Environment.NewLine,
Array.ConvertAll(array,
row => String.Join(",",
Array.ConvertAll(row, x => x.ToString()))));
}
public static string OneBuilder(IEnumerable<int[]> source)
{
StringBuilder sb = new StringBuilder();
bool firstRow = true;
foreach (var row in source)
{
if (firstRow)
{
firstRow = false;
}
else
{
sb.AppendLine();
}
if (row.Length > 0)
{
sb.Append(row[0]);
for (int i = 1; i < row.Length; i++)
{
sb.Append(',').Append(row[i]);
}
}
}
return sb.ToString();
}
}
}
- Marc Gravell
6
谢谢马克。大数组有什么结果？例如，我正在使用[2048][64]（约1 MB）。此外，如果您使用我正在使用的“OptimizeForTesting()”方法，您的结果是否有任何不同？ - Hosam Aly
非常感谢，马克。但我注意到这不是我们第一次在微基准测试中得到不同的结果。你有任何想法为什么会这样吗？ - Hosam Aly
2Karma？宇宙射线？谁知道…不过这表明了微观优化的危险，哈哈;-p - Marc Gravell
你使用的是 AMD 处理器吗？比如说，ET64？也许我的缓存内存太少了（512 KB）？或者 Windows Vista 上的 .NET 框架比 XP SP3 更优化？你怎么想？我真的很想知道这为什么会发生...... - Hosam Aly
XP SP3，x86，Intel Core2 Duo T7250@2GHz - Marc Gravell
24
我不这样认为。从Reflector中看，String.Join的实现非常优化。它还有一个额外的好处，就是提前知道要创建的字符串的总大小，因此不需要任何重新分配。
我创建了两个测试方法进行比较：
public static string TestStringJoin(double[][] array)
{
return String.Join(Environment.NewLine,
Array.ConvertAll(array,
row => String.Join(",",
Array.ConvertAll(row, x => x.ToString()))));
}
public static string TestStringBuilder(double[][] source)
{
// based on Marc Gravell's code
StringBuilder sb = new StringBuilder();
foreach (var row in source)
{
if (row.Length > 0)
{
sb.Append(row[0]);
for (int i = 1; i < row.Length; i++)
{
sb.Append(',').Append(row[i]);
}
}
}
return sb.ToString();
}
我已经运行了每个方法50次，传入一个大小为[2048][64]的数组。我对两个数组都这样做了；一个用零填充，另一个用随机值填充。在我的机器上（P4 3.0 GHz，单核，无HT，从CMD运行发布模式），我得到了以下结果：
// with zeros:
TestStringJoin took 00:00:02.2755280
TestStringBuilder took 00:00:02.3536041
// with random values:
TestStringJoin took 00:00:05.6412147
TestStringBuilder took 00:00:05.8394650
将数组大小增加到[2048][512]，同时将迭代次数减少到10，得到以下结果：
// with zeros:
TestStringJoin took 00:00:03.7146628
TestStringBuilder took 00:00:03.8886978
// with random values:
TestStringJoin took 00:00:09.4991765
TestStringBuilder took 00:00:09.3033365
String.Join稍微快一点（但差距非常小）。
这是我用于测试的代码：const int Iterations = 50;
const int Rows = 2048;
const int Cols = 64; // 512
static void Main()
{
OptimizeForTesting(); // set process priority to RealTime
// test 1: zeros
double[][] array = new double[Rows][];
for (int i = 0; i < array.Length; ++i)
array[i] = new double[Cols];
CompareMethods(array);
// test 2: random values
Random random = new Random();
double[] template = new double[Cols];
for (int i = 0; i < template.Length; ++i)
template[i] = random.NextDouble();
for (int i = 0; i < array.Length; ++i)
array[i] = template;
CompareMethods(array);
}
static void CompareMethods(double[][] array)
{
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 0; i < Iterations; ++i)
TestStringJoin(array);
stopwatch.Stop();
Console.WriteLine("TestStringJoin took " + stopwatch.Elapsed);
stopwatch.Reset(); stopwatch.Start();
for (int i = 0; i < Iterations; ++i)
TestStringBuilder(array);
stopwatch.Stop();
Console.WriteLine("TestStringBuilder took " + stopwatch.Elapsed);
}
static void OptimizeForTesting()
{
Thread.CurrentThread.Priority = ThreadPriority.Highest;
Process currentProcess = Process.GetCurrentProcess();
currentProcess.PriorityClass = ProcessPriorityClass.RealTime;
if (Environment.ProcessorCount > 1) {
// use last core only
currentProcess.ProcessorAffinity
= new IntPtr(1 << (Environment.ProcessorCount - 1));
}
}
- Hosam Aly
16
除非这个1%的差异在整个程序运行时间里变得显著，否则这看起来就是微小优化。我会写出最易读/易理解的代码，不必担心1%的性能差异。
- tvanfosson
3
1我认为使用String.Join更易懂，但这篇文章更多是一个有趣的挑战。 :) 在我的看法中，学习使用一些内置方法比手动操作更好，即使直觉可能表明相反也是如此。... - Hosam Aly
通常，很多人会建议使用 StringBuilder。即使 String.Join 被证明慢了 1%，很多人也不会考虑它，只是因为他们认为 StringBuilder 更快。 - Hosam Aly
我对调查没有任何问题，但既然你已经得到了答案，我不确定性能是否是最重要的问题。由于我想不出除了将其写入流之外构造CSV字符串的任何原因，所以我可能根本不会构造中间字符串。 - tvanfosson
-2
是的。如果你做超过几个连接，速度会快得多。
当你执行string.join时，运行时必须：
- 为结果字符串分配内存
- 将第一个字符串的内容复制到输出字符串的开头
- 将第二个字符串的内容复制到输出字符串的末尾。
如果您进行两个连接，则必须复制数据两次，等等。
StringBuilder分配了一个有剩余空间的缓冲区，因此可以追加数据而无需复制原始字符串。由于缓冲区中有剩余空间，因此追加的字符串可以直接写入缓冲区。 然后它只需要在最后一次复制整个字符串。
- jalf
2
1但是 String.Join 提前知道要分配多少空间，而 StringBuilder 不知道。请查看我的答案以获取更多澄清。 - Hosam Aly
@erikkallen：你可以在Reflector中查看String.Join的代码。http://www.red-gate.com/products/reflector/index.htm - Hosam Aly
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接