我有两个整型数组。
int[] data1 #
int[] data2 #
我想创建一个第三个int[]数组data3，用于存储另外两个数组之间的差值。
让我们取data1中的第一个值。
该值为15（例如）。
现在让我们取data2中的第一个值。
该值为3（例如）。
那么data3中的第一个值将是12。
但是，如果第一个值的顺序相反，即data2中的第一个值减去data1中的第一个值，则结果将是负数。
data1[0] = 3
data2[0] = 15
那么差异将是-12。但我希望它只是12。
目前，我有一个for循环，我在那里进行计算以获得那种类型的结果。
谢谢
N.B. 针对“关闭者”的回应。 在某种程度上，我同意你们的看法。 我需要补充的是：
我正在寻找最有效（最快的方式，但内存占用率次之）来实现这一点。 使用Linq（据我所知）可能是最慢的方法？
Zip 方法。var data3 = data1.Zip(data2, (d1,d2) => Math.Abs(d1 - d2)).ToArray();
Enumerable.Zip<TFirst, TSecond, TResult> 方法
将指定函数应用于两个序列的对应元素，生成结果序列。
它简单地取每个对应的元素，例如 data1[0] 和 data2[0]，然后是 data1[1] 和 data2[1]，以此类推... 然后应用函数 Math.Abs(d1-d2)，它仅将两个数字相减并得到结果的绝对值。然后返回包含每个操作结果的序列。
System.LINQ 吗？ - flindeberg有没有一种方法可以在不通过枚举循环的情况下执行 data1-data2 = data3?
不，这在技术上是不可能的。
最好（或者说最坏）的情况是，您可以调用一个函数来为您枚举。但这会使速度变慢。在LINQ的情况下，速度非常慢。
对于我目前正在使用的机器，对于4KB表（1024个整数），其他答案的结果如下：
"循环代码：
for (int i = 0; i < data3.Length; i++)
{
data3[i] = Math.Abs(data1[i] - data2[i]);
}
生成的代码大约比使用 Math.Abs() 的简单循环快8倍；请记住，您只能将循环展开到数据集大小的除数。 您编写的数据集大小为25920，因此8是可以的（最大为64，但我怀疑这样做是否有任何意义）。 我建议将此代码隐藏在某个函数中，因为它非常丑陋。
int[] data3 = new int[data1.Length];
for (int i = 0; i < data1.Length; i += 8)
{
int b;
b = (data1[i + 0] - data2[i + 0]);
data3[i + 0] = b < 0 ? -b : b;
b = (data1[i + 1] - data2[i + 1]);
data3[i + 1] = b < 0 ? -b : b;
b = (data1[i + 2] - data2[i + 2]);
data3[i + 2] = b < 0 ? -b : b;
b = (data1[i + 3] - data2[i + 3]);
data3[i + 3] = b < 0 ? -b : b;
b = (data1[i + 3] - data2[i + 4]);
data3[i + 4] = b < 0 ? -b : b;
b = (data1[i + 5] - data2[i + 5]);
data3[i + 5] = b < 0 ? -b : b;
b = (data1[i + 6] - data2[i + 6]);
data3[i + 6] = b < 0 ? -b : b;
b = (data1[i + 7] - data2[i + 7]);
data3[i + 7] = b < 0 ? -b : b;
}
1 XOR 1 = 0
0 XOR 1 = 1
1 XOR 0 = 1
0 XOR 0 = 0
所以，使用只填充0值的值进行异或操作没有任何效果。
我们可以从我们的数字中获取符号。对于32位整数，它非常简单，即x>>31。它将位符移动到最低位。正如维基百科所说，插入的位从左侧插入将为零，因此对于负数（x<0），x>>31的结果将为1，对于非负数（x>=0）则为0，对吗？
不是这样的。对于带符号的值，使用算术移位而不是纯位移。因此，根据符号，我们将获得-1或0....这意味着对于负数和非负数来说，'x>>31'将分别给出111...111和000...000。如果您将原始x与这种移位的结果进行异或运算，则会执行NOT或NOP，具体取决于值的符号。另一个有用的事情是，0将导致加法/否定的NOP，因此我们可以根据值的符号添加/减去-1。
所以'x^(x>>31)'将翻转负数的位，而对非负数不做任何更改，'x-(x>>31)'将给负数x加1（否定的负值给出正值），并对非负值不做任何更改。
当组合在一起时，你会得到'(x ^ (x >> 31)) - (x >> 31)'... 这可以翻译为：
IF X<0
X=!X+1
而且这只是
IF X<0
X=-X
for (int i = 0; i < data1.Length; i++)
{
int x = data1[i] - data2[i];
data3[i] = (x ^ (x >> 31)) - (x >> 31);
}
CPU拥有超快的缓存内存，当按顺序处理数组时，它会将整个块复制到缓存中。 但是，如果你编写糟糕的代码，就会出现缓存未命中。你可以通过 搞乱嵌套循环的顺序 轻易地陷入这个陷阱。
并行性（多线程，同样的数据）必须按顺序分块处理，以充分利用CPU缓存。
手动编写线程将允许你手动选择线程的块，但这是一个麻烦的方法。 自4.0版本起，.NET提供了帮助程序，但默认的 Parallel.For 会搞乱缓存。 因此，由于 缓存未命中，这段代码实际上比单线程版本更慢。
Parallel.For(0, data1.Length,
fn =>
{
int x = data1[fn] - data2[fn];
data3[fn] = (x ^ (x >> 31)) - (x >> 31);
}
通过在缓存数据中执行顺序操作，可以手动利用缓存数据。例如，您可以展开循环，但这是一种不良的技巧，并且展开具有自己的性能问题（这取决于CPU型号）。
Parallel.For(0, data1.Length >> 3,
i =>
{
int b;
b = (data1[i + 0] - data2[i + 0]);
data3[i + 0] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 1] - data2[i + 1]);
data3[i + 1] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 2] - data2[i + 2]);
data3[i + 2] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 3] - data2[i + 3]);
data3[i + 3] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 3] - data2[i + 4]);
data3[i + 4] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 5] - data2[i + 5]);
data3[i + 5] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 6] - data2[i + 6]);
data3[i + 6] = b < 0 ? (b ^ -1) + b : b;
b = (data1[i + 7] - data2[i + 7]);
data3[i + 7] = b < 0 ? (b ^ -1) + b : b;
}
var rangePartitioner = Partitioner.Create(0, data1.Length);
Parallel.ForEach(rangePartitioner, (range, loopState)
=>
{
for (int i = range.Item1; i < range.Item2; i++)
{
int x = data1[i] - data2[i];
data3[i] = (x ^ (x >> 31)) - (x >> 31);
}
});
GetDifference比你的循环慢20倍？我也只是使用了一个循环，所以代码完全相同。另外，你是如何测试它的呢？我还会删除那个以“这样基本的内存操作”开头的句子，因为它非常令人困惑，而LINQ通常并不明显地低效。 - Tim SchmelterStopwatch而不是DateTime。 - Tim Schmelter这里有另一种方法（可能不太易读，但可能更加高效），它不需要使用LINQ：
public static int[] GetDifference(int[] first, int[] second)
{
int commonLength = Math.Min(first.Length, second.Length);
int[] diff = new int[commonLength];
for (int i = 0; i < commonLength; i++)
diff[i] = Math.Abs(first[i] - second[i]);
return diff;
}
为什么要“稍微更高效”？因为ToArray需要调整数组大小，直到知道最终大小为止。（参考链接）
var data3 = data1.Select((x,i)=>new {x,i})
.Join
(
data2.Select((x,i)=>new {x,i}),
x=>x.i,
x=>x.i,
(d1,d2)=>Math.Abs(d1.x-d2.x)
)
.ToArray();