Vector v=new Vector(10);
for (int i=1;i<100; i++)
{
        Object o=new Object();
        v.add(o);
        o=null;        
}
上面这段代码，发生内存泄漏了。但是我不怎么明白~求大神指教~~~~谢谢

masai158 发表于 2014-8-10 15:05
刚刚总结完了。看对你有帮助不嘛！！我是后悔没看反射，就教答案了。不然又可以多混点技术分了 ...

:lol 辛苦了，谢谢

fantacyleo 发表于 2014-8-10 15:01
这段代码在IBM的技术文章库中出现过，但我认为它很难说是内存泄露。我猜作者的本意是想说：变量o通过new指 ...

谢谢。我发的那个代码有人说内存泄漏，可是我貌似没看出来泄漏，所以发帖求大神讲解一下。您发的这篇代码我也比较赞同里面的内存泄漏:lol

1. import java.util.HashSet;
   
2. 
   
3. 
   
4. /**hashCode的作用：当需要在hash结构的集合中存储时就需要根据自己的属性来覆写hashCode。为什么呢？
   
5. * 因为在hash结构中，必须要确保元素的唯一性，在判断唯一性的最重要的依据就是 hashCode 和 equals。如果这2个都相等的那就是同一个元素。
   
6. * 程序是有限判断 hashCode值，如果相等在判断equals。所以提高程序的效率 最好就根据 自己的属性来覆写hashCode.
   
7. * */
   
8. public class HashCode {
   
9. 
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 HashSet hs = new HashSet();
    
13.                 hs.add(new Person5("xiaozhang",20));
    
14.                 hs.add(new Person5("xiaozi",10));
    
15.                 hs.add(new Person5("xiaoxia",20));        //不写hashCode的话。和下面的对象都可以同时存入集合中
    
16.                 hs.add(new Person5("xiaoxia",20));
    
17.                
    
18.                 Person5 xiaojian = new Person5("xiaojian",15);
    
19.                 hs.add(xiaojian);
    
20.                 System.out.println(hs.size());//        4
    
21.                
    
22.                 xiaojian.age = 10;                //我修改一个对象的成员属性以后。
    
23.                 System.out.println(hs.remove(xiaojian));        //在删除对象，是没办法删除的
    
24.                 /**我在创建的时候是记录的是一个哈希值，我删除的时候也必须是当时记录的哈希值，
    
25.                  * 当我修改对象的属性后，他的哈希值将随之改变，肯定不是 之前的哈希值，所以没办法删除。
    
26.                  *
    
27.                  * 这种现象叫内存泄漏：当我需要删除一个对象时。这个对象已经不可达，而且也无法回收内存的话，这样白白的占用了内存的空间，
    
28.                  * 当我的对象很多的，同时这种浪费资源的空间越来越多的时候，就会造成内存溢出
    
29.                  * 内存溢出：递归的时候也应该尽量控制递归次数，不然也容易引发内存溢出。
    
30.                  * */                                
    
31.                 System.out.println(hs.size());//        4
    
32. 
    
33.         }
    
34. }
    
35. 
    
36. class Person5
    
37. {
    
38.         public String name;
    
39.         public int age;
    
40.         public Person5(String name, int age)
    
41.         {
    
42.                 this.name = name;
    
43.                 this.age = age;
    
44.         }
    
45. 
    
46.         public int hashCode() {
    
47.                 final int prime = 31;
    
48.                 int result = 1;
    
49.                 result = prime * result + age;
    
50.                 result = prime * result + ((name == null) ? 0 : name.hashCode());
    
51.                 return result;
    
52.         }
    
53. 
    
54.         public boolean equals(Object obj) {
    
55.                 if (this == obj)
    
56.                         return true;
    
57.                 if (obj == null)
    
58.                         return false;
    
59.                 if (getClass() != obj.getClass())
    
60.                         return false;
    
61.                 Person5 other = (Person5) obj;
    
62.                 if (age != other.age)
    
63.                         return false;
    
64.                 if (name == null) {
    
65.                         if (other.name != null)
    
66.                                 return false;
    
67.                 } else if (!name.equals(other.name))
    
68.                         return false;
    
69.                 return true;
    
70.         }
    
71. }

复制代码

刚刚总结完了。看对你有帮助不嘛！！我是后悔没看反射，就教答案了。不然又可以多混点技术分了

这段代码在IBM的技术文章库中出现过，但我认为它很难说是内存泄露。我猜作者的本意是想说：变量o通过new指向了一个Object对象，把o加入v后，v中有对Object对象的引用，但当o=null后，外界就失去了对o所指对象的直接引用（也就是说没法直接访问之前创建的10个new Object对象了），而v中对Object的引用依然存在，导致垃圾回收器不会回收之前创建的10个new Object对象。

但是，从逻辑上来说，既然你把对象加入了Vector，自然是要使用它们的，既然要使用它们，而且可以通过Vector类的各种方法来访问到它们，又何来内存泄露之说呢？所以我觉得用这个例子来说明内存泄露并不恰当。还是张孝祥老师在高新技术视频中的那个内存泄露例子比较合适：

1. public class HashCodeDemo {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                   
   
5.                 Point p1 = new Point(3, 3);
   
6.                 Point p2 = new Point(3, 5);
   
7.                 Point p3 = new Point(3, 5);
   
8.          
   
9.                 Collection<Point> hset =  new HashSet<Point>();
   
10.                 hset.add(p1);
    
11.                 hset.add(p2);
    
12.                 hset.add(p2);
    
13. 
    
14.                 System.out.println(hset.size());
    
15.                 p1.x = 4;
    
16.                 hset.remove(p1); // p1没有被移走。因为虽然p1的域x被修改了，但其在哈希表中的存储位置没有被修改。导致找不到p1
    
17.                 System.out.println("after remove: " + hset.size());
    
18.                 for (Point p : hset)
    
19.                         System.out.println(p.getY());
    
20.          
    
21.                 System.out.println(hset.remove(new Point(3,3)));// 这样也删除不了，实际上p1已经无法再放访问到
    
22.                 System.out.println(hset.contains(p1));
    
23.                 System.out.println(hset.size());
    
24. 
    
25.         }
    
26. 
    
27. }
    

复制代码