int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };
int[] z = // your answer here...
Debug.Assert(z.SequenceEqual(new int[] { 1, 2, 3, 4, 5 }));
现在我用
int[] z = x.Concat(y).ToArray();
有没有更简单或更有效的方法?
使用Concat方法时要小心。c#中的数组拼接这篇文章解释了:
var z = x.Concat(y).ToArray();
对于大型阵列来说效率很低。这意味着Concat方法仅适用于中型数组(最多10000个元素)。
当前回答
static class Extensions
{
public static T[] Concat<T>(this T[] array1, params T[] array2) => ConcatArray(array1, array2);
public static T[] ConcatArray<T>(params T[][] arrays)
{
int l, i;
for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++);
var a = new T[l];
for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++)
arrays[i].CopyTo(a, l);
return a;
}
}
我认为上面的解决方案比我在这里看到的其他解决方案更普遍和更轻。它更通用，因为它不限制只对两个数组进行连接，也更轻便，因为它不使用LINQ和List。
注意，这个解决方案很简洁，并且添加的通用性不会增加大量的运行时开销。
其他回答
int[] scores = { 100, 90, 90, 80, 75, 60 };
int[] alice = { 50, 65, 77, 90, 102 };
int[] scoreBoard = new int[scores.Length + alice.Length];
int j = 0;
for (int i=0;i<(scores.Length+alice.Length);i++) // to combine two arrays
{
if(i<scores.Length)
{
scoreBoard[i] = scores[i];
}
else
{
scoreBoard[i] = alice[j];
j = j + 1;
}
}
for (int l = 0; l < (scores.Length + alice.Length); l++)
{
Console.WriteLine(scoreBoard[l]);
}
在我看来，你所做的一切还不错。astander的答案也适用于List<int>。
static class Extensions
{
public static T[] Concat<T>(this T[] array1, params T[] array2) => ConcatArray(array1, array2);
public static T[] ConcatArray<T>(params T[][] arrays)
{
int l, i;
for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++);
var a = new T[l];
for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++)
arrays[i].CopyTo(a, l);
return a;
}
}
我认为上面的解决方案比我在这里看到的其他解决方案更普遍和更轻。它更通用，因为它不限制只对两个数组进行连接，也更轻便，因为它不使用LINQ和List。
注意，这个解决方案很简洁，并且添加的通用性不会增加大量的运行时开销。
使用Buffer更有效(更快)。对数组进行BlockCopy。CopyTo,
int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };
int[] z = new int[x.Length + y.Length];
var byteIndex = x.Length * sizeof(int);
Buffer.BlockCopy(x, 0, z, 0, byteIndex);
Buffer.BlockCopy(y, 0, z, byteIndex, y.Length * sizeof(int));
我写了一个简单的测试程序来“加热Jitter”，在发布模式下编译，并在没有调试器的情况下在我的机器上运行。
对于问题中例子的10,000,000次迭代
Concat花了3088ms CopyTo耗时1079ms BlockCopy耗时603毫秒
如果我将测试数组改变为从0到99的两个序列，那么我会得到类似于这样的结果，
Concat花了45945ms CopyTo花了2230ms BlockCopy耗时1689ms
从这些结果中，我可以断言CopyTo和BlockCopy方法明显比Concat更有效，此外，如果性能是一个目标，BlockCopy比CopyTo更有价值。
要注意这个答案，如果性能不重要，或者迭代很少，请选择您认为最简单的方法。缓冲区。BlockCopy确实提供了一些超出这个问题范围的类型转换实用程序。
public static T[] Concat<T>(this T[] first, params T[][] arrays)
{
int length = first.Length;
foreach (T[] array in arrays)
{
length += array.Length;
}
T[] result = new T[length];
length = first.Length;
Array.Copy(first, 0, result, 0, first.Length);
foreach (T[] array in arrays)
{
Array.Copy(array, 0, result, length, array.Length);
length += array.Length;
}
return result;
}
