比较两个通用列表差异的最快方法

比较两个大型项目（> 50.000个项目）最快（且最不占用资源）是什么，因此有两个列表如下：

1. 显示在第一个列表中但不在第二个列表中的项目
2. 出现在第二个列表中但不在第一个列表中的项目

目前，我正在使用List或IReadOnlyCollection，并在linq查询中解决此问题：

var list1 = list.Where(i => !list2.Contains(i)).ToList();
var list2 = list2.Where(i => !list.Contains(i)).ToList();

但这并没有我想要的那样好。有什么想法可以让我更快地处理和减少资源消耗，因为我需要处理很多列表？

用途Except：

var firstNotSecond = list1.Except(list2).ToList();
var secondNotFirst = list2.Except(list1).ToList();

我怀疑有这实际上是略高于这个速度的方法，但即使这样会大大超过你的O（N * M）的方法要快。

如果要组合使用这些方法，则可以使用上面的方法创建一个方法，然后再使用return语句：

return !firstNotSecond.Any() && !secondNotFirst.Any();

要注意的一点是，有是在问题的原代码和这里的解决方案之间的结果有所不同：其中仅在一个列表中的任何重复的元素将只报告一次我的代码，而他们会被报告为多原始代码中出现的次数。

例如，清单[1, 2, 2, 2, 3]和[1]，在“列表1中的元素，但不是列表2”导致原始代码将是[2, 2, 2, 3]。用我的代码就可以了[2, 3]。在许多情况下，这不是问题，但是值得一提。

更有效的方法是使用Enumerable.Except：

var inListButNotInList2 = list.Except(list2);
var inList2ButNotInList = list2.Except(list);

通过使用延迟执行来实现此方法。这意味着您可以编写例如：

var first10 = inListButNotInList2.Take(10);

由于它内部使用a Set<T>比较对象，因此它也是有效的。它的工作方式是首先从第二个序列中收集所有不同的值，然后流式传输第一个结果，并检查它们之前是否未见过。

Enumerable.SequenceEqual方法

根据相等比较器确定两个序列是否相等。 微软文档

Enumerable.SequenceEqual(list1, list2);

这适用于所有原始数据类型。如果需要在自定义对象上使用它，则需要实现IEqualityComparer

定义方法以支持比较对象是否相等。

IEqualityComparer接口

定义方法以支持比较对象是否相等。 IEqualityComparer的MS.Docs

如果您希望结果不区分大小写，则可以执行以下操作：

List<string> list1 = new List<string> { "a.dll", "b1.dll" };
List<string> list2 = new List<string> { "A.dll", "b2.dll" };

var firstNotSecond = list1.Except(list2, StringComparer.OrdinalIgnoreCase).ToList();
var secondNotFirst = list2.Except(list1, StringComparer.OrdinalIgnoreCase).ToList();

firstNotSecond将包含b1.dll

secondNotFirst将包含b2.dll

不是这个问题，但是这里有一些代码比较列表是否相等！相同的对象：

public class EquatableList<T> : List<T>, IEquatable<EquatableList<T>> where    T : IEquatable<T>

/// <summary>
/// True, if this contains element with equal property-values
/// </summary>
/// <param name="element">element of Type T</param>
/// <returns>True, if this contains element</returns>
public new Boolean Contains(T element)
{
    return this.Any(t => t.Equals(element));
}

/// <summary>
/// True, if list is equal to this
/// </summary>
/// <param name="list">list</param>
/// <returns>True, if instance equals list</returns>
public Boolean Equals(EquatableList<T> list)
{
    if (list == null) return false;
    return this.All(list.Contains) && list.All(this.Contains);
}

尝试这种方式：

var difList = list1.Where(a => !list2.Any(a1 => a1.id == a.id))
            .Union(list2.Where(a => !list1.Any(a1 => a1.id == a.id)));

using System.Collections.Generic;
using System.Linq;

namespace YourProject.Extensions
{
    public static class ListExtensions
    {
        public static bool SetwiseEquivalentTo<T>(this List<T> list, List<T> other)
            where T: IEquatable<T>
        {
            if (list.Except(other).Any())
                return false;
            if (other.Except(list).Any())
                return false;
            return true;
        }
    }
}

有时候，你只需要知道，如果两个列表是不同的，而不是那些差异。在这种情况下，请考虑将此扩展方法添加到您的项目中。请注意，列出的对象应实现IEquatable！

用法：

public sealed class Car : IEquatable<Car>
{
    public Price Price { get; }
    public List<Component> Components { get; }

    ...
    public override bool Equals(object obj)
        => obj is Car other && Equals(other);

    public bool Equals(Car other)
        => Price == other.Price
            && Components.SetwiseEquivalentTo(other.Components);

    public override int GetHashCode()
        => Components.Aggregate(
            Price.GetHashCode(),
            (code, next) => code ^ next.GetHashCode()); // Bitwise XOR
}

无论Component是什么类，此处显示的方法Car都应几乎相同地实现。

请务必注意我们如何编写GetHashCode。为了正确实施IEquatable，Equals以及GetHashCode 必须的以逻辑兼容的方式对实例的属性进行操作。

具有相同内容的两个列表仍然是不同的对象，并且将产生不同的哈希码。由于我们希望将这两个列表视为相等，因此我们必须GetHashCode为每个列表产生相同的值。我们可以通过将哈希码委派给列表中的每个元素，并使用标准的按位XOR来将它们全部组合在一起来实现此目的。XOR与订单无关，因此列表的排序方式不同并不重要。它们只包含等效成员，这仅是重要的。

注意：奇怪的名称表示该方法未考虑列表中元素的顺序。如果您确实关心列表中元素的顺序，则此方法不适合您！

我使用此代码来比较两个具有百万条记录的列表。

这种方法不会花费很多时间

    //Method to compare two list of string
    private List<string> Contains(List<string> list1, List<string> list2)
    {
        List<string> result = new List<string>();

        result.AddRange(list1.Except(list2, StringComparer.OrdinalIgnoreCase));
        result.AddRange(list2.Except(list1, StringComparer.OrdinalIgnoreCase));

        return result;
    }

如果仅需要组合的结果，这也将起作用：

var set1 = new HashSet<T>(list1);
var set2 = new HashSet<T>(list2);
var areEqual = set1.SetEquals(set2);

其中T是列表元素的类型。

可能很有趣，但对我有用

string.Join（“”，List1）！= string.Join（“”，List2）

我认为这是一种比较简单的方法，可以逐个元素比较两个列表

x=[1,2,3,5,4,8,7,11,12,45,96,25]
y=[2,4,5,6,8,7,88,9,6,55,44,23]

tmp = []


for i in range(len(x)) and range(len(y)):
    if x[i]>y[i]:
        tmp.append(1)
    else:
        tmp.append(0)
print(tmp)

这是您会发现的最佳解决方案

var list3 = list1.Where(l => list2.ToList().Contains(l));