c# - 如何索引嵌套列表？

Question

我在迭代 a 时遇到了一个真正的问题list<list<object>>，并且想请教任何人的见解。

如您所见，我有一个list<list<object>> posCheckOptions包含 32 个列表的列表，每个列表包含 x 个对象，即 348 表示 0，325 表示 1 等。

例如，在这个 348 个列表中，有我想删除的重复元素。重复我的意思是，股票的名称可能相同，因此，如果我说 VODAFONE 4 次，我想将每个股票的数量添加到第一次发现 Vodafone 并删除重复项。

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 个字段）进行比较（poscheckOptions是一个列表，其类型 T 是一个具有 76 个变量的类）。如果我比较的不相等（即不重复，我将索引向上移动并继续到下一个，依此类推。在我的旅行中，如果我发现一个重复的元素，我会进行添加和删除，将索引移回一个并开始直到我到达终点。

我对这个事实感到困惑，我不确定我是否需要在 j 中运行 2 个索引，posCheckOptions[0][j]因为一旦说索引 m 循环了所有 348 个元素，j 只会进入 j+1。如果我删除 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>只有一个元素，它是具有该密钥对的项目的 ies 总和。KeySubKeyQuantityQuantit

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

源嵌套Items 集合：

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

我建议执行以下操作：

1. 实现IComparable列表中对象的类型的接口。这样，您可以将比较逻辑存储在类型本身中。
2. 创建一个这种类型的列表（就像 中的列表一样posCheckOptions）。让我们称之为bigList
3. 遍历所有列表posCheckOptions
4. 遍历包含列表中的每个项目并检查该项目是否包含在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;
}

现在您有了一个字典，将股票名称映射到实际股票。如果这是您需要的，只需遍历这些值即可得到一个列表。