HashSet为何能够引起内存泄露，看了张老师的讲解还是有些不甚了解，
还有就是equals和hashcode方法.这两个方法。。和内存泄露又有什么必然关系？？

不知道你说的是不是那个改了hash值的那个例子，hashset是以hashcode值存的，当x参与hashcode值运算时，当程序运行中将这个x改变了，hash值也就改了，那就不可能再找到原来地址的值了，原来地址的值就被漏掉了。引起内存泄露。我的理解，错了请拍砖。

黑马-李勇 发表于 2012-8-24 16:34
不知道你说的是不是那个改了hash值的那个例子，hashset是以hashcode值存的，当x参与hashcode值运算时，当程 ...

是这个意思。。能具体些么

我只看了一遍，记不太清了。下面这个例子意思是程序不要改变参与运算的x,改变后就会有内存遗漏或泄露。
        public int hashCode()
        {        return name.hashCode()+age*x;}
           //例：name.hashcode=20   age.hashcode=30 x=34
           //return 的值是20+30*34=1040
但在后面的程序中你的x变了。如  x=40了。！！！
再调用hashcode找那个值就成了。20+30*40=1220
如这时调用remove   返回的hashcode值就成了name.hashCode()+age*x    ---->  20+30*40    ---->1220
删除的是hashcode值为1220地址的值。可原来的1040地址的值已经没有指针指向了。此程序也不能找到原来的1040地址的值了。1040就泄露了。
个人理解，可能有不对的地方。

                                                                                 

老师说的好象是不要改变参与hashcode运算的对象的值。这个不太确定。但应该是这个意思。你再看下吧，等我再看到那的时候再确认下。应该是张老师基础加强里面的。

黑马-李勇 发表于 2012-8-24 16:56
我只看了一遍，记不太清了。下面这个例子意思是程序不要改变参与运算的x,改变后就会有内存遗漏或泄露。
        pu ...

JVM不会回收这个没用的地址所代表的对象
么？？

这个应该回收吧，但你的程序就出现了问题。上面那个例子，你要删除员工档案hashcode=1040的员工，但你把hashcode=1220的员工给删除了，1040的员工漏掉了。这程序就出现问题了。少了两个人了。

黑马-李勇 发表于 2012-8-24 17:06
这个应该回收吧，但你的程序就出现了问题。上面那个例子，你要删除员工档案hashcode=1040的员工，但你把has ...

这个我感觉是引用错了内存中的地址，，但是这个和内存泄露有什么关系？？

1. package com.itheima.test;
   
2. 
   
3. import java.util.Collection;
   
4. import java.util.HashSet;
   
5. 
   
6. public class Test {
   
7. 
   
8.         public static void main(String[] args) {
   
9.                 Collection<Person> collections = new HashSet<Person>();
   
10.                
    
11.                 Person p1 = new Person("zhangsan", 23);
    
12.                 Person p2 = new Person("lisi", 34);
    
13.                
    
14.                 collections.add(p1);
    
15.                 collections.add(p2);
    
16.                
    
17.                 System.out.println(collections.size());
    
18.                
    
19.                 p1.setAge(32);//p1的hashCode值也随之改变了
    
20.                
    
21.                 /*        想要移除p1，但是由于哈希算法内部原理，到另一个区域，却找不到p1，没有移除掉，故collections中还有2个元素
    
22.                  *         长此以往，collections中元素越来越多，内存泄漏
    
23.                  *         因为并不是无名引用对象，JVM不会自动释放内存的
    
24.                 */
    
25.                 collections.remove(p1);
    
26.                 System.out.println(collections.size());
    
27.                 System.out.println(p1);
    
28.                 System.out.println(collections);
    
29.                
    
30.                 /*p2就可以移除掉*/
    
31.                 collections.remove(p2);
    
32.                 System.out.println(collections.size());
    
33.         }
    
34. }
    
35. 
    
36. class Person {
    
37.        
    
38.         String name;
    
39.         int age;
    
40.        
    
41.         Person(String name, int age) {
    
42.                 this.name = name;
    
43.                 this.age = age;
    
44.         }
    
45. 
    
46.         public String getName() {
    
47.                 return name;
    
48.         }
    
49. 
    
50.         public void setName(String name) {
    
51.                 this.name = name;
    
52.         }
    
53. 
    
54.         public int getAge() {
    
55.                 return age;
    
56.         }
    
57. 
    
58.         public void setAge(int age) {
    
59.                 this.age = age;
    
60.         }
    
61. 
    
62.         @Override
    
63.         public int hashCode() {
    
64.                 final int prime = 31;
    
65.                 int result = 1;
    
66.                 result = prime * result + age;
    
67.                 result = prime * result + ((name == null) ? 0 : name.hashCode());
    
68.                 return result;
    
69.         }
    
70. 
    
71.         @Override
    
72.         public boolean equals(Object obj) {
    
73.                 if (this == obj)
    
74.                         return true;
    
75.                 if (obj == null)
    
76.                         return false;
    
77.                 if (getClass() != obj.getClass())
    
78.                         return false;
    
79.                 Person other = (Person) obj;
    
80.                 if (age != other.age)
    
81.                         return false;
    
82.                 if (name == null) {
    
83.                         if (other.name != null)
    
84.                                 return false;
    
85.                 } else if (!name.equals(other.name))
    
86.                         return false;
    
87.                 return true;
    
88.         }
    
89. 
    
90.         @Override
    
91.         public String toString() {
    
92.                 return "Person [name=" + name + ", age=" + age + "]";
    
93.         }
    
94.        
    
95. }

复制代码

代码太长了，我把main函数摘出来把：

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Collection<Person> collections = new HashSet<Person>();
   
5.                
   
6.                 Person p1 = new Person("zhangsan", 23);
   
7.                 Person p2 = new Person("lisi", 34);
   
8.                
   
9.                 collections.add(p1);
   
10.                 collections.add(p2);
    
11.                
    
12.                 System.out.println(collections.size());
    
13.                
    
14.                 p1.setAge(32);//p1的hashCode值也随之改变了
    
15.                
    
16.                 /*        想要移除p1，但是由于哈希算法内部原理，到另一个区域，却找不到p1，没有移除掉，故collections中还有2个元素
    
17.                  *         长此以往，collections中元素越来越多，内存泄漏
    
18.                  *         因为并不是无名引用对象，JVM不会自动释放内存的
    
19.                 */
    
20.                 collections.remove(p1);
    
21.                 System.out.println(collections.size());
    
22.                 System.out.println(p1);
    
23.                 System.out.println(collections);
    
24.                
    
25.                 /*p2就可以移除掉*/
    
26.                 collections.remove(p2);
    
27.                 System.out.println(collections.size());
    
28.         }
    
29. }

复制代码

打印结果是：

1. 2
   
2. 2
   
3. Person [name=zhangsan, age=32]
   
4. [Person [name=zhangsan, age=32], Person [name=lisi, age=34]]
   
5. 1
   

复制代码

杜鹏云 发表于 2012-8-24 17:14
这个我感觉是引用错了内存中的地址，，但是这个和内存泄露有什么关系？？ ...

import java.util.HashSet;

public class HashSetTest
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                HashSet hs = new HashSet();
                Person p1 = new Person("a1",11);      
                Person p2 = new Person("a2",12);
                Person p3 = new Person("a3",13);
                Person p4 = new Person("a1",11);
               
                hs.add(p1);                //p1存进hs中的时候根据你覆写hashCode方法算出来的“name.hashCode()+age*37”值存到到集合中分配的对应的区域块（暂且认为是区域01）中，这时你的算出来的hashCode应该是name.hashCode()+11*37.
                hs.add(p2);
                hs.add(p3);
                //hs.add(p4);
               
                p1.setAge(15);        //你设置了pi的年龄是15，又根据算出来的值是name.hashCode()+15*37.
                hs.remove(p1);       //当你要在集合中移除p1的时候，还是根据hashCode的值去集合中查找与之对应的p1，但是刚刚你上面改变了p1的年龄，算出来的hashCode值肯定不一样了  这个集合就会根据你刚刚的值去内存中对应的区域块查，发现没有对应的pi就没删了，这时的区域01就在集合成垃圾了，即使你把改后的p1添加到集合中，存起来的也是不同的区域，你删除的p1还不是区域01，还是垃圾

假如你现在往集合里添加了对象很多，不断地重复刚才的添加，修改，删除操作，上述的垃圾就一直增加，内存空间就越来越少，导致内存溢出。就是张老师说的如果参加hashCode运算的变量在HashSet集合中添加了，就不要随意修改，希望能帮助你理解   
                System.out.println(hs.size());
        }
}
class Person
{
        private String name;
        public void setName(String name) {
                this.name = name;
        }

        public void setAge(int age) {
                this.age = age;
        }
        private int age;
        Person(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
        
        public int hashCode()
        {
                return name.hashCode()+age*37;
        }

        public boolean equals(Object obj)
        {
                if(!(obj instanceof Person))
                        return false;
                Person p = (Person)obj;
                return this.name.equals(p.name) && this.age == p.age;
        }

}