11

我有两个列表

ListA<Emp>两者ListB<Emp> 都有 1000 条记录。

Emp是员工类的对象。下面是我的Employee课

public class Employee
{
    int ID = 0;
    string Name = String.Empty;
    string Dept = String.Empty;
    string Address = String.Empty;
    int Age = 0;
    string Email = String.Empty;
}

我想验证两个列表是否相等。Emp 对象可以按不同的顺序放置。此外，可能有几个 Emp 对象在两个列表中具有完全相同的信息。我也必须验证这些。

我尝试对列表进行排序并使用比较SequenceEqual

Enumerable.SequenceEqual(ListA.OrderBy(s => s), ListB.OrderBy(s => s)

我得到以下错误

At least one object must implement IComparable.
Exception Stack trace is as below 

   at System.Collections.Comparer.Compare(Object a, Object b)
   at System.Collections.Generic.ObjectComparer`1.Compare(T x, T y)
   at System.Linq.EnumerableSorter`2.CompareKeys(Int32 index1, Int32 index2)
   at System.Linq.EnumerableSorter`1.QuickSort(Int32[] map, Int32 left, Int32 right)
   at System.Linq.EnumerableSorter`1.Sort(TElement[] elements, Int32 count)
   at System.Linq.OrderedEnumerable`1.<GetEnumerator>d__0.MoveNext()
   at System.Linq.Enumerable.SequenceEqual[TSource](IEnumerable`1 first, IEnumerable`1 second, IEqualityComparer`1 comparer)
   at System.Linq.Enumerable.SequenceEqual[TSource](IEnumerable`1 first, IEnumerable`1 second)

我该如何实现呢？另外，如果你们能提供给我最快的方法会更好，因为 List 中的对象数量可能会增长到 1000 万。谢谢你的帮助 ！

编辑：每个员工都必须在两个列表中，顺序无关紧要。但是，如果 ListA 包含 5 次相同的员工对象（这意味着一些重复的条目），而 ListB 包含 4 次员工对象，则 ListA 和 ListB 不相等。

4

6 回答 6

8

您可以使用SequenceEqual 自定义IEqualityComparer<Employee>：

class EmployeeComparer : IEqualityComparer<Employee>
{
    public bool Equals(Employee x, Employee y)
    {
        if (x == null || y == null) return false;

        bool equals = x.ID==y.ID && x.Name == y.Name && x.Dept == y.Dept 
            && x.Address == y.Address && x.Age == y.Age && x.Email == y.Email;
        return equals;
    }

    public int GetHashCode(Employee obj)
    {
        if (obj == null) return int.MinValue;

        int hash = 19;
        hash = hash + obj.ID.GetHashCode();
        hash = hash + obj.Name.GetHashCode();
        hash = hash + obj.Dept.GetHashCode();
        hash = hash + obj.Address.GetHashCode();
        hash = hash + obj.Age.GetHashCode();
        hash = hash + obj.Email.GetHashCode();
        return hash;
    }
}

现在很简单：

listA.SequenceEqual(ListB, new EmployeeComparer());

如果订单不重要并且您只想知道所有员工是否都在两个列表中，您可以使用HashSet<Employee>.SetEquals来确定两个列表是否包含相同的人：

var empComparer =  new EmployeeComparer();
bool bothEqual = new HashSet<Employee>(ListA, empComparer)
      .SetEquals(new HashSet<Employee>(ListB, empComparer));
于 2013-01-09T14:00:10.513 回答
5

最佳复杂度是 O(N) 以下使用 HashSet 实现：

实现 GetHashCode 和 Equals 的类：

public class Employee
{
    public int ID = 0;
    public string Name = String.Empty;
    public string Dept = String.Empty;
    public string Address = String.Empty;
    public int Age = 0;
    public string Email = String.Empty;

    public override int GetHashCode()
    {
        return
            ID.GetHashCode() ^
            (Name ?? String.Empty).GetHashCode() ^
            (Dept ?? String.Empty).GetHashCode() ^
            (Address ?? String.Empty).GetHashCode() ^
            Age.GetHashCode() ^
            (Email ?? String.Empty).GetHashCode()
            ;
    }
    public override bool Equals(object obj)
    {
        Employee other = obj as Employee;
        if (obj == null)
            return false;

        return ID == other.ID &&
                Name == other.Name &&
                Dept == other.Dept &&
                Address == other.Address &&
                Age == other.Age &&
                Email == other.Email;
    }
}

比较列表的功能：

public static bool CompareLists(List<Employee> list1, List<Employee> list2)
{
    if (list1 == null || list2 == null)
        return list1 == list2;

    if (list1.Count != list2.Count)
        return false;
    Dictionary<Employee, int> hash = new Dictionary<Employee, int>();
    foreach (Employee employee in list1)
    {
        if (hash.ContainsKey(employee))
        {
            hash[employee]++;
        }
        else
        {
            hash.Add(employee, 1);
        }
    }

    foreach (Employee employee in list2)
    {
        if (!hash.ContainsKey(employee) || hash[employee] == 0)
        {
            return false;
        }
        hash[employee]--;
    }

    return true;
}
于 2013-01-09T14:10:42.043 回答
1

如果列表中的数字将变得巨大（10M），您可能必须考虑并行化查找以获得可接受的查询时间。

考虑使用PLINQ。

更清楚你所说的“平等”是什么意思会很好。等效性检查有多复杂？您是在检查对象是否相同或对象值是否相同？

另一个考虑因素是这个；如果元素的数量会变得很大，您是否可以考虑将此检查从 .NET 移到您的数据库中 - 也许作为存储过程？您可能会发现它在那里执行效率更高。

于 2013-01-09T13:58:15.703 回答
1

将列表简化为标量类型：int、string、....

L1.Select(x => x.K).ToArray()

使用 except 方法

L1.Select(x => x.K).ToArray().Except(L1.Select(x => x.K).ToArray())

如果结果集的计数为 0，则列表等于

L1.Select(x => x.K).ToArray().Except(L1.Select(x => x.K).ToArray()).Count()

全部一起

public class Program {
    public static void Main(String[] args) {
        List<O> L1 = new List<O>{
            new O {K = 1, V = "abcd"},
            new O {K = 2, V = "efgh"}
        };
        List<O> L2 = new List<O>{
            new O {K = 1, V = "abcd"}
        };
        List<O> L3 = new List<O>{
            new O {K = 1, V = "abcd"},
            new O {K = 3, V = "ijkl"}
        };
        List<O> L4 = new List<O>{
            new O {K = 2, V = "efgh"},
            new O {K = 1, V = "abcd"}

        };

        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L1.Select(x => x.K).ToArray()).Count());
        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L2.Select(x => x.K).ToArray()).Count());
        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L3.Select(x => x.K).ToArray()).Count());
        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L4.Select(x => x.K).ToArray()).Count());

    }
} 

public class O {
    public int K { get; set; }
    public String V { get; set; }
}
于 2013-01-09T14:07:23.203 回答
1

正是它所说的。
在 Employee 类上实现 IComparable
还需要重写 Equals
由于可能有大量对 GetHashCode 的调用将其保存并仅计算更改。
经过测试

IComparable 接口

public MainWindow()
{
    InitializeComponent();
    List<Person> PLa = new List<Person>();
    List<Person> PLb = new List<Person>();

    PLa.Add(new Person { Age = 3, Name = "Jim"});
    PLa.Add(new Person { Age = 2, Name = "Jimmmy" });
    PLa.Add(new Person { Age = 1, Name = "Jim" });

    PLb.Add(new Person { Age = 1, Name = "Jim" });
    PLb.Add(new Person { Age = 3, Name = "Jim" });
    PLb.Add(new Person { Age = 2, Name = "Jimmmy" });

    System.Diagnostics.Debug.WriteLine(ListSameIgnoreOrder(PLa, PLb));

}

public bool ListSameIgnoreOrder(List<Person> PLa, List<Person> PLb)
{
    if (PLa.Count != PLb.Count) return false;
    //PLa.Sort();
    //PLb.Sort();
    return Enumerable.SequenceEqual(PLa.OrderBy(s => s), PLb.OrderBy(s => s));
    //for (int i = 0; i < PLa.Count; i++)
    //{
    //    System.Diagnostics.Debug.WriteLine(
    //        PLa[i].Age.ToString() + " " + PLb[i].Age.ToString() + " " +
    //        PLa[i].Name + " " + PLb[i].Name);
    //    if (!PLa[i].Equals(PLb[i])) return false;
    //}
    //return true;
}

public class Person : object, IComparable
{
    private int age = 0;
    private string name = string.Empty;
    private int hash;

    public int Age
    {
        get { return age; }
        set 
        {
            if (age == value) return;
            age = value;
            CalcHash();
        }
    }
    public string Name
    {
        get { return name; }
        set 
        { 
            if (name == value) return;
            name = value;
            CalcHash();
        }
    }

    public override bool Equals(Object obj)
    {
        //Check for null and compare run-time types.
        if (obj == null || !(obj is Person)) return false;
        Person f = (Person)obj;
        if (f.Age != this.Age) return false;
        return (string.Compare(f.name, this.name) == 0);
    }

    private void CalcHash()
    {
        hash = Age.GetHashCode() ^
            (Name ?? String.Empty).GetHashCode();
    }

    public override int GetHashCode()
    {
        return hash;
        //return age ^ name.GetHashCode();
    }

    public int CompareTo(object obj)
    {
        if (obj == null) return 1;

        Person otherPerson = obj as Person;
        if (otherPerson != null)
        {
            if (otherPerson.Age > this.Age) return -1;
            if (otherPerson.Age < this.Age) return 1;
            // compare all properties like above
            return string.Compare(otherPerson.name, this.name);
        }
        else
            throw new ArgumentException("Object is not a Person");
    }
    public Person() { CalcHash(); }
}
于 2013-01-09T14:08:32.777 回答
0

这行得通。

public bool EqualList(Dictionary<int, string> a, Dictionary<int, string> b)
{
    if (a.Count == b.Count)
    {
        bool rs = false;
        foreach (var i in a)
        {
            if (b.ContainsKey(i.Key))
            {
                rs = true;
            }
            else
            {
                rs = false;
                break;
            }
        }
        return rs;
    }
    else
    {
        return false;
    }

用法：

if(EqualList(List<A>.ToDictionary(k => k.Key, k => k.Value), List<B>.ToDictionary(k => k.Key, k => k.Value)){

}else{

}
于 2017-03-22T07:09:26.480 回答