如何在 C # 中连接两个数组？

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方法。 < a href = “ https://stackoverflow. com/questions/2788636/Array-Concatenation-in-c-Sharp”> Array Concatenation in C # 后面解释说:

var z = x.Concat(y).ToArray();

这意味着 Concat方法只适用于中等大小的数组(最多10000个元素)。

441302 次浏览
小开

您可以取消ToArray()调用结束。是否有理由在调用Concat之后需要它是一个数组?

调用Concat在两个数组上创建迭代器。它不会创建一个新的数组，所以您没有为一个新数组使用更多的内存。当你调用ToArray时，你实际上创建了一个新数组，并为新数组占用内存。

因此，如果你只是需要轻松迭代，然后调用Concat。

小开

试试这个:

List<int> list = new List<int>();
list.AddRange(x);
list.AddRange(y);
int[] z = list.ToArray();
小开

在我看来，你所做的一切还不错。astander的答案也适用于List<int>。

小开
最佳答案 
var z = new int[x.Length + y.Length];
x.CopyTo(z, 0);
y.CopyTo(z, x.Length);
小开

你可以按照你提到的方式来做，或者如果你想要真正的手动操作，你可以滚动你自己的循环:

string[] one = new string[] { "a", "b" };
string[] two = new string[] { "c", "d" };
string[] three;


three = new string[one.Length + two.Length];


int idx = 0;


for (int i = 0; i < one.Length; i++)
three[idx++] = one[i];
for (int j = 0; j < two.Length; j++)
three[idx++] = two[j];
小开

你可以写一个扩展方法:

public static T[] Concat<T>(this T[] x, T[] y)
{
if (x == null) throw new ArgumentNullException("x");
if (y == null) throw new ArgumentNullException("y");
int oldLen = x.Length;
Array.Resize<T>(ref x, x.Length + y.Length);
Array.Copy(y, 0, x, oldLen, y.Length);
return x;
}

然后:

int[] x = {1,2,3}, y = {4,5};
int[] z = x.Concat(y); // {1,2,3,4,5}
小开

就RAM(和CPU)而言，保存组合数组的最有效结构是一个特殊的类，它实现IEnumerable(或者如果您希望从array派生)，并在内部链接到原始数组以读取值。AFAIK Concat就是这么做的。

在示例代码中，您可以省略. toarray()，这将使它更有效。

小开
你需要记住的是，当你使用LINQ时，你是在利用延迟执行。这里描述的其他方法都工作得很好，但它们会立即执行。此外，Concat()函数可能以您自己无法实现的方式进行优化(调用内部API, OS调用等)。 无论如何，除非你真的需要尝试和优化，否则你目前正处于通往“万恶之源”的道路上;)

小开

我选择了一种更通用的解决方案，它允许连接同一类型的一维数组的任意集。(我一次连接了3个+。)

我的函数:

public static T[] ConcatArrays<T>(params T[][] list)
{
var result = new T[list.Sum(a => a.Length)];
int offset = 0;
for (int x = 0; x < list.Length; x++)
{
list[x].CopyTo(result, offset);
offset += list[x].Length;
}
return result;
}

和用法:

int[] a = new int[] { 1, 2, 3 };
int[] b = new int[] { 4, 5, 6 };
int[] c = new int[] { 7, 8 };
var y = ConcatArrays(a, b, c); //Results in int[] {1,2,3,4,5,6,7,8}
小开 
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;
}
小开

我发现了一个优雅的一行解决方案，使用LINQ或λ表达式，两者工作相同(当程序编译时LINQ转换为Lambda)。该解决方案适用于任何数组类型和任何数量的数组。

使用LINQ:

public static T[] ConcatArraysLinq<T>(params T[][] arrays)
{
return (from array in arrays
from arr in array
select arr).ToArray();
}

使用λ:

public static T[] ConcatArraysLambda<T>(params T[][] arrays)
{
return arrays.SelectMany(array => array.Select(arr => arr)).ToArray();
}

这两种我都提供了。性能方面@Sergey Shteyn的或@deepee1的解决方案稍快，Lambda表达式是最慢的。所花费的时间取决于数组元素的类型，但除非有数百万次调用，否则方法之间没有显著差异。

小开

就是这样:

using System.Linq;


int[] array1 = { 1, 3, 5 };
int[] array2 = { 0, 2, 4 };


// Concatenate array1 and array2.
int[] result1 = array1.Concat(array2).ToArray();
小开

试试下面的方法:

T[] r1 = new T[size1];
T[] r2 = new T[size2];


List<T> targetList = new List<T>(r1);
targetList.Concat(r2);
T[] targetArray = targetList.ToArray();
小开 
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。

注意，这个解决方案很简洁，并且添加的通用性不会增加大量的运行时开销。

小开

对于较小的数组<10000个元素:

using System.Linq;


int firstArray = {5,4,2};
int secondArray = {3,2,1};


int[] result = firstArray.ToList().Concat(secondArray.ToList()).toArray();
小开

我知道上级只是对表现有点好奇。较大的数组可能会得到不同的结果(参见@kurdishTree)。这通常并不重要(@jordan.peoples)。尽管如此，我还是很好奇，因此失去了理智(就像@TigerShark解释的那样)....我的意思是，我根据原始问题....编写了一个简单的测试以及所有的答案....

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace concat
{
class Program
{
static void Main(string[] args)
{
int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };




int itter = 50000;
Console.WriteLine("test iterations: {0}", itter);


DateTime startTest = DateTime.Now;
for(int  i = 0; i < itter; i++)
{
int[] z;
z = x.Concat(y).ToArray();
}
Console.WriteLine ("Concat Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks );


startTest = DateTime.Now;
for(int  i = 0; i < itter; i++)
{
var vz = new int[x.Length + y.Length];
x.CopyTo(vz, 0);
y.CopyTo(vz, x.Length);
}
Console.WriteLine ("CopyTo Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks );


startTest = DateTime.Now;
for(int  i = 0; i < itter; i++)
{
List<int> list = new List<int>();
list.AddRange(x);
list.AddRange(y);
int[] z = list.ToArray();
}
Console.WriteLine("list.AddRange Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
int[] z = Methods.Concat(x, y);
}
Console.WriteLine("Concat(x, y) Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
int[] z = Methods.ConcatArrays(x, y);
}
Console.WriteLine("ConcatArrays Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
int[] z = Methods.SSConcat(x, y);
}
Console.WriteLine("SSConcat Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int k = 0; k < itter; k++)
{
int[] three = new int[x.Length + y.Length];


int idx = 0;


for (int i = 0; i < x.Length; i++)
three[idx++] = x[i];
for (int j = 0; j < y.Length; j++)
three[idx++] = y[j];
}
Console.WriteLine("Roll your own Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);




startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
int[] z = Methods.ConcatArraysLinq(x, y);
}
Console.WriteLine("ConcatArraysLinq Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
int[] z = Methods.ConcatArraysLambda(x, y);
}
Console.WriteLine("ConcatArraysLambda Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
List<int> targetList = new List<int>(x);
targetList.Concat(y);
}
Console.WriteLine("targetList.Concat(y) Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


startTest = DateTime.Now;
for (int i = 0; i < itter; i++)
{
int[] result = x.ToList().Concat(y.ToList()).ToArray();
}
Console.WriteLine("x.ToList().Concat(y.ToList()).ToArray() Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);
}
}
static class Methods
{
public static T[] Concat<T>(this T[] x, T[] y)
{
if (x == null) throw new ArgumentNullException("x");
if (y == null) throw new ArgumentNullException("y");
int oldLen = x.Length;
Array.Resize<T>(ref x, x.Length + y.Length);
Array.Copy(y, 0, x, oldLen, y.Length);
return x;
}


public static T[] ConcatArrays<T>(params T[][] list)
{
var result = new T[list.Sum(a => a.Length)];
int offset = 0;
for (int x = 0; x < list.Length; x++)
{
list[x].CopyTo(result, offset);
offset += list[x].Length;
}
return result;
}




public static T[] SSConcat<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;
}


public static T[] ConcatArraysLinq<T>(params T[][] arrays)
{
return (from array in arrays
from arr in array
select arr).ToArray();
}


public static T[] ConcatArraysLambda<T>(params T[][] arrays)
{
return arrays.SelectMany(array => array.Select(arr => arr)).ToArray();
}
}


}

结果是:

enter image description here

滚你自己赢的。

小开

使用Buffer.BlockCopy比使用Array.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));

我写了一个简单的测试程序，以发布模式编译，在没有调试器的情况下在我的机器上运行。

对于问题中例子的10,000,000次迭代

Concat花了3088ms

CopyTo耗时1079ms

BlockCopy耗时603毫秒

如果我将测试数组改变为从0到99的两个序列，那么我会得到类似于这样的结果，

Concat花了45945ms

CopyTo花了2230ms

BlockCopy耗时1689ms

从这些结果中，我可以断言CopyTo和BlockCopy方法明显比Concat更有效，此外，如果性能是一个目标，BlockCopy比CopyTo更有价值。

要注意这个答案，如果性能不重要，或者迭代很少，请选择您认为最简单的方法。Buffer.BlockCopy确实提供了一些超出这个问题范围的类型转换实用程序。

小开

concat (y).ToArray();

小开

很抱歉要恢复一个旧的帖子，但是这样如何:

static IEnumerable<T> Merge<T>(params T[][] arrays)
{
var merged = arrays.SelectMany(arr => arr);


foreach (var t in merged)
yield return t;
}

然后在代码中:

int[] x={1, 2, 3};
int[] y={4, 5, 6};


var z=Merge(x, y);  // 'z' is IEnumerable<T>


var za=z.ToArray(); // 'za' is int[]

在调用.ToArray()， .ToList()或.ToDictionary(...)之前，内存没有分配，你可以自由地“构建你的查询”，要么调用这三个中的一个来执行它，要么简单地使用foreach (var i in z){...}子句来执行它们，它每次从上面的yield return t;返回一个项…

以上函数可以做成一个扩展，如下所示:

static IEnumerable<T> Merge<T>(this T[] array1, T[] array2)
{
var merged = array1.Concat(array2);


foreach (var t in merged)
yield return t;
}

所以在代码中，你可以这样做:

int[] x1={1, 2, 3};
int[] x2={4, 5, 6};
int[] x3={7, 8};


var z=x1.Merge(x2).Merge(x3);   // 'z' is IEnumerable<T>


var za=z.ToArray(); // 'za' is int[]

其余部分和以前一样。

对此的另一个改进是将T[]更改为IEnumerable<T>(因此params T[][]将成为params IEnumerable<T>[])，以使这些函数不仅仅接受数组。

希望这能有所帮助。

小开

迟回答:-)。

public static class ArrayExtention
{


public static T[] Concatenate<T>(this T[] array1, T[] array2)
{
T[] result = new T[array1.Length + array2.Length];
array1.CopyTo(result, 0);
array2.CopyTo(result, array1.Length);
return result;
}


}
小开

以下是我的回答:

int[] z = new List<string>()
.Concat(a)
.Concat(b)
.Concat(c)
.ToArray();

此方法可用于初始化级别，例如定义静态数组的静态连接:

public static int[] a = new int [] { 1, 2, 3, 4, 5 };
public static int[] b = new int [] { 6, 7, 8 };
public static int[] c = new int [] { 9, 10 };


public static int[] z = new List<string>()
.Concat(a)
.Concat(b)
.Concat(c)
.ToArray();

但是，你需要注意两点:

  • Concat方法在两个数组上创建迭代器:它不创建新数组，因此在使用内存方面是有效的:然而，随后的ToArray将否定这种优势，因为它实际上会创建一个新数组，并为新数组占用内存。
  • 正如@Jodrell所说，Concat对于大型数组来说是相当低效的:它只应该用于中型数组。

如果必须以性能为目标，可以使用以下方法:

/// <summary>
/// Concatenates two or more arrays into a single one.
/// </summary>
public static T[] Concat<T>(params T[][] arrays)
{
// return (from array in arrays from arr in array select arr).ToArray();


var result = new T[arrays.Sum(a => a.Length)];
int offset = 0;
for (int x = 0; x < arrays.Length; x++)
{
arrays[x].CopyTo(result, offset);
offset += arrays[x].Length;
}
return result;
}

或者(对于喜欢说俏皮话的人):

int[] z = (from arrays in new[] { a, b, c } from arr in arrays select arr).ToArray();

虽然后一种方法要优雅得多，但前一种方法的性能肯定更好。

更多信息，请参考我博客上的这篇文章。

小开 
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]);
}
小开

我认为列出一份清单很适合这个目的。

你可以创建一个这样的列表。

List<int> Items = new List<int>();

然后你可以很容易地使用for每个循环遍历任意数量的数组并将它们添加到列表中。

foreach (int i in nameOfArray)
{
Items.Add(i);
}

如果使用列表，则可以消除出界异常的问题。列表可以用于与数组相同的所有功能。唯一有意义的区别是缺少项目数量的硬性限制。


提交答案