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个元素)。
当前回答
我发现了一个优雅的一行解决方案，使用LINQ或Lambda表达式，两者工作相同(当程序编译时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表达式是最慢的。所花费的时间取决于数组元素的类型，但除非有数百万次调用，否则方法之间没有显著差异。
其他回答
很抱歉要恢复一个旧的帖子，但是这样如何:
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>(因此参数T[]将成为params IEnumerable<T>[])，以使这些函数不仅仅接受数组。
希望这能有所帮助。
我发现了一个优雅的一行解决方案，使用LINQ或Lambda表达式，两者工作相同(当程序编译时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表达式是最慢的。所花费的时间取决于数组元素的类型，但除非有数百万次调用，否则方法之间没有显著差异。
试试下面的方法:
T[] r1 = new T[size1];
T[] r2 = new T[size2];
List<T> targetList = new List<T>(r1);
targetList.Concat(r2);
T[] targetArray = targetList.ToArray();
迟回答:-)。
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;
}
}
你可以写一个扩展方法:
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}
