我有一个字符串列表 例如{“apple.txt”、“orange.sd.2.txt”、“apple.2.tf.txt”、“orange.txt”} 和另一个字符串列表来分组第一个列表 例如{“苹果”，“橙色”} 这样第一个列表就被拆分成一个列表，看起来像这样：
{{"apple.txt", "apple.2.tf.txt"},{"orange.txt", "orange.sd.2.txt"}}
如何使用 linq 实现这一点？
【问题讨论】：
这个怎么样：
var groupedList = firstList.GroupBy(x => secondList.Single(y => x.Name.Contains(y)));
【讨论】：
First，除非您确定给定的firstList 成员不能有多个键匹配。您可能想要使用FirstOrDefault，除非您肯定每个firstList 成员都将属于一个组。否则，做得很好。
SelectMany 进行更多处理来处理属于多个组的项目：dataToSplit.SelectMany(ds => keyList.Where(k => ds.Contains(k)).Select(k => new { Key = k, Value = ds })) .GroupBy(kds => kds.Key, kds => kds.Value)
您可以使用匿名类型的Split、SelectMany 和GroupBy，将每个原始list 的元素按所有 个可能的键分组：
var list = new List<string> { "apple.txt", "orange.sd.2.txt", "apple.2.tf.txt", "orange.txt" };
var groups = list
.SelectMany(element => element
.Split('.')
.Select(part => new { Part = part, Full = element }))
.GroupBy(entry => entry.Part);
现在您可以使用Where 选择要保留的组，然后使用Select 和ToList 将结果转换为嵌套列表：
var keys = new List<string> { "apple", "orange" };
var result = group
.Where(group => keys.Contains(group.Key))
.Select(group => group
.Select(entry => entry.Full)
.ToList())
.ToList();
注意原始列表中不包含任何指定键的元素将不会出现在结果中，而包含多个指定键的元素将在结果中出现多次。
编辑：正如@NetMage 所指出的，我对拆分字符串做出了错误的假设 - 这是另一个版本，尽管它是O(m * n)：
var result = keys
.Select(key => list.Where(element => element.Contains(key)).ToList())
.ToList();
【讨论】：
keys 转换为 HashSet 我认为这最接近 O(n) 解决方案，尽管我相信处理所有不需要的部分的开销以及拆分的假设在. 上可行意味着它不是最佳答案。
这是一种简单的方法。有很多方法，这将包括重复的密钥作为我对您的问题的评论。如果许多键匹配相同的数据，则分组将包括副本。
// have the list of keys (groups)
var keyList = new List<string>() {"apple", "orange"};
// have the list of all the data to split
var dataToSplit = new List<string>()
{
"apple.txt",
"apple.2.tf.txt",
"orange.txt",
"orange.sd.2.txt"
};
// now split to get just as desired you select what you want for each keys
var groupedData = keyList.Select(key => dataToSplit.Where(data => data.Contains(key)).ToList()).ToList();
// groupedData is a List<List<string>>
以更“对象”的方式获取值的第二个选项是使用匿名。如果您要进行大量操作并且代码中更加“冗长”，则特别好。但如果你是新手，我不推荐这种方法，但无论如何就是这样。
// have the list of keys (groups)
var keyList = new List<string>() {"apple", "orange"};
// have the list of all the data to split
var dataToSplit = new List<string>()
{
"apple.txt",
"apple.2.tf.txt",
"orange.txt",
"orange.sd.2.txt"
};
// create the anonymous
var anonymousGroup = keyList.Select(key =>
{
return new
{
Key = key,
Data = dataToSplit.Where(data => data.Contains(key)).ToList()
}
});
// anonymousGroup is a List<A> where keeping the order you should access all data for orange like this
var orangeGroup = anonymousGroup.FirstOfDefault(o=> o.Key = "orange"); // get the anonymous
var orangeData = orangeGroup.Data; // get the List<string> for that group
第三种方法的复杂度低于 O(m*n)。诀窍是从集合中删除数据，以减少重新检查已处理项目的机会。这是来自我的代码库，它是 List 的扩展，它只是根据谓词从集合中删除项目并返回已删除的内容。
public static List<T> RemoveAndGet<T>(this List<T> list, Func<T, bool> predicate)
{
var itemsRemoved = new List<T>();
// iterate backward for performance
for (int i = list.Count - 1; i >= 0; i--)
{
// keep item pointer
var item = list[i];
// if the item match the remove predicate
if (predicate(item))
{
// add the item to the returned list
itemsRemoved.Add(item);
// remove the item from the source list
list.RemoveAt(i);
}
}
return itemsRemoved;
}
现在有了这个扩展，当你有一个列表时，你可以像这样轻松地使用它：
// have the list of keys (groups)
var keyList = new List<string>() {"apple", "orange"};
// have the list of all the data to split
var dataToSplit = new List<string>()
{
"apple.txt",
"apple.2.tf.txt",
"orange.txt",
"orange.sd.2.txt"
};
// now split to get just as desired you select what you want for each keys
var groupedData = keyList.Select(key => dataToSplit.RemoveAndGet(data => data.Contains(key))).ToList();
在这种情况下，由于两个集合中的顺序，第一个键是 apple，因此它将迭代 dataToSplit 中的 4 个项目并仅保留 2 个并将 dataToSplit 集合减少到 2 个项目仅是具有orange 在其中。在第二个键上，它将仅迭代 2 个项目，这将使其在这种情况下更快。通常，此方法将与我提供的前 2 个方法一样快或更快，同时清晰且仍然使用 linq。
【讨论】：
您可以使用这个简单的代码来实现：
var list1 = new List<string>() {"apple.txt", "orange.sd.2.txt", "apple.2.tf.txt", "orange.txt"};
var list2 = new List<string>() {"apple", "orange"};
var result = new List<List<string>>();
list2.ForEach(e => {
result.Add(list1.Where(el => el.Contains(e)).ToList());
});
【讨论】：
元组来救援！
var R = new List<(string, List<string>)> { ("orange", new List<string>()), ("apple", new List<string>()) };
var L = new List<string> { "apple.txt", "apple.2.tf.txt", "orange.txt", "orange.sd.2.txt" };
R.ForEach(r => L.ForEach(l => { if (l.Contains(r.Item1)) { r.Item2.Add(l); } }));
var resultString = string.Join("," , R.Select(x => "{" + string.Join(",", x.Item2) + "}"));
如果需要，您可以轻松地动态构建 R。
【讨论】：