如何在 C# 中连接两个 arrays？

Question

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# 中的 Array Concatenation 帖子解释说：

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

对于大型 arrays 效率低下。这意味着Concat方法仅适用于中等大小的 arrays（最多 10000 个元素）。

Answer 1

var z = new int[x.Length + y.Length];
x.CopyTo(z, 0);
y.CopyTo(z, x.Length);

Answer 2

试试这个：

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

Answer 3

你可以写一个扩展方法：

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}

Answer 4

我选择了一个更通用的解决方案，它允许连接任意一组相同类型的一维数组。 （我一次连接 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}

Answer 5

就是这个：

using System.Linq;

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

// Concatenate array1 and array2.
var result1 = array1.Concat(array2);

Answer 6

我知道 OP 只是对性能有点好奇。 较大的数组可能会得到不同的结果（请参阅 @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();
        }
    }

}

结果是：

滚动你自己的胜利。

Answer 7

您可以在最后取消 ToArray() 调用。 在调用 Concat 之后，您是否需要将它作为数组？

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

因此，如果您只需要轻松地遍历两者，那么只需调用 Concat。

Answer 8

在Array.CopyTo上使用Buffer.BlockCopy更有效（更快），

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 耗时 3088 毫秒

CopyTo 耗时 1079 毫秒

块复制耗时 603 毫秒

如果我将测试数组更改为从 0 到 99 的两个序列，那么我会得到与此类似的结果，

Concat 耗时 45945 毫秒

CopyTo 耗时 2230 毫秒

块复制耗时 1689 毫秒

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

需要注意的是，如果性能无关紧要，或者迭代次数很少，请选择您认为最简单的方法。 Buffer.BlockCopy确实提供了一些超出此问题范围的类型转换实用程序。

Answer 9

小心使用Concat方法。 C# 中的后数组连接解释了：

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

对于大型阵列将效率低下。 这意味着Concat方法仅适用于中等大小的数组（最多 10000 个元素）。

Answer 10

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;
}

Answer 11

迟到的答案:-)。

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;
        }

    }

Answer 12

这是我的回答：

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

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

有关更多信息，请参阅这篇文章在我的博客。

Answer 13

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

在您的示例代码中，您可以省略 .ToArray() ，这会使其更有效率。

Answer 14

很抱歉恢复旧线程，但是如何：

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){...}子句foreach (var i in z){...}它们，该子句从yield return t;一次返回一个项目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>[] ）以使这些函数接受的不仅仅是数组。

希望这可以帮助。

Answer 15

你可以按照你提到的方式来做，或者如果你想获得真正的手册，你可以滚动你自己的循环：

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];

Answer 16

我找到了一个使用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();
}

使用 Lambda：

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

我已经根据个人喜好提供了两者。 性能明智的@Sergey Shteyn或@deepee1 的解决方案要快一些，Lambda 表达式是最慢的。 花费的时间取决于数组元素的类型，但除非有数百万次调用，否则方法之间没有显着差异。

Answer 17

您需要记住的是，在使用 LINQ 时，您正在使用延迟执行。 此处描述的其他方法都可以完美运行，但它们会立即执行。 此外，Concat() 函数可能以您自己无法完成的方式进行了优化（调用内部 API、操作系统调用等）。 无论如何，除非您真的需要尝试和优化，否则您目前正走在通往“万恶之源”的道路上；）

Answer 18

请尝试以下操作：

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

List<T> targetList = new List<T>(r1);
targetList.Concat(r2);
T[] targetArray = targetList.ToArray();

Answer 19

对于 int[] 你所做的对我来说看起来不错。 旁观者的回答也适用于List<int> 。

Answer 20

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。

请注意，该解决方案是简洁的，并且增加的通用性不会增加显着的运行时开销。

Answer 21

对于小于 10000 个元素的较小数组：

using System.Linq;

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

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

Answer 22

我认为一个列表将适用于此目的。

您可以创建这样的列表。

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

然后你可以很容易地使用 for each 循环来迭代任意数量的数组并将它们添加到列表中。

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

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

Answer 23

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

int[] z = x.Union(y).ToArray();

Answer 24

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