C#比较两个集合的更有效方法

Question

我有两个收藏

List<Car> currentCars = GetCurrentCars();
List<Car> newCars = GetNewCars();

我不想使用 foreach 循环或其他东西，因为我认为应该有更好的方法来做到这一点。

我正在寻找更有效的方法来比较这些集合并获得结果：

1. newCars 中而不是 currentCars 中的汽车列表
2. 不在 newCars 和 currentCars 中的汽车列表

类型 Car 具有 int 属性 Id。

有一个答案，已被删除说 我所说的高效是什么意思：更少的代码、更少的机制和更易读的案例

那么这样想我有什么案例？

什么是更少的代码、更少的机制和更易读的案例？

Answer 1

你可以这样做：

// 1) List of cars in newCars and not in currentCars
var newButNotCurrentCars = newCars.Except(currentCars);

// 2) List of cars in currentCars and not in newCars
var currentButNotNewCars = currentCars.Except(newCars);

代码使用Enumerable.Except 扩展方法（在.Net 3.5 及更高版本中可用）。

我相信这符合您“更少代码、更少机制和更易读”的标准。

Answer 2

你可以使用Except:

var currentCarsNotInNewCars = currentCars.Except(newCars);
var newCarsNotInCurrentCars = newCars.Except(currentCars);

但这与foreach 解决方案相比没有性能优势。它看起来更干净。
另外，请注意，您需要为您的 Car 类实现 IEquatable<T>，因此比较是在 ID 而不是参考上进行的。

就性能而言，更好的方法是不使用List<T>，而是使用Dictionary<TKey, TValue>，并将ID作为键：

var currentCarsDictionary = currentCars.ToDictionary(x => x.ID);
var newCarsDictionary = newCars.ToDictionary(x => x.ID);

var currentCarsNotInNewCars = 
    currentCarsDictionary.Where(x => !newCarsDictionary.ContainsKey(x.Key))
                         .Select(x => x.Value);

var newCarsNotInCurrentCars = 
    newCarsDictionary.Where(x => !currentCarsDictionary.ContainsKey(x.Key))
                     .Select(x => x.Value);

Answer 3

如果你从HashSets 开始，你可以使用Except 方法。

HashSet<Car> currentCars = GetCurrentCars();
HashSet<Car> newCars = GetNewCars();

currentCars.Except(newCars);
newCars.Except(currentCars);

使用集合比使用列表要快得多。 （在后台，列表只是做一个 foreach，集合可以优化）。

Answer 4

您可以使用 LINQ...

        List<Car> currentCars = new List<Car>();
        List<Car> newCars = new List<Car>();

        List<Car> currentButNotNew = currentCars.Where(c => !newCars.Contains(c)).ToList();
        List<Car> newButNotCurrent = newCars.Where(c => !currentCars.Contains(c)).ToList();

...但不要上当。对你来说可能代码更少，但肯定会有一些 for 循环在某个地方

编辑：没有意识到有一个例外方法:(

Answer 5

我会覆盖 Car 的 Equals 以按 id 进行比较，然后您可以使用 IEnumerable.Except 扩展方法。如果您无法覆盖 Equals，您可以创建自己的 IEqualityComparer<Car>，它通过 id 比较两辆汽车。

class CarComparer : IEqualityComparer<Car>
{
    public bool Equals(Car x, Car y)
    {
        return x != null && y != null && x.Id == y.Id;
    }

    public int GetHashCode(Car obj)
    {
        return obj == null ? 0 : obj.Id;
    }
}

Answer 6

如果您正在寻找效率，请在 Cars 上实现 IComparable（按您的唯一 ID 排序）并使用 SortedList。然后，您可以一起浏览您的集合并在 O(n) 中评估您的检查。这当然会增加 List 插入的成本以保持排序的性质。

Answer 7

您可以将较小的列表复制到基于哈希表的集合（如 HashSet 或 Dictionary）中，然后遍历第二个列表并检查该项目是否存在于哈希表中。

这将把时间从 foreach 案例中的幼稚 foreach 中的 O(N^2) 减少到 O(N)。

这是您在不了解列表的情况下可以做的最好的事情（例如，如果列表经过排序，您可能会做得更好，但是，因为您必须“触摸”每辆车至少检查一次，以检查它是否在新车清单上，你永远不会比 O(N)) 做得更好

Answer 8

如果 Id 属性的比较足以让您判断 Car 是否与另一个 Car 相等，为了避免某种循环，您可以使用自己的类覆盖 List 来跟踪项目并使用IEqualityComparer 在整个集合上，像这样：

class CarComparer : IList<Car>, IEquatable<CarComparer>
{
    public bool Equals(CarComparer other)
    {
        return object.Equals(GetHashCode(),other.GetHashCode());
    }

    public override int GetHashCode()
    {
        return _runningHash;
    }

    public void Insert(int index, Car item)
    {
        // Update _runningHash here
        throw new NotImplementedException();
    }

    public void RemoveAt(int index)
    {
        // Update _runningHash here
        throw new NotImplementedException();
    }

    // More IList<Car> Overrides ....
}

然后，您只需覆盖Add、Remove 等以及任何其他可能影响列表中项目的方法。然后，您可以保留一个私有变量，它是列表中项目的某种 Id 的哈希值。当覆盖你的 Equals 方法时，你可以只比较这个私有变量。到目前为止，这不是最干净的方法（因为您必须跟上您的哈希变量），但它会导致您不必循环进行比较。如果是我，我会像这里提到的那样使用 Linq...