我有两个数组,我想知道它们是否包含相同的项目. 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不是更好
我反映了源,它不比较执行循环之前的长度.这是有道理的,因为该方法通常用于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的阵列：并行速度更快
[ SequenceEqual: 00:00:02.357 ] [ ContainsEqSeq: 00:00:03.341 ] [ Parallel: 00:00:01.688 ]*
两个相同的大小50000的阵列：平行踢屁股
[ 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有一个差异的两个数组：平行踢脚踢
[ SequenceEqual: 00:00:02.386 ] [ ContainsEqSeq: 00:00:03.417 ] [ Parallel: 00:00:01.614 ]*
SequenceEqual的代码是
a1.SequenceEqual(a2)
Parallel的代码是
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 []测试,但我相信它也可以是复杂类型的快速.
但请记住,结果会因输入而有所不同.
