Як з'єднати два масиви в 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();

Чи є простіший чи ефективніший метод?

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

Спробуйте це:

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

Ви можете написати метод розширення:

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}

Я зупинився на більш загальному варіанті рішення, яке дозволяє об'єднати довільну множину одновимірних масивів одного типу. (Я об'єднував 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}

Це воно:

using System.Linq;

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

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

Ви можете зняти дзвінок ToArray () до кінця. Чи є причина, що вам потрібно, щоб це був масив після виклику Concat?

Виклик Concat створює ітератор над обома масивами. Він не створює новий масив, тому ви не використовували більше пам’яті для нового масиву. Коли ви телефонуєте в ToArray, ви фактично створюєте новий масив і займаєте пам'ять для нового масиву.

Тож якщо вам просто потрібно легко перебрати і те й інше, просто зателефонуйте на Concat.

Я знаю, що ОП був лише м'яко цікавий щодо продуктивності. Цей більший масив може отримати інший результат (див. @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();
        }
    }

}

Результат:

Розкажіть власні виграші.

Будьте обережні з Concatметодом. Зв'язок масиву публікацій у C # пояснює, що:

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

Буде неефективним для великих масивів. Це означає, що Concatметод застосовується лише для масивів середнього розміру (до 10000 елементів).

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

Більш ефективний (швидше) , щоб використовувати 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 зайняв 3088 мс

CopyTo зайняв 1079 мс

BlockCopy зайняв 603 мс

Якщо я змінити тестові масиви на дві послідовності від 0 до 99, то я отримаю результати, подібні до цього,

Concat зайняв 45945 мс

CopyTo зайняв 2230 мс

BlockCopy зайняв 1689 мс

З цих результатів можу стверджувати, що CopyTo і BlockCopyметоди значно ефективніші, Concatі, крім того, якщо ефективність є ціллю, BlockCopyмає значення надCopyTo .

Щоб застерегти цю відповідь, якщо продуктивність не має значення, або буде кілька ітерацій, виберіть найпростіший метод. Buffer.BlockCopyпропонує певну корисність для перетворення типів за межі цього питання.

Пізня відповідь :-).

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

    }

Найбільш ефективною структурою з точки зору оперативної пам’яті (та процесора) для утримання комбінованого масиву був би спеціальний клас, який реалізує IEnumerable (або якщо ви хочете навіть походить від Array) та внутрішньо посилається на вихідні масиви для зчитування значень. AFAIK Concat робить саме це.

У вашому зразковому коді ви можете опустити .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>[] ), щоб зробити ці функції прийняти більше, ніж просто масиви.

Сподіваюсь, це допомагає.

Ви можете це зробити так, як ви згадували, або якщо ви хочете отримати справді посібник про це, ви можете прокатати свій власний цикл:

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

Я знайшов елегантне однолінійне рішення, використовуючи 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 трохи швидша, вираз лямбда - найповільніший. Затрачений час залежить від типів елементів масиву, але якщо мільйонів викликів немає, різниці між методами немає.

Що вам потрібно пам’ятати, це те, що при використанні LINQ ви використовуєте затримку виконання. Інші описані тут методи працюють прекрасно, але вони виконуються негайно. Крім того, функція Concat (), ймовірно, оптимізована способами, які ви не можете зробити самостійно (дзвінки до внутрішніх API, дзвінки ОС тощо). У будь-якому разі, якщо вам справді не потрібно намагатися та оптимізувати, ви зараз на шляху до "кореня всього зла";)

Спробуйте наступне:

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

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

Ось моя відповідь:

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 [] те, що ти зробив, мені добре виглядає. відповідь стародавнього також буде добре працювати List<int>.

Для менших масивів <10000 елементів:

using System.Linq;

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

int[] result = firstArray.ToList().Concat(secondArray.ToList()).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.

Зауважте, що рішення є стислим, і додана загальність не додає значних витрат на виконання.

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

int [] z = x.Union (y) .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]);
}