Enumerable.Zip
Linq中的扩展方法有什么用?
9 回答
Zip 运算符使用指定的选择器函数合并两个序列的相应元素。
var letters= new string[] { "A", "B", "C", "D", "E" };
var numbers= new int[] { 1, 2, 3 };
var q = letters.Zip(numbers, (l, n) => l + n.ToString());
foreach (var s in q)
Console.WriteLine(s);
输出
A1
B2
C3
Zip
用于将两个序列合二为一。例如,如果您有序列
1, 2, 3
和
10, 20, 30
并且您希望将每个序列中相同位置的元素相乘得到的序列获得
10, 40, 90
你可以说
var left = new[] { 1, 2, 3 };
var right = new[] { 10, 20, 30 };
var products = left.Zip(right, (m, n) => m * n);
之所以称为“拉链”,是因为您将一个序列视为拉链的左侧,而将另一个序列视为拉链的右侧,拉链操作员会将两侧拉到一起,从而使牙齿配对(序列的元素)适当地。
它遍历两个序列并将它们的元素一个一个地组合成一个新序列。所以你取序列 A 的一个元素,用序列 B 中的对应元素变换它,结果形成序列 C 的一个元素。
一种思考方式是它类似于Select
,除了不是从单个集合中转换项目,它同时适用于两个集合。
int[] numbers = { 1, 2, 3, 4 };
string[] words = { "one", "two", "three" };
var numbersAndWords = numbers.Zip(words, (first, second) => first + " " + second);
foreach (var item in numbersAndWords)
Console.WriteLine(item);
// This code produces the following output:
// 1 one
// 2 two
// 3 three
如果您要在命令式代码中执行此操作,您可能会执行以下操作:
for (int i = 0; i < numbers.Length && i < words.Length; i++)
{
numbersAndWords.Add(numbers[i] + " " + words[i]);
}
或者如果 LINQ 没有Zip
,你可以这样做:
var numbersAndWords = numbers.Select(
(num, i) => num + " " + words[i]
);
当您将数据分散到简单的类似数组的列表中时,这很有用,每个列表都具有相同的长度和顺序,并且每个都描述同一组对象的不同属性。Zip
帮助您将这些数据组合成一个更连贯的结构。
因此,如果您有一个州名称数组和另一个它们的缩写数组,您可以将它们整理成一个State
类,如下所示:
IEnumerable<State> GetListOfStates(string[] stateNames, int[] statePopulations)
{
return stateNames.Zip(statePopulations,
(name, population) => new State()
{
Name = name,
Population = population
});
}
不要让名字让Zip
你失望。它与压缩文件或文件夹(压缩)无关。它实际上得名于衣服上的拉链是如何工作的:衣服上的拉链有两个面,每面都有一串牙齿。当您朝一个方向前进时,拉链会枚举(移动)两侧并通过咬紧牙齿来关闭拉链。当你朝另一个方向走时,它会打开牙齿。您要么以打开或闭合的拉链结束。
该Zip
方法的想法相同。考虑一个我们有两个集合的例子。一个持有字母,另一个持有以该字母开头的食品名称。为清楚起见,我称它们为leftSideOfZipper
和rightSideOfZipper
。这是代码。
var leftSideOfZipper = new List<string> { "A", "B", "C", "D", "E" };
var rightSideOfZipper = new List<string> { "Apple", "Banana", "Coconut", "Donut" };
我们的任务是制作一个以 a 分隔的水果字母:
及其名称的集合。像这样:
A : Apple
B : Banana
C : Coconut
D : Donut
Zip
救援。为了跟上我们的拉链术语,我们将调用此结果closedZipper
以及我们将调用左侧拉链leftTooth
和右侧拉链的项目,righTooth
原因很明显:
var closedZipper = leftSideOfZipper
.Zip(rightSideOfZipper, (leftTooth, rightTooth) => leftTooth + " : " + rightTooth).ToList();
在上面我们枚举(移动)拉链的左侧和拉链的右侧,并对每个牙齿执行操作。我们正在执行的操作是将左齿(食物字母)与 a 连接:
,然后将右齿(食物名称)连接起来。我们使用以下代码做到这一点:
(leftTooth, rightTooth) => leftTooth + " : " + rightTooth)
最终结果是这样的:
A : Apple
B : Banana
C : Coconut
D : Donut
最后一个字母 E 怎么了?
如果你在枚举(拉)一个真正的衣服拉链和一侧,无论是左侧还是右侧,都比另一侧的牙齿少,会发生什么?那么拉链将停在那里。该Zip
方法将完全相同:一旦到达任一侧的最后一项,它将停止。在我们的例子中,右侧的牙齿(食物名称)较少,因此它将在“甜甜圈”处停止。
这里的很多答案都展示了Zip
,但没有真正解释会激发使用Zip
.
一种特别常见的模式,Zip
非常适合迭代连续成对的事物。这是通过迭代一个可枚举X
的自身来完成的,跳过 1 个元素:x.Zip(x.Skip(1)
。视觉示例:
x | x.Skip(1) | x.Zip(x.Skip(1), ...)
---+-----------+----------------------
| 1 |
1 | 2 | (1, 2)
2 | 3 | (2, 1)
3 | 4 | (3, 2)
4 | 5 | (4, 3)
这些连续的对对于查找值之间的第一个差异很有用。例如,IEnumable<MouseXPosition>
可以使用连续对来产生IEnumerable<MouseXDelta>
. 类似地,a 的采样bool
值button
可以解释为类似NotPressed
// Clicked
/的事件Held
。Released
然后这些事件可以驱动对委托方法的调用。这是一个例子:
using System;
using System.Collections.Generic;
using System.Linq;
enum MouseEvent { NotPressed, Clicked, Held, Released }
public class Program {
public static void Main() {
// Example: Sampling the boolean state of a mouse button
List<bool> mouseStates = new List<bool> { false, false, false, false, true, true, true, false, true, false, false, true };
mouseStates.Zip(mouseStates.Skip(1), (oldMouseState, newMouseState) => {
if (oldMouseState) {
if (newMouseState) return MouseEvent.Held;
else return MouseEvent.Released;
} else {
if (newMouseState) return MouseEvent.Clicked;
else return MouseEvent.NotPressed;
}
})
.ToList()
.ForEach(mouseEvent => Console.WriteLine(mouseEvent) );
}
}
印刷:
NotPressesd
NotPressesd
NotPressesd
Clicked
Held
Held
Released
Clicked
Released
NotPressesd
Clicked
我没有代表点可以在评论部分发布,但要回答相关问题:
如果我希望 zip 在一个列表用完元素的情况下继续执行怎么办?在这种情况下,较短的列表元素应采用默认值。在这种情况下输出为 A1、B2、C3、D0、E0。– 梁 2015 年 11 月 19 日 3:29
您要做的是使用 Array.Resize() 用默认值填充较短的序列,然后将它们一起 Zip() 。
代码示例:
var letters = new string[] { "A", "B", "C", "D", "E" };
var numbers = new int[] { 1, 2, 3 };
if (numbers.Length < letters.Length)
Array.Resize(ref numbers, letters.Length);
var q = letters.Zip(numbers, (l, n) => l + n.ToString());
foreach (var s in q)
Console.WriteLine(s);
输出:
A1
B2
C3
D0
E0
请注意,使用 Array.Resize()有一个警告:Redim Preserve in C#?
如果不知道哪个序列更短,可以创建一个函数来判断它:
static void Main(string[] args)
{
var letters = new string[] { "A", "B", "C", "D", "E" };
var numbers = new int[] { 1, 2, 3 };
var q = letters.Zip(numbers, (l, n) => l + n.ToString()).ToArray();
var qDef = ZipDefault(letters, numbers);
Array.Resize(ref q, qDef.Count());
// Note: using a second .Zip() to show the results side-by-side
foreach (var s in q.Zip(qDef, (a, b) => string.Format("{0, 2} {1, 2}", a, b)))
Console.WriteLine(s);
}
static IEnumerable<string> ZipDefault(string[] letters, int[] numbers)
{
switch (letters.Length.CompareTo(numbers.Length))
{
case -1: Array.Resize(ref letters, numbers.Length); break;
case 0: goto default;
case 1: Array.Resize(ref numbers, letters.Length); break;
default: break;
}
return letters.Zip(numbers, (l, n) => l + n.ToString());
}
普通 .Zip() 与 ZipDefault() 的输出:
A1 A1
B2 B2
C3 C3
D0
E0
回到原始问题的主要答案,人们可能希望做的另一件有趣的事情(当要“压缩”的序列的长度不同时)是以这样一种方式加入它们,以便列表的末尾匹配而不是顶部。这可以通过使用.Skip()“跳过”适当数量的项目来完成。
foreach (var s in letters.Skip(letters.Length - numbers.Length).Zip(numbers, (l, n) => l + n.ToString()).ToArray())
Console.WriteLine(s);
输出:
C1
D2
E3
正如其他人所说,Zip 允许您组合两个集合以用于进一步的 Linq 语句或 foreach 循环。
过去需要 for 循环和两个数组的操作现在可以使用匿名对象在 foreach 循环中完成。
我刚刚发现的一个例子有点傻,但如果并行化是有益的,那么它可能会很有用,那就是具有副作用的单行队列遍历:
timeSegments
.Zip(timeSegments.Skip(1), (Current, Next) => new {Current, Next})
.Where(zip => zip.Current.EndTime > zip.Next.StartTime)
.AsParallel()
.ForAll(zip => zip.Current.EndTime = zip.Next.StartTime);
timeSegments 表示队列中的当前或出列项(最后一个元素被 Zip 截断)。timeSegments.Skip(1) 表示队列中的下一个或查看项目。Zip 方法将这两者组合成一个具有 Next 和 Current 属性的匿名对象。然后我们使用 Where 过滤并使用 AsParallel().ForAll 进行更改。当然,最后一位可能只是一个常规的 foreach 或另一个返回违规时间段的 Select 语句。
Zip 方法允许您使用调用者的合并函数提供程序“合并”两个不相关的序列。MSDN 上的示例实际上很好地展示了您可以使用 Zip 做什么。在此示例中,您获取两个任意的、不相关的序列,并使用任意函数将它们组合(在这种情况下,只需将两个序列中的项目连接成一个字符串)。
int[] numbers = { 1, 2, 3, 4 };
string[] words = { "one", "two", "three" };
var numbersAndWords = numbers.Zip(words, (first, second) => first + " " + second);
foreach (var item in numbersAndWords)
Console.WriteLine(item);
// This code produces the following output:
// 1 one
// 2 two
// 3 three
string[] fname = { "mark", "john", "joseph" };
string[] lname = { "castro", "cruz", "lopez" };
var fullName = fname.Zip(lname, (f, l) => f + " " + l);
foreach (var item in fullName)
{
Console.WriteLine(item);
}
// The output are
//mark castro..etc