c# - Unendo due liste insieme



(10)

Se ho due liste di tipo string (o qualsiasi altro tipo), qual è un modo rapido per unire le due liste?

L'ordine dovrebbe rimanere lo stesso. I duplicati dovrebbero essere rimossi (anche se ogni elemento in entrambi i collegamenti è unico). Non ho trovato molto su questo quando su Google e non volevo implementare alcuna interfaccia .NET per la velocità di consegna.


Answer #1

Finché sono dello stesso tipo, è molto semplice con AddRange:

list2.AddRange(list1);


Answer #3

Il modo con il minimo sovraccarico di spazio è utilizzare il metodo di estensione Concat.

var combined = list1.Concat(list2);

Crea un'istanza di IEnumerable<T> che enumera gli elementi di list1 e list2 in quell'ordine.


Answer #4

Le due opzioni che uso sono:

list1.AddRange(list2);

o

list1.Concat(list2);

Tuttavia, ho notato che quando AddRange metodo AddRange con una funzione ricorsiva, che mi chiamava molto spesso ho ottenuto un SystemOutOfMemoryException perché è stato raggiunto il numero massimo di dimensioni.

(Messaggio tradotto da Google)
Le dimensioni dell'array hanno superato l'intervallo supportato.

Utilizzando Concat risolto questo problema.


Answer #5

Qualcosa come questo:

firstList.AddRange (secondList);

In alternativa, è possibile utilizzare il metodo di estensione "Unione" definito in System.Linq. Con 'Unione', puoi anche specificare un comparatore, che può essere usato per specificare se un elemento deve essere unito o meno.

Come questo:

List<int> one = new List<int> { 1, 2, 3, 4, 5 };
List<int> second=new List<int> { 1, 2, 5, 6 };

var result = one.Union (second, new EqComparer ());

foreach( int x in result )
{
    Console.WriteLine (x);
}
Console.ReadLine ();

#region IEqualityComparer<int> Members
public class EqComparer : IEqualityComparer<int>
{
    public bool Equals( int x, int y )
    {
        return x == y;
    }

    public int GetHashCode( int obj )
    {
        return obj.GetHashCode ();
    }
}
#endregion

Answer #6

Se alcuni articoli sono presenti in entrambi gli elenchi è possibile utilizzarli

var all = list1.Concat(list2).Concat(list3) ... Concat(listN).Distinct().ToList();

Answer #7

Volevo solo testare come funziona Union con il confronto predefinito su raccolte sovrapposte di oggetti di tipo riferimento.

Il mio oggetto è:

class MyInt
{
    public int val;

    public override string ToString()
    {
        return val.ToString();
    }
}

Il mio codice di prova è:

MyInt[] myInts1 = new MyInt[10];
MyInt[] myInts2 = new MyInt[10];
int overlapFrom = 4;
Console.WriteLine("overlapFrom: {0}", overlapFrom);

Action<IEnumerable<MyInt>, string> printMyInts = (myInts, myIntsName) => Console.WriteLine("{2} ({0}): {1}", myInts.Count(), string.Join(" ", myInts), myIntsName);

for (int i = 0; i < myInts1.Length; i++)
    myInts1[i] = new MyInt { val = i };
printMyInts(myInts1, nameof(myInts1));

int j = 0;
for (; j + overlapFrom < myInts1.Length; j++)
    myInts2[j] = myInts1[j + overlapFrom];
for (; j < myInts2.Length; j++)
    myInts2[j] = new MyInt { val = j + overlapFrom };
printMyInts(myInts2, nameof(myInts2));

IEnumerable<MyInt> myUnion = myInts1.Union(myInts2);
printMyInts(myUnion, nameof(myUnion));

for (int i = 0; i < myInts2.Length; i++)
    myInts2[i].val += 10;
printMyInts(myInts2, nameof(myInts2));
printMyInts(myUnion, nameof(myUnion));

for (int i = 0; i < myInts1.Length; i++)
    myInts1[i].val = i;
printMyInts(myInts1, nameof(myInts1));
printMyInts(myUnion, nameof(myUnion));

L'output è:

overlapFrom: 4
myInts1 (10): 0 1 2 3 4 5 6 7 8 9
myInts2 (10): 4 5 6 7 8 9 10 11 12 13
myUnion (14): 0 1 2 3 4 5 6 7 8 9 10 11 12 13
myInts2 (10): 14 15 16 17 18 19 20 21 22 23
myUnion (14): 0 1 2 3 14 15 16 17 18 19 20 21 22 23
myInts1 (10): 0 1 2 3 4 5 6 7 8 9
myUnion (14): 0 1 2 3 4 5 6 7 8 9 20 21 22 23

Quindi, tutto funziona bene.


Answer #8

one way: List.AddRange () a seconda dei tipi?


Answer #9
targetList = list1.Concat(list2).ToList();

Funziona bene, penso di si. Come detto in precedenza, Concat restituisce una nuova sequenza e mentre converte il risultato in List, fa perfettamente il lavoro. Le conversioni implicite potrebbero non riuscire a volte quando si utilizza il metodo AddRange.


Answer #10
var bigList = new List<int> { 1, 2, 3 }
    .Concat(new List<int> { 4, 5, 6 })
    .ToList(); /// yields { 1, 2, 3, 4, 5, 6 }




c#