我有两个数组,我想知道它们是否包含相同的项。 Equals(object obj)
不起作用,因为数组是引用类型。我在下面发布了我的尝试,但由于我确定这是一项常见任务,所以我想知道是否有更好的测试。
public bool ContainsEquivalentSequence<T>(T[] array1, T[] array2)
{
bool a1IsNullOrEmpty = ReferenceEquals(array1, null) || array1.Length == 0;
bool a2IsNullOrEmpty = ReferenceEquals(array2, null) || array2.Length == 0;
if (a1IsNullOrEmpty) return a2IsNullOrEmpty;
if (a2IsNullOrEmpty || array1.Length != array2.Length) return false;
for (int i = 0; i < array1.Length; i++)
if (!Equals(array1[i], array2[i]))
return false;
return true;
}
更新 - System.Linq.Enumerable.SequenceEqual 不是更好
我反射(reflect)了来源,它在执行循环之前不比较长度。这是有道理的,因为该方法通常是为 IEnumerable<T>
设计的。 , 不适用于 T[]
.
public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
{
if (comparer == null)
{
comparer = EqualityComparer<TSource>.Default;
}
if (first == null)
{
throw Error.ArgumentNull("first");
}
if (second == null)
{
throw Error.ArgumentNull("second");
}
using (IEnumerator<TSource> enumerator = first.GetEnumerator())
{
using (IEnumerator<TSource> enumerator2 = second.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (!enumerator2.MoveNext() || !comparer.Equals(enumerator.Current, enumerator2.Current))
{
return false;
}
}
if (enumerator2.MoveNext())
{
return false;
}
}
}
return true;
}
最佳答案
我已经使用 Any
、Contains
、All
和 SequenceEqual
进行了一些测试,然后我选择了最好的3.
不同的输入有不同的结果...
两个相同的大小为 100 的数组:SequenceEqual
更快
[ SequenceEqual: 00:00:00.027 ]*
[ ContainsEqSeq: 00:00:00.046 ]
[ Parallel: 00:00:00.281 ]
两个相同的大小为 1000 的数组:SequenceEqual
更快
[ SequenceEqual: 00:00:00.240 ]*
[ ContainsEqSeq: 00:00:00.361 ]
[ Parallel: 00:00:00.491 ]
两个相同的大小为 10000 的数组:Parallel
更快
[ SequenceEqual: 00:00:02.357 ]
[ ContainsEqSeq: 00:00:03.341 ]
[ Parallel: 00:00:01.688 ]*
两个相同的大小为 50000 的数组:Parallel
kick ass
[ SequenceEqual: 00:00:11.824 ]
[ ContainsEqSeq: 00:00:17.206 ]
[ Parallel: 00:00:06.811 ]*
两个数组在位置 200 处有一个差异:SequenceEqual
更快
[ SequenceEqual: 00:00:00.050 ]*
[ ContainsEqSeq: 00:00:00.075 ]
[ Parallel: 00:00:00.332 ]
在位置 0 有一个差异的两个数组:ContainsEqSeq
和 SequenceEqual
更快
[ SequenceEqual: 00:00:00.002 ]*
[ ContainsEqSeq: 00:00:00.001 ]*
[ Parallel: 00:00:00.211 ]
两个数组在位置 999 有一个不同:SequenceEqual
更快
[ SequenceEqual: 00:00:00.237 ]*
[ ContainsEqSeq: 00:00:00.330 ]
[ Parallel: 00:00:00.691 ]
两个数组在位置 9999 有一个不同:Parallel
kick ass
[ SequenceEqual: 00:00:02.386 ]
[ ContainsEqSeq: 00:00:03.417 ]
[ Parallel: 00:00:01.614 ]*
SequenceEqual
的代码是
a1.SequenceEqual(a2)
ContainsEqSeq
的代码就是您的方法。
并行
的代码是
bool a1IsNullOrEmpty = ReferenceEquals(a1, null) || a1.Length == 0;
bool a2IsNullOrEmpty = ReferenceEquals(a2, null) || a2.Length == 0;
if (a1IsNullOrEmpty) return a2IsNullOrEmpty;
if (a2IsNullOrEmpty || a1.Length != a2.Length) return false;
var areEqual = true;
Parallel.ForEach(a1,
(i, s, x) =>
{
if (a1[x] != a2[x])
{
areEqual = false;
s.Stop();
}
});
return areEqual;
我会说最好的取决于您的输入。
如果你将使用巨大的数组(比如 10000+)我会说 Parallel
是最好的选择,它只会在开始时有差异时才会失败。
对于其他情况,SequenceEqual
可能是最好的,我只使用 int[]
进行了测试,但我相信它也可以快速处理复杂类型。
但请记住,结果会因输入而异。
关于c# - 如何最有效地测试两个数组是否包含 C# 中的等效项,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/7086234/