【C#】list 去重（转载）

小贝

Enumerable.Distinct 方法 是常用的LINQ扩展方法，属于System.Linq的Enumerable方法，可用于去除数组、集合中的重复元素，还可以自定义去重的规则。

有两个重载方法：

1. //
2. // 摘要:
3. // 通过使用默认的相等比较器对值进行比较返回序列中的非重复元素。
4. //
5. // 参数:
6. // source:
7. // 要从中移除重复元素的序列。
8. //
9. // 类型参数:
10. // TSource:
11. // source 中的元素的类型。
12. //
13. // 返回结果:
14. // 一个 System.Collections.Generic.IEnumerable<T>，包含源序列中的非重复元素。
15. //
16. // 异常:
17. // System.ArgumentNullException:
18. // source 为 null。
19. public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source);
20. //
21. // 摘要:
22. // 通过使用指定的 System.Collections.Generic.IEqualityComparer<T> 对值进行比较返回序列中的非重复元素。
23. //
24. // 参数:
25. // source:
26. // 要从中移除重复元素的序列。
27. //
28. // comparer:
29. // 用于比较值的 System.Collections.Generic.IEqualityComparer<T>。
30. //
31. // 类型参数:
32. // TSource:
33. // source 中的元素的类型。
34. //
35. // 返回结果:
36. // 一个 System.Collections.Generic.IEnumerable<T>，包含源序列中的非重复元素。
37. //
38. // 异常:
39. // System.ArgumentNullException:
40. // source 为 null。
41. public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);

复制代码

第一个方法不带参数，第二个方法需要传一个System.Collections.Generic.IEqualityComparer的实现对象

1.值类型元素集合去重

1. List<int> list = new List<int> { 1, 1, 2, 2, 3, 4, 5, 5 };
2. list.Distinct().ToList().ForEach(s => Console.WriteLine(s));

复制代码

执行结果是：1 2 3 4 5

2.引用类型元素集合去重

首先自定义一个Student类

1. public class Student
2. {
3. public string Name { get; private set; }
4. public int Id { get; private set; }
5. public string Hobby { get; private set; }
6. public Student(string name, int id, string hobby)
7. {
8. this.Name = name;
9. this.Id = id;
10. this.Hobby = hobby;
11. }
12. /// <summary>
13. /// 方便输出，重写ToString方法
14. /// </summary>
15. /// <returns></returns>
16. public override string ToString()
17. {
18. return string.Format("{0}\t小贝\t{2}", this.Name, this.Id, this.Hobby);
19. }
20. }

复制代码

使用不到参数的Distinct方法去重

1. List<Student> list = new List<Student>() {
2. new Student("James",1,"Basketball"),
3. new Student("James",1,"Basketball"),
4. new Student("Kobe",2,"Basketball"),
5. new Student("Curry",3,"Football"),
6. new Student("Curry",3,"Yoga")
7. };
8. list.Distinct().ToList().ForEach(s => Console.WriteLine(s.ToString()));

复制代码

执行结果：

可见，并没有去除重复的记录。

不带comparer参数的Distinct方法是使用的IEqualityComparer接口的默认比较器进行比较的，对于引用类型，默认比较器比较的是其引用地址，程序中集合里的每一个元素都是个新的实例，引用地址都是不同的，所以不会被作为重复记录删除掉。

因此，我们考虑使用第二个重载方法。

新建一个类，实现IEqualityComparer接口。注意GetHashCode方法的实现，只有HashCode相同才会去比较

1. public class Compare:IEqualityComparer<Student>
2. {
3. public bool Equals(Student x,Student y)
4. {
5. return x.Id == y.Id;//可以自定义去重规则，此处将Id相同的就作为重复记录，不管学生的爱好是什么
6. }
7. public int GetHashCode(Student obj)
8. {
9. return obj.Id.GetHashCode();
10. }
11. }

复制代码

然后调用

1. list.Distinct(new Compare()).ToList().ForEach(s => Console.WriteLine(s.ToString()));

复制代码

执行结果：

我们按照Id去给这个集合去重成功！

3.如何编写一个具有扩展性的去重方法

1. public class Compare<T, C> : IEqualityComparer<T>
2. {
3. private Func<T, C> _getField;
4. public Compare(Func<T, C> getfield)
5. {
6. this._getField = getfield;
7. }
8. public bool Equals(T x, T y)
9. {
10. return EqualityComparer<C>.Default.Equals(_getField(x), _getField(y));
11. }
12. public int GetHashCode(T obj)
13. {
14. return EqualityComparer<C>.Default.GetHashCode(this._getField(obj));
15. }
16. }
17. public static class CommonHelper
18. {
19. /// <summary>
20. /// 自定义Distinct扩展方法
21. /// </summary>
22. /// <typeparam name="T">要去重的对象类</typeparam>
23. /// <typeparam name="C">自定义去重的字段类型</typeparam>
24. /// <param name="source">要去重的对象</param>
25. /// <param name="getfield">获取自定义去重字段的委托</param>
26. /// <returns></returns>
27. public static IEnumerable<T> MyDistinct<T, C>(this IEnumerable<T> source, Func<T, C> getfield)
28. {
29. return source.Distinct(new Compare<T, C>(getfield));
30. }
31. }

复制代码

调用：

1. list.MyDistinct(s=>s.Id).ToList().ForEach(s => Console.WriteLine(s.ToString()));

复制代码

用到了泛型、委托、扩展方法等知识点。可以用于任何集合的各种去重场景

转载来源：https://www.cnblogs.com/Robert-go-go/p/5399198.html