为什么是说HashSet存在内存泄漏？，它的内存泄漏是怎样造成的？

HashSet就是采用哈希算法存储对象的，他内部采用了对某个数字进行取模的方式对所有的哈希码进行分组划分的对象存储区域

Object中定义了一个hashCode方法用来返回每个java对象的哈希码，当从hashSet集合中查找某个对象时，java系统首先调用对象的hashCode()方法获得该对象的哈希码，然后根据哈希码值找到相应的存储区域，最后取出该存储区域没的每个元素与该元素进行equals方法比较，这样不用遍历整个HashSet集合，就能得到结论。

1. public class ReflectPoint {
   
2. 
   
3.         String str1 = "sontao";//此处没有public
   
4.         public String str2 = "foxiaotao";
   
5.         public String str3 = "ou mygod";
   
6.         private int x;
   
7.         public int y;
   
8.         public ReflectPoint(int x, int y) {
   
9.                 this.x = x;
   
10.                 this.y = y;
    
11.         }
    
12.         public ReflectPoint(){}
    
13.         public String toString()
    
14.         {
    
15.                 return str1+" : "+str2+" : "+str3;
    
16.         }
    
17.        
    
18.         @Override
    
19.         public int hashCode() {
    
20.                 final int prime = 31;
    
21.                 int result = 1;
    
22.                 result = prime * result + x;
    
23.                 result = prime * result + y;
    
24.                 return result;
    
25.         }
    
26.         @Override
    
27.         public boolean equals(Object obj) {
    
28.                 if (this == obj)
    
29.                         return true;
    
30.                 if (obj == null)
    
31.                         return false;
    
32.                 if (getClass() != obj.getClass())
    
33.                         return false;
    
34.                 ReflectPoint other = (ReflectPoint) obj;
    
35.                 if (x != other.x)
    
36.                         return false;
    
37.                 if (y != other.y)
    
38.                         return false;
    
39.                 return true;
    
40.         }
    
41. }

复制代码

1.         public static void main(String[] args) {
   
2.                 // TODO Auto-generated method stub
   
3.                 Collection collections=null;
   
4.                 try
   
5.                 {
   
6. //                        InputStream ips = new FileInputStream("config.properties");
   
7. //                        InputStream ips = ArrayList_HashSet.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");
   
8.                         InputStream ips = ArrayList_HashSet.class.getResourceAsStream("resources/config.properties");
   
9.                         Properties prop = new Properties();
   
10.                         prop.load(ips);
    
11.                         ips.close();
    
12.                         String className = prop.getProperty("className");
    
13.                         collections = (Collection)Class.forName(className).newInstance();
    
14.                 }
    
15.                 catch (Exception e) {
    
16.                         // TODO Auto-generated catch block
    
17.                         e.printStackTrace();
    
18.                 }
    
19.                 ReflectPoint pt1 = new ReflectPoint(3,3);
    
20.                 ReflectPoint pt2 = new ReflectPoint(4,4);
    
21.                 ReflectPoint pt3 = new ReflectPoint(3,3);
    
22.                 collections.add(pt1);
    
23.                 collections.add(pt2);
    
24.                 collections.add(pt3);//复写了ReflectPoint的hashCode方法和equals方法
    
25.                 collections.add(pt1);
    
26.                 pt1.y=7;
    
27.                 collections.remove(pt1);//内存泄露，没能移除
    
28.                 System.out.println(collections.size());
    
29.         }
    
30. 
    
31. }

复制代码

结果：2

在例子中复写hashCode()和equals()方法，根据ReflectPoint的x，y的值确定对象的hashCode()值，这样pt1和pt3就是同一个对象，如果不复写hashCode(),pt1和pt3就不是同一个对象。

将pt1，pt2，pt3添加进集合中去之后，改变pt1.y的值

pt1.y=7；

这是从集合中移除pt1。

但是pt1在原来的HashSet中的存储位置已经由y值得改变而改变。程序这是不发现pt1新的位置。所以移除不出去，这样程序员以为移除了，但是pt1还在内存中，造成内存泄露。