[C#] Объединение двух массивов в .NET.


Answers

В C # 3.0 вы можете использовать метод Concat LINQ для этого:

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 .

Question

Есть ли встроенная функция в .NET 2.0, которая будет принимать два массива и объединить их в один массив?

Массивы одного типа. Я получаю эти массивы от широко используемой функции в моей базе кода и не могу изменить функцию для возврата данных в другом формате.

Я ищу, чтобы избежать написания моей собственной функции, чтобы сделать это, если это возможно.




Вот простой пример использования 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);

Наверное, вы не можете сделать это намного проще.




У всех уже есть свое мнение, но я думаю, что это более читаемо, чем подход «использовать как метод расширения»:

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

Однако его можно использовать только при объединении 2 массивов.




Этот код будет работать для всех случаев:

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



Предполагая, что массив назначения имеет достаточно места, Array.Copy() будет работать. Вы также можете попробовать использовать List<T> и его .AddRange() .




Если вы не хотите удалять дубликаты, попробуйте это

Используйте LINQ:

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



Я предполагаю, что вы используете свои собственные типы массивов в отличие от встроенных .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 #.




Мне нужно решение для объединения неизвестного количества массивов.

Удивленный никто не предоставил решение с помощью 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);

Примечание. При использовании отдельных элементов определенно нет гарантии упорядочивания.




Легче будет использовать LINQ :

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

Сначала преобразуйте массивы в списки и объедините их ... После этого просто преобразуйте список обратно в массив :)