利用set集合进行list集合高效去重

  我们可以知道Set集合是没有重复数据的特性，那么对于元素为对象 的情况是否也同样奏效？可以看一下。举一个例子：

SetTest.java：

1. class VO {

2. private String name;

3. private String addr;

4.  

5. public VO(String name, String addr) {

6. this.name = name;

7. this.addr = addr;

8. }

9.  

10. @Override

11. public String toString() {

12. return "name: " + name + " addr:" + addr;

13. }

14. }

15.  

16. @Test

17. public void testSet() {

18.  

19. Set<VO> vos = new HashSet<>();

20.  

21. VO vo = new VO("wahaha", "sh");

22.  

23. VO vo1 = new VO("wahaha", "bj");

24.  

25. VO vo2 = new VO("wahaha", "sh");

26.  

27. vos.add(vo);

28. vos.add(vo1);

29. vos.add(vo2);

30.  

31. for (VO item : vos) {

32. System.out.println(item.toString());

33. }

34. }

结果为：

1. name: wahaha addr:sh

2. name: wahaha addr:bj

3. name: wahaha addr:sh

可见，对于各个字段值都相同的对象，并没有做去重操作。为什么呢，看一下JDK1.8中HashSet的数据结构：

HashSet.java:

实例化对象：

1. /**

2. * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has

3. * default initial capacity (16) and load factor (0.75).

4. */

5. public HashSet() {

6. map = new HashMap<>();

7. }

可见new HashSet()操作实际上是new HashMap<>()，可见底层是以HashMap来实现的。

HashSet.add方法：

1. public boolean add(E e) {

2. return map.put(e, PRESENT)==null;

3. }

HashMap.add方法：

1. public V put(K key, V value) {

2. return putVal(hash(key), key, value, false, true);

3. }

4.  

5. final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

6. boolean evict) {

7. Node<K,V>[] tab; Node<K,V> p; int n, i;

8. if ((tab = table) == null || (n = tab.length) == 0)

9. n = (tab = resize()).length;

10. if ((p = tab[i = (n - 1) & hash]) == null)

11. tab[i] = newNode(hash, key, value, null);

12. else {

13. Node<K,V> e; K k;

14. if (p.hash == hash &&

15. ((k = p.key) == key || (key != null && key.equals(k))))

16. e = p;

17. else if (p instanceof TreeNode)

18. e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

19. else {

20. for (int binCount = 0; ; ++binCount) {

21. if ((e = p.next) == null) {

22. p.next = newNode(hash, key, value, null);

23. if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

24. treeifyBin(tab, hash);

25. break;

26. }

27. if (e.hash == hash &&

28. ((k = e.key) == key || (key != null && key.equals(k))))

29. break;

30. p = e;

31. }

32. }

33. if (e != null) { // existing mapping for key

34. V oldValue = e.value;

35. if (!onlyIfAbsent || oldValue == null)

36. e.value = value;

37. afterNodeAccess(e);

38. return oldValue;

39. }

40. }

41. ++modCount;

42. if (++size > threshold)

43. resize();

44. afterNodeInsertion(evict);

45. return null;

46. }

可以从上面的加粗字段看出，判断插入的key是否存在，要判断两点①hash值是否相同；②对应的值是否相同，前者要看hashCode()方法，后者要看equal()方法。下面我们来探索一下基本的数据类型和自定义类类型在计算hashCode和equal的区别，看一下如下代码：

1. class VO {

2. private String name;

3. private String addr;

4.  

5. public VO(String name, String addr) {

6. this.name = name;

7. this.addr = addr;

8. }

9.  

10. @Override

11. public String toString() {

12. return "name: " + name + " addr:" + addr;

13. }

14. }

15.  

16. @Test

17. public void testSet() {

18.  

19. Set<VO> vos = new HashSet<>();

20.  

21. VO vo = new VO("wahaha", "sh");

22. VO vo1 = new VO("wahaha", "bj");

23. VO vo2 = new VO("wahaha", "sh");

24.  

25. Integer a = 2;

26. Integer b = 2;

27.  

28. String str1 = new String("abc");

29. String str2 = new String("abc");

30.  

31. System.out.println(a.equals(b));

32. System.out.println(str1.equals(str2));

33. System.out.println(vo.equals(vo2));

34.  

35. System.out.println(a.hashCode() == b.hashCode());

36. System.out.println(str1.hashCode() == str2.hashCode());

37. System.out.println(vo.hashCode() == vo2.hashCode());

38.  

39. vos.add(vo);

40. vos.add(vo1);

41. vos.add(vo2);

42.  

43. for (VO item : vos) {

44. System.out.println(item.toString());

45. }

46. }

结果为：

1. true

2. true

3. false

4. true

5. true

6. false

7. name: wahaha addr:sh

8. name: wahaha addr:sh

9. name: wahaha addr:bj

java.lang.Integer.equals()：两个对象对应的值一致则返回true。

1. public boolean equals(Object obj) {

2. if (obj instanceof Integer) {

3. return value == ((Integer)obj).intValue();

4. }

5. return false;

6. }

java.lang.String.equals()：两个字符串对应的值一致则返回true：

1. public boolean equals(Object anObject) {

2. if (this == anObject) {//同一个对象，必定是一致的

3. return true;

4. }

5. if (anObject instanceof String) {

6. String anotherString = (String)anObject;

7. int n = value.length;

8. if (n == anotherString.value.length) {//对比每一个字符

9. char v1[] = value;

10. char v2[] = anotherString.value;

11. int i = 0;

12. while (n-- != 0) {

13. if (v1[i] != v2[i])

14. return false;

15. i++;

16. }

17. return true;

18. }

19. }

20. return false;//anObject不是String实例，那么返回false

21. }

java.lang.Object.equals()：两个对象的引用是否一致，即两个的对象是否是同一个。

1. public boolean equals(Object obj) {

2. return (this == obj);

3. }

可见对于java.lang.Object.equals()来讲，两个new出来的对象肯定是不一致的，那么在HashMap数据结构中不会被判定成相同的对象（尽管值相同）。下面再看看hashCode的源码：

java.lang.Integer.hashCode():

1. @Override

2. public int hashCode() {

3. return Integer.hashCode(value);

4. }

5.  

6. public static int hashCode(int value) {

7. return value;

8. }

java.lang.String.hashCode():

1. public int hashCode() {

2. int h = hash;

3. if (h == 0 && value.length > 0) {

4. char val[] = value;

5.  

6. for (int i = 0; i < value.length; i++) {

7. h = 31 * h + val[i];

8. }

9. hash = h;

10. }

11. return h;

12. }

java.lang.Object.hashCode():

public native int hashCode();

JDK8的默认hashCode的计算方法是通过和当前线程有关的一个随机数+三个确定值，运用Marsaglia's xorshift schema随机数算法得到的一个随机数。

因此，以上可以看到Integer和String也都是根据具体的value值来计算hashCode，那么尽管两个引用不同但是值相同的对象，依然是想等的，但是Object则不同了。

知道了原因，解决方法就简单了，那就是重载VO类的equals和hashCode方法，代码如下：

SetTest.java：

1. class VO {

2. private String name;

3. private String addr;

4.  

5. public VO(String name, String addr) {

6. this.name = name;

7. this.addr = addr;

8. }

9.  

10. @Override

11. public String toString() {

12. return "name: " + name + " addr:" + addr;

13. }

14.  

15. /**

16. * 如果对象类型是User,先比较hashcode，一致的场合再比较每个属性的值

17. */

18. @Override

19. public boolean equals(Object obj) {

20. if (obj == null)

21. return false;

22. if (this == obj)

23. return true;

24. if (obj instanceof VO) {

25. VO vo = (VO) obj;

26.  

27. // 比较每个属性的值 一致时才返回true

28. if (vo.name.equals(this.name) && vo.addr.equals(this.addr))

29. return true;

30. }

31. return false;

32. }

33.  

34. /**

35. * 重写hashcode 方法，返回的hashCode不一样才再去比较每个属性的值

36. */

37. @Override

38. public int hashCode() {

39. return name.hashCode() * addr.hashCode();

40. }

41. } // class

42.  

43. @Test

44. public void testSet() {

45.  

46. Set<VO> vos = new HashSet<>();

47.  

48. VO vo = new VO("wahaha", "sh");

49. VO vo1 = new VO("wahaha", "bj");

50. VO vo2 = new VO("wahaha", "sh");

51.  

52. vos.add(vo);

53. vos.add(vo1);

54. vos.add(vo2);

55.  

56. for (VO item : vos) {

57. System.out.println(item.toString());

58. }

59.  

60. }

结果：

1. name: wahaha addr:sh

2. name: wahaha addr:bj

在阿里巴巴Java开发是手册的集合处理中需要强制遵循如下规则：

1)只要重写equals，就必须重写hashCode；

2)因为Set存储的是不重复的对象，依据hashCode和equals进行判断，所以Set存储的对象必须重写这两个方法。

3)如果自定义对象做为Map的键，那么必须重写hashCode和equals。

正例：String重写了hashCode和equals方法，所以我们可以非常愉快的使用String对象作为key来使用。

以上。

Author：忆之独秀

Email：[email protected]

注明出处：https://blog.csdn.net/lavorange/article/details/80420087