Effiziente Methoden zum Kombinieren von Listen in C#

Das Verbinden von Listen ist eine grundlegende Operation in der C#-Programmierung. Dieser Artikel untersucht verschiedene effektive Techniken zum Verbinden von Listen, jede mit ihren eigenen Vorteilen und Anwendungsfällen. Wir werden verschiedene Ansätze untersuchen, von einfacher Konkatenation bis hin zu anspruchsvolleren Operationen wie dem Zusammenführen mit Duplikatentfernung oder dem Paaren von Elementen.

Inhaltsverzeichnis

1. Verbinden von Listen mit AddRange()
2. Verketten von Listen mit Concat() (LINQ)
3. Manuelles Verbinden von Listen mit einer foreach-Schleife
4. Kombinieren von Listen und Entfernen von Duplikaten mit Union() (LINQ)
5. Einfügen einer Liste in eine andere mit InsertRange()
6. Paaren von Elementen mit der Zip()-Methode
7. Fazit

Verbinden von Listen mit AddRange()

Die AddRange()-Methode bietet eine direkte und effiziente Möglichkeit, eine Liste an das Ende einer anderen anzuhängen. Diese Methode modifiziert die ursprüngliche Liste.

using System;
using System.Collections.Generic;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        list1.AddRange(list2);

        Console.WriteLine("Verbundene Liste:");
        Console.WriteLine(string.Join(" ", list1)); // Ausgabe: 1 2 3 4 5 6
    }
}

Verketten von Listen mit Concat() (LINQ)

Die Concat()-Methode von LINQ bietet einen schreibgeschützten Ansatz zur Listenverkettung. Sie erstellt eine neue Liste, die alle Elemente aus beiden Eingabelisten enthält, ohne die Originale zu verändern.

using System;
using System.Collections.Generic;
using System.Linq;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        var joinedList = list1.Concat(list2).ToList();

        Console.WriteLine("Verkettete Liste:");
        Console.WriteLine(string.Join(" ", joinedList)); // Ausgabe: 1 2 3 4 5 6
    }
}

Manuelles Verbinden von Listen mit einer foreach-Schleife

Ein manueller Ansatz mit einer foreach-Schleife bietet maximale Kontrolle, besonders nützlich bei komplexerer Verknüpfungslogik.

using System;
using System.Collections.Generic;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };
        List<int> joinedList = new List<int>();

        joinedList.AddRange(list1);
        foreach (int num in list2)
        {
            joinedList.Add(num);
        }

        Console.WriteLine("Verbundene Liste:");
        Console.WriteLine(string.Join(" ", joinedList)); // Ausgabe: 1 2 3 4 5 6

    }
}

Kombinieren von Listen und Entfernen von Duplikaten mit Union() (LINQ)

Die Union()-Methode führt effizient zwei Listen zusammen und entfernt dabei doppelte Einträge.

using System;
using System.Collections.Generic;
using System.Linq;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 3, 4, 5 };

        var joinedList = list1.Union(list2).ToList();

        Console.WriteLine("Verbundene Liste (Duplikate entfernt):");
        Console.WriteLine(string.Join(" ", joinedList)); // Ausgabe: 1 2 3 4 5
    }
}

Einfügen einer Liste in eine andere mit InsertRange()

InsertRange() ermöglicht das präzise Einfügen einer Liste in eine andere an einem angegebenen Index.

using System;
using System.Collections.Generic;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<int> list1 = new List<int> { 1, 2, 3 };
        List<int> list2 = new List<int> { 4, 5, 6 };

        list1.InsertRange(2, list2); // Fügt list2 ab Index 2 ein

        Console.WriteLine("Verbundene Liste:");
        Console.WriteLine(string.Join(" ", list1)); // Ausgabe: 1 2 4 5 6 3
    }
}

Paaren von Elementen mit der Zip()-Methode

Die Zip()-Methode paart entsprechende Elemente aus zwei Listen basierend auf ihrem Index. Dies ist hilfreich, wenn Sie Elemente kombinieren müssen, die eine relationale Korrespondenz aufweisen.

using System;
using System.Collections.Generic;
using System.Linq;

public class JoinLists
{
    public static void Main(string[] args)
    {
        List<string> list1 = new List<string> { "A", "B", "C" };
        List<int> list2 = new List<int> { 1, 2, 3 };

        var zippedList = list1.Zip(list2, (str, num) => str + num).ToList();

        Console.WriteLine("Gezippte Liste:");
        Console.WriteLine(string.Join(" ", zippedList)); // Ausgabe: A1 B2 C3
    }
}

Fazit

C# bietet eine umfangreiche Reihe von Werkzeugen zur Listenmanipulation. Die Wahl der Methode hängt stark von den spezifischen Anforderungen Ihrer Aufgabe ab. Berücksichtigen Sie, ob Sie Originallisten ändern, Duplikate entfernen oder entsprechende Elemente paarweise kombinieren müssen, wenn Sie den am besten geeigneten Ansatz auswählen.