C# 将两个锯齿状列表合并为一个

我有两张参差不齐的名单

第一个：

List<List<string>> firstList = new List<List<string>>();

{ dd ff }
{ dd ff }
{ dd ff }

任何连接尝试都只会导致添加

secondList

元素，类似于另一个

firstList

行，如下所示：

{ dd ff }
{ dd ff }
{ dd ff }
{ gg hh }
{ gg uu }
{ hh uu }

List<List<string>> finalList = (from x in firstList
                                join y in secondList
                                on firstList.IndexOf(x) equals secondList.IndexOf(y)
                                select x.Concat(y).ToList()).ToList();

如果您能帮上忙，我将不胜感激

您可以使用来连接相应的子列表

var combined = firstList.Zip(secondList, (f,s) => f.Concat(s).ToList()).ToList();

请注意，如果两个列表包含不同数量的子列表，则结果将只包含两个列表中较短的子列表。

您可以使用来连接相应的子列表

var combined = firstList.Zip(secondList, (f,s) => f.Concat(s).ToList()).ToList();

---

请注意，如果两个列表包含不同数量的子列表，则结果将只包含两个列表中较短的子列表。

这里的重要思想是必须将列表的每个元素合并，而不是将两个列表合并

每个元素的浓度：

{ dd ff gg hh } //each element dd ff is concatted with gg hh
{ dd ff gg uu }
{ dd ff hh uu }

在名单上：

{ dd ff }
{ dd ff }
{ dd ff }   //elements from the 1st list
----------- concated with
{ gg hh }   
{ gg uu }
{ hh uu }  //elements from the 2nd list

您可以

Concat

列表中的每个元素（必须具有相同数量的元素，或者第二个元素的数量比第一个元素的数量多），如下所示：

{ dd ff }
{ dd ff }
{ dd ff }
{ gg hh }
{ gg uu }
{ hh uu }

List<List<string>> finalList = (from x in firstList
                                join y in secondList
                                on firstList.IndexOf(x) equals secondList.IndexOf(y)
                                select x.Concat(y).ToList()).ToList();

List finalList=（从firstList中的x开始）
加入第二名单
在第一个列表上。IndexOf（x）等于第二个列表。IndexOf（y）
选择x.Concat（y）.ToList（））.ToList（）；

---

或者任何其他方式来完成。这里的重要思想是，你必须将列表中的每个元素连在一起，而不是将两个列表连在一起

每个元素的浓度：

{ dd ff gg hh } //each element dd ff is concatted with gg hh
{ dd ff gg uu }
{ dd ff hh uu }

在名单上：

{ dd ff }
{ dd ff }
{ dd ff }   //elements from the 1st list
----------- concated with
{ gg hh }   
{ gg uu }
{ hh uu }  //elements from the 2nd list

您可以

Concat

列表中的每个元素（必须具有相同数量的元素，或者第二个元素的数量比第一个元素的数量多），如下所示：

{ dd ff }
{ dd ff }
{ dd ff }
{ gg hh }
{ gg uu }
{ hh uu }

List<List<string>> finalList = (from x in firstList
                                join y in secondList
                                on firstList.IndexOf(x) equals secondList.IndexOf(y)
                                select x.Concat(y).ToList()).ToList();

List finalList=（从firstList中的x开始）
加入第二名单
在第一个列表上。IndexOf（x）等于第二个列表。IndexOf（y）
选择x.Concat（y）.ToList（））.ToList（）；

---

或者任何其他方式来完成。您可以使用Zip扩展方法，它是

System.Linq

命名空间的一部分。元组可用于关联两个列表中的值。或者，您可以只查看内部列表

var list1 = new List<List<string>>
{
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" },
};

var list2 = new List<List<string>>
{
    new List<string> { "gg", "hh" },
    new List<string> { "gg", "uu" },
    new List<string> { "hh", "uu" },
};

var result = list1.Zip(list2, (l1, l2) => Tuple.Create(l1, l2)).ToList();

var list1=新列表
{
新列表{“dd”，“ff”}，
新列表{“dd”，“ff”}，
新列表{“dd”，“ff”}，
};
var list2=新列表
{
新列表{“gg”，“hh”}，
新列表{“gg”，“uu”}，
新列表{“hh”，“uu”}，
};
var result=list1.Zip（list2，（l1，l2）=>Tuple.Create（l1，l2））.ToList（）；

您可以使用Zip扩展方法，它是

System.Linq

命名空间的一部分。元组可用于关联两个列表中的值。或者，您可以只查看内部列表

var list1 = new List<List<string>>
{
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" },
};

var list2 = new List<List<string>>
{
    new List<string> { "gg", "hh" },
    new List<string> { "gg", "uu" },
    new List<string> { "hh", "uu" },
};

var result = list1.Zip(list2, (l1, l2) => Tuple.Create(l1, l2)).ToList();

var list1=新列表
{
新列表{“dd”，“ff”}，
新列表{“dd”，“ff”}，
新列表{“dd”，“ff”}，
};
var list2=新列表
{
新列表{“gg”，“hh”}，
新列表{“gg”，“uu”}，
新列表{“hh”，“uu”}，
};
var result=list1.Zip（list2，（l1，l2）=>Tuple.Create（l1，l2））.ToList（）；

另一个选项是循环第一个列表并添加第二个列表中的元素。例如：

var list1 = new List<List<string>> {
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" }};

var list2 = new List<List<string>> {
    new List<string> { "gg", "hh" },
    new List<string> { "gg", "uu" },
    new List<string> { "hh", "uu" }};

for(var j = 0; j < list1.Count(); j++)
{
    list1[j].AddRange(list2[j]);
}

var list1=新列表{
新列表{“dd”，“ff”}，
新列表{“dd”，“ff”}，
新名单{“dd”、“ff”}；
var list2=新列表{
新列表{“gg”，“hh”}，
新列表{“gg”，“uu”}，
新名单{“hh”，“uu”}；
对于（var j=0；j

另一个选项是循环第一个列表并添加第二个列表中的元素。例如：

var list1 = new List<List<string>> {
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" },
    new List<string> { "dd", "ff" }};

var list2 = new List<List<string>> {
    new List<string> { "gg", "hh" },
    new List<string> { "gg", "uu" },
    new List<string> { "hh", "uu" }};

for(var j = 0; j < list1.Count(); j++)
{
    list1[j].AddRange(list2[j]);
}

var list1=新列表{
新列表{“dd”，“ff”}，
新列表{“dd”，“ff”}，
新名单{“dd”、“ff”}；
var list2=新列表{
新列表{“gg”，“hh”}，
新列表{“gg”，“uu”}，
新名单{“hh”，“uu”}；
对于（var j=0；j

不妨使用

list1[j]

而不是

list1.ElementAt（j）

。不妨使用

list1[j]

而不是

list1.ElementAt（j）

。谢谢！我会尝试使用它！谢谢我会尝试使用它！谢谢我会尝试使用它！谢谢我会尝试使用它！事实上，我觉得这是最好的答案。。。我还从你那里学到了新东西：

Zip

：）事实上，我觉得这是最好的答案。。。我还从你那里学到了新东西：

Zip

：）