blocks|key|1403488|text|我不这样认为。通过反射器观察，String.Join的实现看起来非常优化。它还有一个额外的好处，那就是提前知道要创建的字符串的总大小，因此不需要任何重新分配。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1403489|我创建了两个测试方法来比较它们：|1403490|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%2B%2B)
++++++++++++{
++++++++++++++++sb.Append(',').Append(row[i]);
++++++++++++}
++++++++}
++++}
++++return+sb.ToString();
}|code-block|syntax|javascript|1403491|我将每个方法运行了50次，传入了一个大小为[2048][64]的数组。我对两个数组这样做:一个数组填充零，另一个数组填充随机值。我在我的机器上得到了以下结果(P4+3.0+GHz，单核，无HT，从CMD运行释放模式)：|1403492|//+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|1403493|将数组的大小增加到[2048][512]，同时将迭代次数减少到10，得到了以下结果：|1403494|//+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|1403495|结果是可重复的(几乎是；由不同的随机值引起的小波动)。显然，String.Join在大多数情况下都要快一点(尽管只有很小的差距)。|1403496|这是我用来测试的代码：|1403497|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;+%2B%2Bi)
++++++++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;+%2B%2Bi)
++++++++template[i]+=+random.NextDouble();

++++for+(int+i+=+0;+i+<+array.Length;+%2B%2Bi)
++++++++array[i]+=+template;

++++CompareMethods(array);
}

static+void+CompareMethods(double[][]+array)
{
++++Stopwatch+stopwatch+=+Stopwatch.StartNew();
++++for+(int+i+=+0;+i+<+Iterations;+%2B%2Bi)
++++++++TestStringJoin(array);
++++stopwatch.Stop();
++++Console.WriteLine("TestStringJoin++++took+"+%2B+stopwatch.Elapsed);

++++stopwatch.Reset();+stopwatch.Start();
++++for+(int+i+=+0;+i+<+Iterations;+%2B%2Bi)
++++++++TestStringBuilder(array);
++++stopwatch.Stop();
++++Console.WriteLine("TestStringBuilder+took+"+%2B+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));
++++}
}|1403498|entityMap^0|F|B|0|0|0|L|A|0|0|9|B|0|0|U|B|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|10|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|11|$]]

I don't think so. Looking through Reflector, the implementation of <code>String.Join</code> looks very optimized. It also has the added benefit of knowing the total size of the string to be created in advance, so it doesn't need any reallocation.

I have created two test methods to compare them:

<pre><code>public static string TestStringJoin(double[][] array)
{
 return String.Join(Environment.NewLine,
 Array.ConvertAll(array,
 row =&gt; String.Join(",",
 Array.ConvertAll(row, x =&gt; 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 &gt; 0)
 {
 sb.Append(row[0]);
 for (int i = 1; i &lt; row.Length; i++)
 {
 sb.Append(',').Append(row[i]);
 }
 }
 }
 return sb.ToString();
}
</code></pre>

I ran each method 50 times, passing in an array of size <code>[2048][64]</code>. I did this for two arrays; one filled with zeros and another filled with random values. I got the following results on my machine (P4 3.0 GHz, single-core, no HT, running Release mode from CMD):

<pre><code>// 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
</code></pre>

Increasing the size of the array to <code>[2048][512]</code>, while decreasing the number of iterations to 10 got me the following results:

<pre><code>// 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
</code></pre>

The results are repeatable (almost; with small fluctuations caused by different random values). Apparently <code>String.Join</code> is a little faster most of the time (although by a very small margin).

This is the code I used for testing:

<pre><code>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 &lt; 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 &lt; template.Length; ++i)
 template[i] = random.NextDouble();

 for (int i = 0; i &lt; array.Length; ++i)
 array[i] = template;

 CompareMethods(array);
}

static void CompareMethods(double[][] array)
{
 Stopwatch stopwatch = Stopwatch.StartNew();
 for (int i = 0; i &lt; Iterations; ++i)
 TestStringJoin(array);
 stopwatch.Stop();
 Console.WriteLine("TestStringJoin took " + stopwatch.Elapsed);

 stopwatch.Reset(); stopwatch.Start();
 for (int i = 0; i &lt; 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 &gt; 1) {
 // use last core only
 currentProcess.ProcessorAffinity
 = new IntPtr(1 &lt;&lt; (Environment.ProcessorCount - 1));
 }
}
</code></pre>

blocks|key|1403540|text|这是我的测试平台，为了简单起见，使用int[][]；结果优先：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1403541|Join:+9420ms+(chk:+210710000
OneBuilder:+9021ms+(chk:+210710000|code-block|syntax|javascript|1403542|(+double结果更新：)|1403543|Join:+11635ms+(chk:+210710000
OneBuilder:+11385ms+(chk:+210710000|1403544|(更新re+2048+*+64+*+150)|1403545|Join:+11620ms+(chk:+206409600
OneBuilder:+11132ms+(chk:+206409600|1403546|并且启用了OptimizeForTesting：|1403547|Join:+11180ms+(chk:+206409600
OneBuilder:+10784ms+(chk:+206409600|1403548|所以更快，但不是很快；rig+(在控制台运行，在发布模式下运行，等等)：|1403549|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%2B%2B)
++++++++++++{
++++++++++++++++int[]+cells+=+new+int[COLS];
++++++++++++++++for+(int+col+=+0;+col+<+COLS;+col%2B%2B)
++++++++++++++++{
++++++++++++++++++++cells[col]+=+rand.Next();
++++++++++++++++}
++++++++++++++++data[row]+=+cells;
++++++++++++}
++++++++++++Collect();
++++++++++++int+chksum+=+0;
++++++++++++Stopwatch+watch+=+Stopwatch.StartNew();
++++++++++++for+(int+i+=+0;+i+<+LOOPS;+i%2B%2B)
++++++++++++{
++++++++++++++++chksum+%2B=+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%2B%2B)
++++++++++++{
++++++++++++++++chksum+%2B=+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%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++sb.Append(',').Append(row[i]);
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++++++return+sb.ToString();
++++++++}
++++}
}|1403550|entityMap^0|I|7|0|0|2|6|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|10|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|11|$]]

Here's my test rig, using <code>int[][]</code> for simplicity; results first:

<pre><code>Join: 9420ms (chk: 210710000
OneBuilder: 9021ms (chk: 210710000
</code></pre>

(update for <code>double</code> results:)

<pre><code>Join: 11635ms (chk: 210710000
OneBuilder: 11385ms (chk: 210710000
</code></pre>

(update re 2048 * 64 * 150)

<pre><code>Join: 11620ms (chk: 206409600
OneBuilder: 11132ms (chk: 206409600
</code></pre>

and with OptimizeForTesting enabled:

<pre><code>Join: 11180ms (chk: 206409600
OneBuilder: 10784ms (chk: 206409600
</code></pre>

So faster, but not massively so; rig (run at console, in release mode, etc):

<pre><code>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 &lt; ROWS; row++)
 {
 int[] cells = new int[COLS];
 for (int col = 0; col &lt; COLS; col++)
 {
 cells[col] = rand.Next();
 }
 data[row] = cells;
 }
 Collect();
 int chksum = 0;
 Stopwatch watch = Stopwatch.StartNew();
 for (int i = 0; i &lt; 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 &lt; 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 =&gt; String.Join(",",
 Array.ConvertAll(row, x =&gt; x.ToString()))));
 }
 public static string OneBuilder(IEnumerable&lt;int[]&gt; source)
 {
 StringBuilder sb = new StringBuilder();
 bool firstRow = true;
 foreach (var row in source)
 {
 if (firstRow)
 {
 firstRow = false;
 }
 else
 {
 sb.AppendLine();
 }
 if (row.Length &gt; 0)
 {
 sb.Append(row[0]);
 for (int i = 1; i &lt; row.Length; i++)
 {
 sb.Append(',').Append(row[i]);
 }
 }
 }
 return sb.ToString();
 }
 }
}
</code></pre>

blocks|key|1403600|text|除非1%25的差异在整个程序的运行时间方面变得很重要，否则这看起来就像是微优化。我会写出最具可读性/可理解性的代码，不用担心1%25的性能差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1403601|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Unless the 1% difference turns into something significant in terms of the time the entire program takes to run, this looks like micro-optimization. I'd write the code that's the most readable/understandable and not worry about the 1% performance difference.

In a <a href="https://stackoverflow.com/questions/585215/can-i-rewrite-this-more-elegantly-using-linq">previous question</a> about formatting a <code>double[][]</code> to CSV format, <a href="https://stackoverflow.com/questions/585215/can-i-rewrite-this-more-elegantly-using-linq/585223#585223">it was suggested</a> that using <code>StringBuilder</code> would be faster than <code>String.Join</code>. Is this true?

String.Join vs. StringBuilder: which is faster?

在关于将double[][]格式化为CSV格式的中，表示使用StringBuilder将比String.Join更快。这是真的吗？

问String.Join和StringBuilder:哪个更快？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问String.Join和StringBuilder:哪个更快？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问String.Join和StringBuilder:哪个更快？
EN