集合源码分析（四）HashSet集合

1、HashSet概述：

//无序、无索引、不可以重复。

    A:存入集合的顺序和取出集合的顺序不一致
    B:没有索引
    C:存入集合的元素不能重复

使用HashSet集合注意点：重写hashCode和equals方法。
调用顺序：
    规则:新添加到HashSet集合的元素都会与集合中已有的元素一一比较。
    首先比较哈希值(每个元素都会调用hashCode()产生一个哈希值)。
       如果新添加的元素与集合中已有的元素的哈希值都不同,新添加的元素存入集合。
       如果新添加的元素与集合中已有的某个元素哈希值相同,此时还需要调用equals(Object obj)比较。
       如果equals(Object obj)方法返回true,说明新添加的元素与集合中已有的某个元素的属性值相同,那么新添加的元素不存入集合。
       如果equals(Object obj)方法返回false, 说明新添加的元素与集合中已有的元素的属性值都不同, 那么新添加的元素存入集合。

2、HashSet不可重复性：

//如果用ArrayList实现HashSet去除重复的功能？
      如果用ArrayList实现HashSet的去除重复的功能

方法一：     

ArrayList<String> al1 = new ArrayList<>();
	al1.add("a");
	al1.add("a");
	al1.add("b");
	al1.add("b");
	al1.add("c");
	al1.add("c");
	
ArrayList<String> al2 = new ArrayList<>();
	for (String string : al1) {
		if(!al2.contains(string)){
			al2.add(string);
		}
	}
	System.out.println(al2);
	al1.clear();
	al1.addAll(al2);
	System.out.println(al1);
}

方法二：//面向对象的思想。
            自己定义一个MyArrayList类，继承ArrayList。重写里面的add方法，也可以。

3、底层源码：

HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set 的迭代顺序；特别是它不保证该顺序恒久不变，此类允许使用null元素。在HashSet中，元素都存到HashMap键值对的Key上面，而Value时有一个统一的值private static final Object PRESENT = new Object();

    所以Set 集合底层依赖的是 Map 双列集合的键，值为 new Object();
    即：add方法源码：
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
    set集合添加实际上是添加到map集合中键的位置，值为PRESENT。而PRESENT = new Object();

4、HashSet遍历：

因为没有索引，所有set集合的遍历只能使用迭代器和增强for。

遍历一：
        HashSet<String> hs = new HashSet<>();
            hs.add("a");
            hs.add("b");
            hs.add("c");
        
        Iterator<String> it = hs.iterator();
            while(it.hasNext()){
                String s = it.next();
                System.out.println(s);
            }
遍历二：
        HashSet<String> hs = new HashSet<>();
            hs.add("a");
            hs.add("b");
            hs.add("c");
        
        for (String string : hs) {
            System.out.println(string);
        }

5、面试分享：

5.1、HashSet与HashMap的区别：

5.2、HashSet在源代码内是如何实现不add相同的元素的？

HashSet它的内部是根据equals()返回值和hashCode()的值是否相同两个方法来判断两个对象是否相同的。而源代码上，HashSet内部用了一个HashMap作存储，add()方法内是调用了map的put()方法，map的put()方法会检查这个键是否已存在，若是则返回该键之前的值，并更新成新值，若不是则返回null，但这个键是不会发生改变的。所以，在源代码里，HashSet的add()方法是根据map的put返回值来判断添加元素是否成功的。

5.3、HashSet导致的内存泄漏

hash集合在操作不当的情况下，有可能造成内存泄漏。

考虑这样的情况，把一个对象存储进hashSet集合后，修改这个对象中参与计算hash的变量的值，这时这个对象的hash值也会随之改变，那么这么对象可以正常地被删除吗？下面用代码试一下：

先自定一个MPoint类，其中有两个变量，x和y，其中x参与计算hash值

public class MPoint {
     private int x;
     private int y;
 
     public MPoint() {
     }
 
     public MPoint( int x, int y) {
            this. x = x;
            this. y = y;
     }
 
     public int getX() {
            return x;
     }
 
     public void setX(int x) {
            this. x = x;
     }
 
     public int getY() {
            return y;
     }
 
     public void setY(int y) {
            this. y = y;
     }
 
     @Override
     public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + x; //x参与计算hash值
            return result;
     }
 
     @Override
     public boolean equals(Object obj) {
            if ( this == obj)
                 return true;
            if ( obj == null)
                 return false;
            if (getClass() != obj.getClass())
                 return false;
           MPoint other = (MPoint) obj;
            if ( x != other. x)
                 return false;
            if ( y != other. y)
                 return false;
            return true;
     }
}

主函数类测试，在一个HashSet集合中：添加三个元素，mp1、mp2、mp3，并进行其中属性的修改和输出测试

public class HashSetTest {
 
     public static void main(String[] args) {
           HashSet<MPoint> set = new HashSet<MPoint>();
           MPoint mp1 = new MPoint(1, 6);
           MPoint mp2 = new MPoint(2, 7);
           MPoint mp3 = new MPoint(1, 6);
 
            set.add( mp1);
            set.add( mp2);
            set.add( mp3);
            set.add( mp1);
 
           System. out.println( set.size()); // 结果为2
 
            mp1.setX(3);
            set.remove( mp1);
           System. out.println( set.size()); // 结果还是为2，说明没有删除成功
           System. out.println( set.contains( mp1)); // 结果为false，修改了参与计算hash值的变量，其对象不能再被找到
           System. out.println( set.remove( mp1)); // 结果为false，修改了参与计算hash值的变量，其对象不能被删除
 
            mp2.setY(2);
           System. out.println( set.contains( mp2)); // 结果为true，没有修改关键属性的对象可以被找到
           System. out.println( set.remove( mp2)); // 结果为true，没有修改关键属性的对象可以被删除
           System. out.println( set.size()); // 结果还是为1
     }
}

输出结果如下：

2
2
false
false
true
true
1

可以看出已经发生了内存泄漏了，mp1对象不能被正常删除。