Como concatenar duas matrizes em 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 }));

Agora eu uso

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

Existe um método mais fácil ou mais eficiente?

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

Tente o seguinte:

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

Você pode escrever um método de extensão:

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

Então:

int[] x = {1,2,3}, y = {4,5};
int[] z = x.Concat(y); // {1,2,3,4,5}

Eu decidi por uma solução de uso geral que permite concatenar um conjunto arbitrário de matrizes unidimensionais do mesmo tipo. (Eu concatenava 3 ou mais de cada vez.)

Minha função:

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

E uso:

        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}

É isso:

using System.Linq;

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

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

Você pode atender a chamada ToArray () no final. Existe uma razão para você precisar que ela seja uma matriz após a chamada para a Concat?

Chamar o Concat cria um iterador sobre as duas matrizes. Ele não cria uma nova matriz, portanto você não usou mais memória para uma nova matriz. Quando você chama o ToArray, na verdade, cria uma nova matriz e ocupa a memória da nova matriz.

Portanto, se você apenas iterar facilmente os dois, basta ligar para a Concat.

Eu sei que o OP estava levemente curioso sobre o desempenho. Matrizes maiores podem ter um resultado diferente (consulte @kurdishTree). E que isso geralmente não importa (@ jordan.peoples). No entanto, fiquei curioso e, portanto, enlouqueci (como o @TigerShark estava explicando) .... quero dizer que escrevi um teste simples com base na pergunta original .... e todas as respostas ....

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

}

O resultado foi:

Role suas próprias vitórias.

Tenha cuidado com o Concatmétodo. A concatenação de matriz pós em C # explica que:

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

Será ineficiente para matrizes grandes. Isso significa que o Concatmétodo é apenas para matrizes de tamanho médio (até 10000 elementos).

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

Mais eficiente (mais rápido) para usar Buffer.BlockCopymais 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));

Eu escrevi um programa de teste simples que "aquece o Jitter", compilado no modo de lançamento e o executava sem um depurador conectado, na minha máquina.

Para 10.000.000 iterações do exemplo na pergunta

Concat levou 3088ms

CopyTo levou 1079ms

BlockCopy levou 603ms

Se eu alterar as matrizes de teste para duas sequências de 0 a 99, obtive resultados semelhantes a este,

Concat levou 45945ms

CopyTo levou 2230ms

BlockCopy levou 1689ms

A partir desses resultados, posso afirmar que os métodos CopyToe BlockCopysão significativamente mais eficientes Concate, além disso, se o desempenho é uma meta, BlockCopytêm valor acima CopyTo.

Para ressaltar esta resposta, se o desempenho não importa, ou haverá poucas iterações, escolha o método que você achar mais fácil. Buffer.BlockCopyoferece algum utilitário para a conversão de tipos além do escopo desta pergunta.

Resposta atrasada :-).

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

    }

A estrutura mais eficiente em termos de RAM (e CPU) para armazenar a matriz combinada seria uma classe especial que implementa IEnumerable (ou se você desejar derivar da matriz) e vincula internamente às matrizes originais para ler os valores. O AFAIK Concat faz exatamente isso.

No seu código de exemplo, você pode omitir o .ToArray (), o que o tornaria mais eficiente.

Desculpe reviver um tópico antigo, mas e quanto a isso:

static IEnumerable<T> Merge<T>(params T[][] arrays)
{
    var merged = arrays.SelectMany(arr => arr);

    foreach (var t in merged)
        yield return t;
}

Então no seu código:

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

Até que você chame .ToArray(), .ToList()ou .ToDictionary(...)a memória não seja alocada, você pode "construir sua consulta" e chamar um desses três para executá-lo ou simplesmente passar por todos eles usando a foreach (var i in z){...}cláusula que retorna um item de cada vez doyield return t; acima...

A função acima pode ser transformada em uma extensão da seguinte maneira:

static IEnumerable<T> Merge<T>(this T[] array1, T[] array2)
{
    var merged = array1.Concat(array2);

    foreach (var t in merged)
        yield return t;
}

Portanto, no código, você pode fazer algo como:

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

O resto é o mesmo de antes.

Uma outra melhoria para este seria mudar T[]para IEnumerable<T>(de modo a params T[][]se tornariaparams IEnumerable<T>[] ) fazer essas funções aceitarem mais do que apenas matrizes.

Espero que isto ajude.

Você pode fazer isso da maneira que você se referiu ou, se quiser ser realmente manual, poderá fazer seu próprio loop:

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

Encontrei uma solução elegante de uma linha usando a expressão LINQ ou Lambda , ambas funcionam da mesma forma (o LINQ é convertido em Lambda quando o programa é compilado). A solução funciona para qualquer tipo de matriz e para qualquer número de matrizes.

Usando LINQ:

public static T[] ConcatArraysLinq<T>(params T[][] arrays)
{
    return (from array in arrays
            from arr in array
            select arr).ToArray();
}

Usando o Lambda:

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

Eu forneci ambos pela preferência. Em termos de desempenho, as soluções @Sergey Shteyn ou @ deepee1 são um pouco mais rápidas, sendo a expressão Lambda a mais lenta. O tempo gasto depende do (s) tipo (s) de elementos da matriz, mas, a menos que haja milhões de chamadas, não há diferença significativa entre os métodos.

O que você precisa lembrar é que, ao usar o LINQ, você está utilizando a execução atrasada. Os outros métodos descritos aqui funcionam perfeitamente, mas são executados imediatamente. Além disso, a função Concat () provavelmente é otimizada de maneiras que você não pode fazer sozinho (chamadas para APIs internas, chamadas de SO etc.). De qualquer forma, a menos que você realmente precise otimizar, você está atualmente no seu caminho para "a raiz de todo mal";)

Tente o seguinte:

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

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

Aqui está a minha resposta:

int[] z = new List<string>()
    .Concat(a)
    .Concat(b)
    .Concat(c)
    .ToArray();

Este método pode ser usado no nível de inicialização, por exemplo, para definir uma concatenação estática de matrizes estáticas:

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

No entanto, ele vem com duas advertências que você precisa considerar:

• o Concat  método cria um iterador sobre as duas matrizes: não cria uma nova matriz, sendo eficiente em termos de memória utilizada: no entanto, o subsequente  ToArray  negará essa vantagem, pois na verdade criará uma nova matriz e ocupará a memória para o nova matriz.
• Como @Jodrell disse, Concat seria bastante ineficiente para matrizes grandes: deve ser usada apenas para matrizes de tamanho médio.

Se apontar para o desempenho é uma obrigação, o método a seguir pode ser usado:

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

Ou (para fãs de one-liners):

int[] z = (from arrays in new[] { a, b, c } from arr in arrays select arr).ToArray();

Embora o último método seja muito mais elegante, o primeiro é definitivamente melhor para o desempenho.

Para informações adicionais, consulte este post no meu blog.

Para int [] o que você fez parece bom para mim. a resposta do astander também funcionaria bem List<int>.

Para matrizes menores <10000 elementos:

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

Penso que a solução acima é mais geral e mais leve do que as outras que vi aqui. É mais geral porque não limita a concatenação para apenas duas matrizes e é mais leve porque não usa LINQ nem List.

Observe que a solução é concisa e a generalidade adicionada não adiciona uma sobrecarga significativa no tempo de execução.

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

int [] z = x.União (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]);
}