Question

我在迭代list<list<object>>时遇到了一个真正的问题，并想向任何人询问他们的见解。

你可以看到我有一个list<list<object>> posCheckOptions，其中包含32个列表，每个列表包含x个对象，即348为0,325为1等。

例如，在348的这个列表中，有一些重复的元素我想删除。一式两份，我的意思是，股票的名称可能是相同的，所以，如果我说VODAFONE 4次，我想在每次发现Vodafone时添加每股的数量，并删除重复数据。< / p>

for(int k = 0; k<posCheckOptions.Count; k++)
{

int l = 0;
int m = 1;

while (l != m) 
{


    foreach(var x in posCheckOptions[k][l].name)
    {

         if(posCheckOptions[k][l].date != posCheckOptions[k][m].date 
            && posCheckOptions[k][l].strike != posCheckOptions[k][m].strike 
             && posCheckOptions[k][l].callPut != posCheckOptions[k][m].callPut)

               {
                    m++;
               }

               else
               {

           posCheckOptions[k][l].size = posCheckOptions[k][l].size + posheckOptions[k][m].size;

                                posCheckOptions[k].RemoveAt(m);

                                m--;

                }



                }

                    l++; m = l;
     }
}

我正在尝试编码，至少我的想法是，我从posCheckOptions [0] [0]开始，并将元素posCheckOptions[0][0].date与posCheckOptions[0][1].date进行比较（我比较4个字段）（{{ 1}}是一个列表，其中类型T是一个有76个变量的类）。如果我比较的不相等（即不重复我将索引向上移动并继续到下一个，依此类推。如果我找到一个重复的元素，我的旅行，我做添加和删除，将索引移回一个并开始直到我到达终点。

我对这个事实感到困惑，我不确定我是否需要在j poscheckOptions中运行2个索引，因为j只会转到j + 1一次说索引m已经循环了所有348个元素。如果我删除2 ....这可能不是348 ....

任何建议都非常受欢迎： - ）

Answer 1

使用LINQ看起来您的问题很容易解决。我将在简化示例中展示它，因此您必须将其调整为真实的。

假设我们有一个类名Item，如下所示：

public class Item
{
    public int Key { get; set; }
    public int SubKey { get; set; }
    public int Quantity { get; set; }
}

列表（List<Item>）：

var items = new List<Item>() {
    new Item { Key = 1, SubKey = 1, Quantity = 100 },
    new Item { Key = 1, SubKey = 2, Quantity = 400 },
    new Item { Key = 2, SubKey = 1, Quantity = 60 },
    new Item { Key = 1, SubKey = 1, Quantity = 10 },
    new Item { Key = 2, SubKey = 1, Quantity = 30 },
    new Item { Key = 1, SubKey = 1, Quantity = 70 }
};

现在，我们想要对Quantity和Key同一对的元素求SubKey（这也将删除重复项）。 LINQ中有GroupBy方法，所以让我们使用它：

var groupedItems = items.GroupBy(x => new { x.Key, x.SubKey })
                        .Select(g => new Item {
                            Key = g.Key.Key,
                            SubKey = g.Key.SubKey,
                            Quantity = g.Sum(x => x.Quantity)
                        }).ToList();

因此，我们有一个新的List<Item>，每个Key / SubKey对只有一个元素，Quantity是Quantit的总和具有该密钥对的项目。

可以将<List<List<Item>>扩展为输入和输出吗？当然可以。

源嵌套Item集合：

var nestedItems = new List<List<Item>>() {
    new List<Item>() {
        new Item { Key = 1, SubKey = 1, Quantity = 100 },
        new Item { Key = 1, SubKey = 2, Quantity = 400 },
        new Item { Key = 2, SubKey = 1, Quantity = 60 },
        new Item { Key = 1, SubKey = 1, Quantity = 10 },
        new Item { Key = 2, SubKey = 1, Quantity = 30 },
        new Item { Key = 1, SubKey = 1, Quantity = 70 }
    },
    new List<Item>() {
        new Item { Key = 1, SubKey = 1, Quantity = 100 },
        new Item { Key = 1, SubKey = 2, Quantity = 400 },
        new Item { Key = 2, SubKey = 1, Quantity = 60 },
        new Item { Key = 1, SubKey = 1, Quantity = 10 },
        new Item { Key = 2, SubKey = 1, Quantity = 30 },
        new Item { Key = 1, SubKey = 1, Quantity = 70 }
    },
    new List<Item>() {
        new Item { Key = 1, SubKey = 1, Quantity = 100 },
        new Item { Key = 1, SubKey = 2, Quantity = 400 },
        new Item { Key = 2, SubKey = 1, Quantity = 60 },
        new Item { Key = 1, SubKey = 1, Quantity = 10 },
        new Item { Key = 2, SubKey = 1, Quantity = 30 },
        new Item { Key = 1, SubKey = 1, Quantity = 70 }
    }
};

查询：

var nestedGroupedItems = nestedItems.Select(x => x.GroupBy(y => new {y.Key, y.SubKey })
                                                  .Select(g => new Item {
                                                      Key = g.Key.Key,
                                                      SubKey = g.Key.SubKey,
                                                      Quantity = g.Sum(y => y.Quantity)
                                                  }).ToList()).ToList();

Answer 2

我建议你做以下事情：

将IComparable接口实现为列表中对象所属的类型。这样您就可以将比较逻辑存储在类型本身中。
创建此类型的列表（就像posCheckOptions中的列表一样）。让我们称之为bigList
遍历posCheckOptions
迭代所包含列表中的每个项目，并检查该项目是否包含在bigList中。如果是，请从当前内部列表中删除它。如果不将其添加到bigList

Answer 3

我对包含您的股票信息的类型做了一些假设，可以根据需要随意调整。您可以做的是创建一个字典，将股票名称映射到股票对象。更新字典中的对象（如果存在），或将其添加到字典中。

var allStock = mylist.SelectMany(l => l.Select(inner => inner));
var lookup = new Dictionary<string, Stock>();
foreach (var stock in allStock)
{
    if (!lookup.ContainsKey(stock.Name)) {
        lookup.Add(stock.Name, stock);
        continue;
    }
    lookup[stock.Name].Quantity += stock.Quantity;
}

现在您有一个字典将库存名称映射到实际库存。如果你需要的话，只需迭代这些值就可以得到一个列表。

如何索引嵌套列表？

3 个答案: