String.Join 与 StringBuilder：哪个更快？

Posted 2023-02-22

【中文标题】String.Join 与 StringBuilder：哪个更快？

【英文标题】：String.Join vs. StringBuilder: which is faster?

【发布时间】：2010-10-09 19:24:54

【问题描述】：

在previous question 中关于将double[][] 格式化为CSV 格式，it was suggested 使用StringBuilder 会比String.Join 更快。这是真的吗？

【问题讨论】：

为了读者清楚，这是关于使用 single StringBuilder，与 multiple string.Join，然后加入（n+1 个联接）

性能上的差异很快就达到了几个数量级。如果您执行的连接数不只少数，则可以通过切换到 stringbuilder

获得很多的性能

【参考方案1】：

简短回答：视情况而定。

长答案：如果您已经有要连接在一起的字符串数组（带有分隔符），String.Join 是最快的方法。

String.Join 可以查看所有字符串以计算出所需的确切长度，然后再次复制所有数据。这意味着将没有涉及额外的复制。 唯一的缺点是它必须遍历字符串两次，这意味着可能会比必要的次数更多地破坏内存缓存。

如果您没有事先将字符串作为数组，则可能使用StringBuilder 会更快-但在某些情况下它不是。如果使用StringBuilder 意味着要进行大量复制，那么构建一个数组然后调用String.Join 可能会更快。

编辑：这是对String.Join 的一次调用与对StringBuilder.Append 的一堆调用。在最初的问题中，我们有两个不同级别的 String.Join 调用，因此每个嵌套调用都会创建一个中间字符串。换句话说，它更复杂，更难猜测。我会惊讶地看到任何一种方式在典型数据上都显着（在复杂性方面）“获胜”。

编辑：当我在家时，我会写一个对StringBuilder 来说尽可能痛苦的基准。基本上，如果你有一个数组，其中每个元素的大小大约是前一个元素的两倍，并且你得到它恰到好处，你应该能够为每个追加（元素，而不是分隔符，尽管需要也要考虑在内）。在这一点上，它几乎和简单的字符串连接一样糟糕 - 但String.Join 不会有任何问题。

【讨论】：

即使我事先没有字符串，使用 String.Join 似乎也更快。请检查我的答案...

这将取决于数组的生成方式、大小等。我很高兴给出一个相当明确的“在 情况下 String.Join 至少会一样快” -我不想做相反的事情。

（特别是看看 Marc 的回答，StringBuilder 击败了 String.Join，差不多。生活很复杂。）

@BornToCode：你的意思是用原始字符串构造一个StringBuilder，然后调用一次Append？是的，我希望string.Join 在那里获胜。

[Thread necromancy]：string.Join 的当前 (.NET 4.5) 实现使用 StringBuilder。

【参考方案2】：

这是我的测试台，为简单起见使用int[][]；结果优先：

Join: 9420ms (chk: 210710000
OneBuilder: 9021ms (chk: 210710000

（double 结果更新：）

Join: 11635ms (chk: 210710000
OneBuilder: 11385ms (chk: 210710000

（更新 2048 * 64 * 150）

Join: 11620ms (chk: 206409600
OneBuilder: 11132ms (chk: 206409600

并启用 OptimizeForTesting：

Join: 11180ms (chk: 206409600
OneBuilder: 10784ms (chk: 206409600

速度如此之快，但规模不大； rig（在控制台运行，在发布模式等）：

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: 0ms (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: 0ms (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();
        
    

【讨论】：

谢谢马克。对于更大的阵列，您会得到什么？例如，我正在使用 [2048][64]（大约 1 MB）。如果您使用我正在使用的OptimizeForTesting() 方法，您的结果也会有所不同吗？

非常感谢马克。但我注意到这不是我们第一次得到不同的微基准测试结果。你知道为什么会这样吗？

业力？宇宙射线？谁知道……不过，它显示了微优化的危险；-p

您使用的是 AMD 处理器吗？ ET64？也许我的缓存内存太少（512 KB）？或者，Windows Vista 上的 .NET 框架可能比 XP SP3 更优化？你怎么看？我真的很想知道为什么会这样……

XP SP3、x86、Intel Core2 Duo T7250@2GHz

【参考方案3】：

我不这么认为。通过 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 运行 Release 模式）：

// 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));
    

【参考方案4】：

除非 1% 的差异在整个程序运行所需的时间方面变得显着，否则这看起来像是微优化。我会编写最易读/易于理解的代码，而不用担心 1% 的性能差异。

【讨论】：

我相信 String.Join 更容易理解，但这篇文章更像是一个有趣的挑战。 :) 了解使用一些内置方法可能比手动操作更好，即使直觉可能暗示其他方法也很有用（恕我直言）。 ...

... 通常，很多人会建议使用 StringBuilder。即使 String.Join 被证明慢了 1%，很多人也不会想到，因为他们认为 StringBuilder 更快。

我对调查没有任何问题，但现在你有了答案，我不确定性能是最重要的问题。由于除了将其写入流之外，我可以想到任何在 CSV 中构造字符串的理由，因此我可能根本不会构造中间字符串。

【参考方案5】：

是的。如果您执行的连接超过几个，它会快很多。

当您执行 string.join 时，运行时必须：

为结果字符串分配内存 将第一个字符串的内容复制到输出字符串的开头 将第二个字符串的内容复制到输出字符串的末尾。

如果你做两个连接，它必须复制数据两次，依此类推。

StringBuilder 为一个缓冲区分配空间，因此无需复制原始字符串即可追加数据。由于缓冲区中有剩余空间，附加的字符串可以直接写入缓冲区。 然后它只需要在最后复制整个字符串一次。

【讨论】：

但是 String.Join 事先知道要分配多少，而 StringBuilder 不知道。请参阅我的回答以获得更多说明。

@erikkallen：您可以在 Reflector 中查看 String.Join 的代码。 red-gate.com/products/reflector/index.htm