合并两个 arrays 到 .NET

Question

.NET 2.0 中是否有一个内置的 function 将两个 arrays 合并到一个数组中？

arrays 都是同一类型。 我从我的代码库中广泛使用的 function 中获取这些 arrays，并且无法修改 function 以返回不同格式的数据。

如果可能的话，我希望避免编写自己的 function 来完成此操作。

Answer 1

在 C# 3.0 中，您可以使用 LINQ 的Concat方法轻松完成此操作：

int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = front.Concat(back).ToArray();

在 C# 2.0 中你没有这样直接的方式，但 Array.Copy 可能是最好的解决方案：

int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };

int[] combined = new int[front.Length + back.Length];
Array.Copy(front, combined, front.Length);
Array.Copy(back, 0, combined, front.Length, back.Length);

这可以很容易地用于实现您自己的Concat版本。

Answer 2

如果您可以操作其中一个数组，则可以在执行复制之前调整其大小：

T[] array1 = getOneArray();
T[] array2 = getAnotherArray();
int array1OriginalLength = array1.Length;
Array.Resize<T>(ref array1, array1OriginalLength + array2.Length);
Array.Copy(array2, 0, array1, array1OriginalLength, array2.Length);

否则，您可以创建一个新数组

T[] array1 = getOneArray();
T[] array2 = getAnotherArray();
T[] newArray = new T[array1.Length + array2.Length];
Array.Copy(array1, newArray, array1.Length);
Array.Copy(array2, 0, newArray, array1.Length, array2.Length);

有关 MSDN 上可用 Array 方法的更多信息。

Answer 3

使用LINQ ：

var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = arr1.Union(arr2).ToArray();

请记住，这将删除重复项。 如果要保留重复项，请使用 Concat。

Answer 4

如果您不想删除重复项，请尝试此操作

使用 LINQ：

var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = arr1.Concat(arr2).ToArray();

Answer 5

首先，确保你问自己这个问题“我真的应该在这里使用数组吗”？

除非你正在构建一些速度至关重要的东西，否则像List<int>这样的类型化 List 可能是要走的路。 我唯一一次使用数组是在通过网络发送内容时使用字节数组。 除此之外，我从不碰它们。

Answer 6

使用LINQ会更容易：

var array = new string[] { "test" }.ToList();
var array1 = new string[] { "test" }.ToList();
array.AddRange(array1);
var result = array.ToArray();

首先将数组转换为列表并合并它们...之后只需将列表转换回数组:)

Answer 7

我认为您可以为此使用Array.Copy 。 它需要一个源索引和目标索引，因此您应该能够将一个数组附加到另​​一个数组。 如果您需要做的不仅仅是将一个附加到另一个更复杂，那么这可能不是适合您的工具。

Answer 8

每个人都已经发表了意见，但我认为这比“用作扩展方法”方法更具可读性：

var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = Queryable.Concat(arr1, arr2).ToArray();

但是，它只能在将 2 个数组放在一起时使用。

Answer 9

这就是我想出的。 适用于可变数量的数组。

public static T[] ConcatArrays<T>(params T[][] args)
    {
        if (args == null)
            throw new ArgumentNullException();

        var offset = 0;
        var newLength = args.Sum(arr => arr.Length); 
        var newArray = new T[newLength];

        foreach (var arr in args)
        {
            Buffer.BlockCopy(arr, 0, newArray, offset, arr.Length);
            offset += arr.Length;
        }

        return newArray;
    }

...

var header = new byte[] { 0, 1, 2};
var data = new byte[] { 3, 4, 5, 6 };
var checksum = new byte[] {7, 0};
var newArray = ConcatArrays(header, data, checksum);
//output byte[9] { 0, 1, 2, 3, 4, 5, 6, 7, 0 }

Answer 10

假设目标数组有足够的空间， Array.Copy()将起作用。 您也可以尝试使用List<T>及其.AddRange()方法。

Answer 11

就个人而言，我更喜欢我自己的语言扩展，我可以随意添加或删除它以进行快速原型设计。

以下是字符串的示例。

//resides in IEnumerableStringExtensions.cs
public static class IEnumerableStringExtensions
{
   public static IEnumerable<string> Append(this string[] arrayInitial, string[] arrayToAppend)
   {
       string[] ret = new string[arrayInitial.Length + arrayToAppend.Length];
       arrayInitial.CopyTo(ret, 0);
       arrayToAppend.CopyTo(ret, arrayInitial.Length);

       return ret;
   }
}

它比 LINQ 和 Concat 快得多。 更快的是，使用自定义IEnumerable类型包装器，它存储传递数组的引用/指针，并允许循环遍历整个集合，就好像它是一个普通数组一样。 （在 HPC、图形处理、图形渲染中很有用...）

您的代码：

var someStringArray = new[]{"a", "b", "c"};
var someStringArray2 = new[]{"d", "e", "f"};
someStringArray.Append(someStringArray2 ); //contains a,b,c,d,e,f

有关完整代码和泛型版本，请参见： https : //gist.github.com/lsauer/7919764

注意：这将返回一个未扩展的 IEnumerable 对象。 返回扩展对象有点慢。

我从 2002 年开始编译这样的扩展，很多功劳都给了 CodeProject 和“Stackoverflow”上有帮助的人。 我将很快发布这些并将链接放在这里。

Answer 12

只是将它标记为一个选项：如果您正在使用的数组是原始类型 – Boolean (bool)、Char、SByte、Byte、Int16 (short)、UInt16、Int32 (int)、UInt32、Int64 (long )、UInt64、IntPtr、UIntPtr、Single 或 Double – 那么您可以（或应该？）尝试使用Buffer.BlockCopy 。 根据Buffer类的 MSDN 页面：

与System.Array类中的类似方法相比，此类为操作基本类型提供了更好的性能。

使用@OwenP答案中的 C# 2.0 示例作为起点，它将按如下方式工作：

int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };

int[] combined = new int[front.Length + back.Length];
Buffer.BlockCopy(front, 0, combined, 0, front.Length);
Buffer.BlockCopy(back, 0, combined, front.Length, back.Length);

Buffer.BlockCopy和@OwenP 使用的Array.Copy之间的语法几乎没有任何区别，但这应该更快（即使只有一点点）。

Answer 13

如果其他人正在寻找如何合并两个图像字节数组：

        private void LoadImage()
        {
            string src = string.empty;
            byte[] mergedImageData = new byte[0];

            mergedImageData = MergeTwoImageByteArrays(watermarkByteArray, backgroundImageByteArray);
            src = "data:image/png;base64," + Convert.ToBase64String(mergedImageData);
            MyImage.ImageUrl = src;
        }

        private byte[] MergeTwoImageByteArrays(byte[] imageBytes, byte[] imageBaseBytes)
        {
            byte[] mergedImageData = new byte[0];
            using (var msBase = new MemoryStream(imageBaseBytes))
            {
                System.Drawing.Image imgBase = System.Drawing.Image.FromStream(msBase);
                Graphics gBase = Graphics.FromImage(imgBase);
                using (var msInfo = new MemoryStream(imageBytes))
                {
                    System.Drawing.Image imgInfo = System.Drawing.Image.FromStream(msInfo);
                    Graphics gInfo = Graphics.FromImage(imgInfo);
                    gBase.DrawImage(imgInfo, new Point(0, 0));
                    //imgBase.Save(Server.MapPath("_____testImg.png"), ImageFormat.Png);
                    MemoryStream mergedImageStream = new MemoryStream();
                    imgBase.Save(mergedImageStream, ImageFormat.Png);
                    mergedImageData = mergedImageStream.ToArray();
                    mergedImageStream.Close();
                }
            }
            return mergedImageData;
        }

Answer 14

我需要一个解决方案来组合未知数量的数组。

令人惊讶的是，没有其他人提供了使用SelectMany和params的解决方案。

 private static T[] Combine<T>(params IEnumerable<T>[] items) =>
                    items.SelectMany(i => i).Distinct().ToArray();

如果您不想要不同的项目，只需删除不同的。

 public string[] Reds = new [] { "Red", "Crimson", "TrafficLightRed" };
 public string[] Greens = new [] { "Green", "LimeGreen" };
 public string[] Blues = new [] { "Blue", "SkyBlue", "Navy" };

 public string[] Colors = Combine(Reds, Greens, Blues);

注意：使用 distinct 时绝对不能保证排序。

Answer 15

这是一个使用 Array.CopyTo 的简单示例。 我认为它回答了您的问题并给出了 CopyTo 用法的示例 - 当我需要使用此函数时我总是感到困惑，因为帮助有点不清楚 - 索引是目标数组中发生插入的位置。

int[] xSrc1 = new int[3] { 0, 1, 2 };
int[] xSrc2 = new int[5] { 3, 4, 5, 6 , 7 };

int[] xAll = new int[xSrc1.Length + xSrc2.Length];
xSrc1.CopyTo(xAll, 0);
xSrc2.CopyTo(xAll, xSrc1.Length);

我想你不能让它变得更简单。

Answer 16

如果数组本身中有源数组，则可以使用SelectMany ：

var arrays = new[]{new[]{1, 2, 3}, new[]{4, 5, 6}};
var combined = arrays.SelectMany(a => a).ToArray();
foreach (var v in combined) Console.WriteLine(v);   

给

1
2
3
4
5
6

可能这不是最快的方法，但可能适合根据用例。

Answer 17

int [] SouceArray1 = new int[] {2,1,3};
int [] SourceArray2 = new int[] {4,5,6};
int [] targetArray = new int [SouceArray1.Length + SourceArray2.Length];
SouceArray1.CopyTo(targetArray,0);
SourceArray2.CopyTo(targetArray,SouceArray1.Length) ; 
foreach (int i in targetArray) Console.WriteLine(i + " ");  

使用上面的代码可以很容易地合并两个数组。

Answer 18

创建和扩展方法来处理空值

public static class IEnumerableExtenions
{
    public static IEnumerable<T> UnionIfNotNull<T>(this IEnumerable<T> list1, IEnumerable<T> list2)
    {
        if (list1 != null && list2 != null)
            return list1.Union(list2);
        else if (list1 != null)
            return list1;
        else if (list2 != null)
            return list2;
        else return null;
    }
}

Answer 19

我假设您使用的是自己的数组类型，而不是内置的 .NET 数组：

public string[] merge(input1, input2)
{
    string[] output = new string[input1.length + input2.length];
    for(int i = 0; i < output.length; i++)
    {
        if (i >= input1.length)
            output[i] = input2[i-input1.length];
        else
            output[i] = input1[i];
    }
    return output;
}

另一种方法是使用内置的 ArrayList 类。

public ArrayList merge(input1, input2)
{
    Arraylist output = new ArrayList();
    foreach(string val in input1)
        output.add(val);
    foreach(string val in input2)
        output.add(val);
    return output;
}

两个示例都是 C#。

Answer 20

string[] names1 = new string[] { "Ava", "Emma", "Olivia" };
string[] names2 = new string[] { "Olivia", "Sophia", "Emma" };
List<string> arr = new List<string>(names1.Length + names2.Length);
arr.AddRange(names1);
arr.AddRange(names2);
string[] result = arr.Distinct().ToArray();
foreach(string str in result)
{
    Console.WriteLine(str.ToString());
}

Console.ReadLine();

Answer 21

我想找到一种不使用 arrays 之外的任何库或功能的方法。

前两个示例主要用于从头开始阅读逻辑，但我也想知道是否会因情况而异。

第三个例子是最实际的选择。

// Two for-loops
private static int[] MergedArrays_1(int[] a, int[] b)
{
    int[] result = new int[a.Length + b.Length];
    for (int i = 0; i < a.Length; i++)
    {
        result[i] = a[i];
    }
    for (int i = a.Length; i < result.Length; i++)
    {
        result[i] = b[i - a.Length];
    }
    return result;
}

// One for-loop
private static int[] MergedArrays_2(int[] a, int[] b)
{
    int[] results = new int[a.Length + b.Length];
    for (int i = 0; i < results.Length; i++)
    {
        results[i] = (i < a.Length) ? a[i] : b[i - a.Length];
    }
    return results;
}

// Array Method
private static int[] MergedArrays_3(int[] a, int[] b)
{
    int[] results = new int[a.Length + b.Length];
    a.CopyTo(results, 0);
    b.CopyTo(results, a.Length);
    return results;
}

最后，我做了第四个例子，可以合并多个 arrays，使用 params 关键字。

int[] result = MultipleMergedArrays(arrayOne, arrayTwo, arrayThree);

private static int[] MultipleMergedArrays(params int[][] a)
{
    // Get Length
    int resultsLength = 0;
    for (int row = 0; row < a.GetLength(0); row++)
    {
        resultsLength += a.Length;
    }

    // Initialize
    int[] results = new int[resultsLength];

    // Add Items
    int index = 0;
    for (int row = 0; row < a.GetLength(0); row++)
    {
        a[row].CopyTo(results, index);
        index += a[row].Length;
    }
    return results;
}

使用参数时它的工作方式是将单维 arrays 传递到锯齿状数组中。

GetLength(0) 返回交错数组中包含的 arrays 的数量。

代码首先计算所有 arrays 的长度，然后根据该大小初始化一个新数组，并开始使用 CopyTo() 方法将整个 arrays 添加到新的结果数组中，同时将每个添加的数组的长度添加到一个索引计数器。

PS：有时合并时需要从 arrays 中删除空项目或某些项目。

private static int[] RemoveEmpty(int[] array)
{
    int count = 0;
    for (int i = 0; i < array.Length; i++)
    {
        if (array[i] == 0) count++;
    }

    int[] result = new int[array.Length - count];

    count = 0;
    for (int i = 0; i < array.Length; i++)
    {
        if (array[i] == 0) continue;
        result[count] = array[i];
        count++;
    }

    return result;
}

这个function可以和上面的组合起来。

它需要一个数组，计算匹配零的项目数。 并创建一个适当大小的新数组。 然后计数器被回收并用作索引，用于将输入数组的值放入新的更小的结果数组中。 当一个项目匹配零时，它会跳过该循环中代码的 rest，并继续下一轮，而不会增加 integer 计数器。

Answer 22

自 .NET 5 以来，我们现在有了AllocateUnitializedArray ，它可能会为建议的解决方案增加额外的（小的）性能改进：

public static T[] ConcatArrays<T>(IEnumerable<T[]> arrays)
{
    var result = GC.AllocateUnitializedArray<T>(arrays.Sum(a => a.Length));
    var offset = 0;
    foreach (var a in arrays)
    {
        a.CopyTo(result, offset);
        offset += a.Length;
    }
    return result;
}

Answer 23

此代码适用于所有情况：

int[] a1 ={3,4,5,6};
int[] a2 = {4,7,9};
int i = a1.Length-1;
int j = a2.Length-1;
int resultIndex=  i+j+1;
Array.Resize(ref a2, a1.Length +a2.Length);
while(resultIndex >=0)
{
    if(i != 0 && j !=0)
    {
        if(a1[i] > a2[j])
        {
            a2[resultIndex--] = a[i--];
        }
        else
        {
            a2[resultIndex--] = a[j--];
        }
    }
    else if(i>=0 && j<=0)
    { 
        a2[resultIndex--] = a[i--];
    }
    else if(j>=0 && i <=0)
    {
       a2[resultIndex--] = a[j--];
    }
}

Answer 24

连接多个数组的简单代码：

string[] arr1 = ...
string[] arr2 = ...
string[] arr3 = ...    
List<string> arr = new List<string>(arr1.Length + arr2.Length + arr3.Length);
arr.AddRange(arr1);
arr.AddRange(arr2);
arr.AddRange(arr3);
string[] result = arr.ToArray();

Answer 25

这是另一种方式来做到这一点:)

public static void ArrayPush<T>(ref T[] table, object value)
{
    Array.Resize(ref table, table.Length + 1); // Resizing the array for the cloned length (+-) (+1)
    table.SetValue(value, table.Length - 1); // Setting the value for the new element
}

public static void MergeArrays<T>(ref T[] tableOne, T[] tableTwo) {
    foreach(var element in tableTwo) {
        ArrayPush(ref tableOne, element);
    }
}

这是片段/示例

Answer 26

尝试这个：

ArrayLIst al = new ArrayList();
al.AddRange(array_1);
al.AddRange(array_2);
al.AddRange(array_3);
array_4 = al.ToArray();