C #에서 두 개의 배열을 어떻게 연결합니까?


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

더 쉽고 효율적인 방법이 있습니까?


8
"효율적"은 무엇을 의미합니까? 코드는 그대로 짧으므로 CPU / RAM 측면에서 효율적이라고 생각하십니까?
TToni 2009

4
아니요, Reflector를
간략히 살펴보면

z가 int [] 유형이어야한다는 것을 명심하십시오.
hwiechers

4
나는 실제로 효율성에 관심이 없습니다. (I 쉽게 말 했는가 또는 더 효율적입니다.) 나는 다른 사람들이 일반적인 작업을 처리 한 방법을 확인하기 위해 질문을했다.
hwiechers

답변:


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

8
@manthrax-> 방어에서 C #은 배열보다 훨씬 강력한 목록을 선호하는 경향이 있습니다. 배열을 사용하는 유일한 기능적 목적은 Interop 호출 (관리되지 않는 C ++)입니다.
Levi Fuller

@LeviFuller C #에서 배열을 사용하는 또 다른 곳은 변수 번호 params매개 변수입니다.
ChrisW

1
@LeviFuller-많은 시스템 루틴이 목록 대신 배열을 반환하는 것은 이상합니다. 예를 들어 System.IO.Directory.GetFiles()문자열 배열을 반환합니다.
오리온 elenzil

4
이것은 이상하지 않습니다. 배열은 변경할 수 없으며 목록은 없습니다. 또한 TrimExcess가 호출되지 않는 한 (List는 배열보다 많은 메모리를 사용합니다)
CSharpie

1
또한 list는 배열을 내부에 래핑하고 인덱서를 호출하는 데 오버 헤드가 있기 때문에 데이터에 액세스 할 때 목록보다 빠릅니다.
C0DEF52

84

이 시도:

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

5
심지어List<int> list = new List<int>(x);
매튜 Scharley

7
x.Concat (y)보다 어떻게 더 효율적입니까? 그것은 효과가 있으며 모두 더 좋게 만드는 것이 있는지 궁금합니다.
Mike Two

7
첫 번째 줄을 List <int> list = new List <int> (x.Length + y.Length)로 만들 수 있습니다. AddRange를 호출 할 때 발생할 수있는 크기 조정을 피하기 위해
Mike Two

5
@Mathew Scharley. 문제는보다 효율적인 솔루션을 요구하는 것입니다. 제목이 오래된 조합처럼 들리지만 전체 질문은 그 이상입니다. 일부 답변을 읽는 것은 일부 사람들이 제목에 답변하고 있다고 생각합니다. 따라서이 답변이 문제의 요점 인 것처럼 보였기 때문에 공감자가 가치가 있다면 효율성을 언급해야한다고 생각했습니다.
Mike Two

2
AddRange는 실제로 상당히 고가의 프로세스 이므로이
Liam

49

확장 방법을 작성할 수 있습니다.

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}

1
IEnumerable에서 작동하는 확장 방법이 있습니까?
Mike Two

2
예, 대부분의 경우 행복하게 사용합니다. 그러나 그들은 많은 오버 헤드를 가지고 있습니다. 때에 따라 다르지; 시간의 98 %가 오버 헤드가 좋습니다. 당신이 2 %에 있다면, 일부 직접 memcopy / 배열 작업이 편리합니다.
Marc Gravell

1
@nawfal, 어떻게 Copy보다 빠릅 CopyTo니까? 정교하게 관리?
skrebbel

1
@skrebbel 광산은 부정확 한 의견이었습니다. 나는 그때 몇 가지 테스트를했고 복사가 더 빠르다는 것을 알았습니다. 그러나 이제는 그들이 똑같아 보입니다. 그때 내가 찾은 것은 Marc의 접근 방식이 Zed의 접근 방식에서 새로운 배열을 생성하는 동안 동일한 인스턴스를 다시 전달하기 때문에 전반적인 접근 방식이 더 효율적일 수 있습니다. 사과 :)
nawfal

1
@Shimmy 그렇지 않습니다. 이 메소드 내에서 x는 로컬 변수이지만 x를 resize 메소드에 대한 참조로 전달하면 새 배열이 작성되고 그것을 가리 키도록 (로컬 변수) x가 변경됩니다. 또는 rephrase : x resize로 전달 된 x와 extension 메소드 내부 x는 동일한 변수이지만 x는 ref로 확장 메소드에 전달되지 않으므로 x는이 확장이 호출 된 범위의 변수와 다른 변수입니다 .
AnorZaken

40

나는 동일한 유형의 임의의 1 차원 배열 세트를 연결할 수있는보다 범용적인 솔루션에 정착했습니다. (한 번에 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}

좋은 기능, 감사합니다! 확장으로 변경 params T[][]되었습니다 this T[][].
Mark

안녕하세요,이 기능은 내가 찾고있는 것처럼 보이지만 어떻게 이것을 달성 할 수 있습니까? 링크 @Mark
George B

31

이거 야:

using System.Linq;

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

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

4
당신은 의미 int[] result = array1.ToList().Concat(array2.ToList()).toArray();당신은 배열에 CONCAT을 적용 할 수 없습니다 직접 내가 믿는
미하일 Michailidis

4
이 솔루션-z = x.Concat (y)-은 위의 원래 질문에 언급되어 있습니다.
Jon Schneider

1
이것은toArray() Cannot implicitly convert type 'System.Collections.Generic.IEnumerable<string>' to 'string[]'. An explicit conversion exists (are you missing a cast?)
Tibor Udvari

2
이것은 직접적인 대답이 아닙니다. 영업 이익은 요청 int[] result = ?, 당신은 당신의 뒤에 당신의 대답의 문제를 숨기고있는 var당신의 결과가 될 것이라고에서 IEnumerable<int>,하지 int[]. ( var메소드 리턴을 좋아하지 않는 이유 중 하나 )
David S.

2
이 방법은 질문에 사용 되므로이 답변은 새로운 정보를 제공하지 않으며 .ToArray()호출 하지 않으면 이 코드는 실제 배열을 반환하지 않으므로 잘못된 답변이기도합니다.
Mani Gandham

10

ToArray () 호출을 끝낼 수 있습니다. Concat를 호출 한 후 배열이 필요한 이유가 있습니까?

Concat을 호출하면 두 배열 모두에 반복자가 생성됩니다. 새 배열을 만들지 않으므로 새 배열에 더 많은 메모리를 사용하지 않았습니다. ToArray를 호출하면 실제로 새 배열을 만들고 새 배열의 메모리를 차지합니다.

따라서 둘 다 쉽게 반복 해야하는 경우 Concat을 호출하십시오.


8

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

}

결과는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

자신의 승리를 굴려 라.


방법을 사용하는 방법에 공평하게, 방법은 아마도 내 시스템에 약 10,000 틱을 추가했습니다.
amalgamate

1
릴리스 모드에서 Visual Studio 2013에서 코드를 실행했으며 테스트 된 배열이 사용자 CopyTo보다 작지 않은 경우 (1000 요소와 같이) 가장 빠르며 ~ 3 배 빠릅니다 Roll your own.
씨 씨

@ Mr.Ree 네, 제 배열은 정말 작았습니다. 감사. 블록 복사가 더 나은지 알고
싶습니다

7

Concat방법에 주의하십시오 . C # 의 Post Array Concatenation은 다음과 같이 설명합니다.

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

큰 배열에는 비효율적입니다. 즉,이 Concat방법은 meduim 크기의 배열에만 적용됩니다 (최대 10000 개의 요소).


2
10,000 개 이상의 요소가 포함 된 배열로 수행해야 할 작업은 무엇입니까?
alex

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

2
StackOverflow에서 코드를 붙여 넣을뿐만 아니라 접근 방식을 설명하십시오. 이 특정한 경우에 당신은 또한 당신의 말 대답은 이미 주어진 (그리고 가능) 답변에 추가 무엇인지 설명 할 수 있습니다
거트 아놀드

1
"이것"이 첫 번째 매개 변수 이전에 무엇을하는지 확실하지 않지만 나머지는 이것이 훌륭한 기능입니다. 일반 및 무한량의 매개 변수가 있습니다.
Nyerguds

2
안녕 Nyerguds. 귀하의 질문에 대답하기 위해 "this"키워드는 함수를 확장 방법으로 만드는 데 사용됩니다. 확장 방법에 대한 자세한 내용은이 MSDN 문서
JFish222를

6

사용하기 (빠른)보다 효율적인 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은 3088ms 걸렸다

CopyTo는 1079ms 걸렸습니다

BlockCopy 소요 603ms

테스트 배열을 0에서 99의 두 시퀀스로 변경하면 다음과 비슷한 결과가 나타납니다.

Concat은 45945ms 걸렸다

CopyTo는 2230ms 걸렸습니다

BlockCopy는 1689ms 걸렸습니다

이러한 결과를 바탕으로 CopyToand 및 BlockCopy방법이 Concat성능 보다 훨씬 효율적이고 성능이 목표 인 BlockCopy경우 그 이상의 가치 가 있다고 주장 할 수 있습니다CopyTo .

이 대답을 피하기 위해 성능이 중요하지 않거나 가장 쉬운 방법을 선택하는 반복이 거의없는 경우. Buffer.BlockCopy이 질문의 범위를 벗어난 유형 변환을위한 유틸리티를 제공합니다.


6

늦은 답변 :-).

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

    }

3

결합 된 배열을 유지하는 RAM (및 CPU) 측면에서 가장 효율적인 구조는 IEnumerable을 구현하고 (또는 Array에서 파생시키려는 경우) 내부 배열을 원래 배열에 연결하여 값을 읽는 특수 클래스입니다. AFAIK Concat은 바로 그렇게합니다.

샘플 코드에서는 .ToArray ()를 생략하여 더 효율적으로 만들 수 있습니다.


3

오래된 스레드를 되살려 서 미안하지만 어떻습니까?

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>[] 은 이러한 함수가 단순한 배열 이상의 것을 받아들이 입니다.

도움이 되었기를 바랍니다.


2

당신은 당신이 참조한 방식으로 그것을 할 수 있거나, 당신이 그것에 대해 실제로 매뉴얼을 얻고 싶다면 당신은 당신 자신의 루프를 굴릴 수 있습니다 :

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

@nawfal 배열 크기에 달려 있다고 생각합니다. 이것은 작은 배열 크기의 테스트에서 승리했습니다.
amalgamate

2

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 표현이 가장 느립니다. 소요되는 시간은 배열 요소의 유형에 따라 다르지만 수백만 건의 호출이 없으면 메서드간에 큰 차이가 없습니다.


1

기억해야 할 것은 LINQ를 사용할 때 지연된 실행을 사용한다는 것입니다. 여기에 설명 된 다른 방법은 모두 완벽하게 작동하지만 즉시 실행됩니다. 또한 Concat () 함수는 사용자가 스스로 할 수없는 방식으로 최적화되었을 것입니다 (내부 API 호출, OS 호출 등). 어쨌든, 당신이 정말로 시도하고 최적화 할 필요가 없다면, 당신은 현재 "모든 악의 근원"으로가는 길에 있습니다.;)


1

다음을 시도하십시오 :

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

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

1

내 대답은 다음과 같습니다.

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

후자의 방법은 훨씬 더 우아하지만 전자의 방법은 성능면에서 훨씬 좋습니다.

자세한 내용은 이 게시물을 참조하십시오 은 내 블로그 을 .


0

int [] 들어 당신이 한 일이 나에게 좋아 보인다. 독자의 답변도 잘 작동합니다 List<int>.


2
Concat은 List <int>에서도 작동합니다. Concat의 장점은 IEnumerable <>에서 작동하는 것입니다.
Mike Two

0

더 작은 배열 <10000 요소의 경우 :

using System.Linq;

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

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

왜 Linq를 사용하지 않아도 되나요?!
ina

0
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를 사용하지 않기 때문에 더 가볍습니다.

솔루션은 간결하며 일반성이 추가되어 런타임 오버 헤드가 크게 증가하지 않습니다.


새로운 질문을 찾거나 모자에 이미 많은 답변이 없습니다.
Andrew Barber

이 솔루션은 다른 솔루션의 장점을 요약 한 것으로 생각하기 때문에이 솔루션을 제안했습니다. 제작되었습니다.
drowa

-2

int [] x = 새로운 int [] {1, 2, 3}; int [] y = 새로운 int [] {4, 5};

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


2
Union암시 적으로 Distinct조인 된 컬렉션에서 복제본을 호출 하고 제거 하므로이 작업을 수행하는 좋은 방법은 아닙니다 . Concat훨씬 낫지 만 이미 원래 질문에 있습니다.
nurchi 2012 년

-3
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]);
}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.