1. package demo;
   
2. import java.util.*;
   
3. 
   
4. public class Demo3 {
   
5. 
   
6. public static void main(String[] args) {
   
7.   
   
8. Collection<TwoPoint>  c=new HashSet<TwoPoint>();
   
9.                 TwoPoint t1=new TwoPoint(3,5);
   
10.                 TwoPoint t2=new TwoPoint(3,6);
    
11.                 TwoPoint t3=new TwoPoint(3,7);
    
12.                
    
13.                 c.add(t1);
    
14.                 c.add(t2);
    
15.                 c.add(t3);
    
16.                
    
17.                 System.out.println(c.size());
    
18.                 t2.y=8;//如果把这里改成5（这里是疑惑的部分）
    
19.                 c.remove(t2);
    
20.                 System.out.println(c.size());
    
21.                 Iterator<TwoPoint> sets=c.iterator();
    
22.                 while(sets.hasNext()){
    
23.                         TwoPoint tp=sets.next();
    
24.                         System.out.println(tp);
    
25.                 }
    
26.         }
    
27. 
    
28. }
    
29. class TwoPoint{
    
30. //覆写了hashCode()方法
    
31.         public int hashCode() {
    
32.                 final int prime = 31;
    
33.                 int result = 1;
    
34.                 result = prime * result + x;
    
35.                 result = prime * result + y;
    
36.                 return result;
    
37.         }
    
38.         //覆写了equals()方法
    
39.         public boolean equals(Object obj) {
    
40.                 if (this == obj)
    
41.                         return true;
    
42.                 if (obj == null)
    
43.                         return false;
    
44.                 if (getClass() != obj.getClass())
    
45.                         return false;
    
46.                 TwoPoint other = (TwoPoint) obj;
    
47.                 if (x != other.x)
    
48.                         return false;
    
49.                 if (y != other.y)
    
50.                         return false;
    
51.                 return true;
    
52.         }
    
53.         int x;
    
54.         int y;
    
55.         TwoPoint(int x,int y){
    
56.                 this.x=x;
    
57.                 this.y=y;
    
58.         }
    
59.         public String toString(){
    
60.                 return x+"..."+y;
    
61.         }
    
62. }
    
63. //我想说的是，如果改成t2.y=8;删除t2的时候，它是找不到了，所以集合的大小还是3，那如果我把t2.y=5;这样
    
64. //集合的大小变成了2，我是不是可以认为，再删除t2的时候根本没有找到t2，而是直接把t1给删了？
    
65. //为什么我会这样想？第一：如果把t2.y=8;改成一个不相关的数字，大小没有改变，说明他找不到集合中t2以前
    
66. //的数据了对么？那我恰好给他改成已经纯在的t1的数据（让他们数据相等）,它是不是会将t1中数据删了？
    
67. //求高手解释
    
68. 
    
69. 
    
70. 
    
71. //我个人觉得，刚才看了一下覆写的hashCode()方法，当把值改成已经存在在集合中的数据所指的话，确实是会取出来，是把t1的数据给移除了为什么我这样说？
    
72. 简单测试一下，把t2.y=5；以后，移除一下试一试，是不是true？是
    
73. 那有人就会说了，那也不定移除的是t1的数据啊，那好，你在c.remove(t1);一下，也就是此时我正常的移除我的t1，这样合情合理吧？结果那？false！为什么？因为他的数据被t2.y=5，修改以后给移除了。！
    
74. 
    
75. 简单的说就是
    
76. t2.y=5；
    
77. c.remove(t2);  //true
    
78. c.remove(t1); //false
    
79. 你们懂得（感谢大家的谈论，一起进步）

复制代码

你这道题太好了！

这个问题的关键就在与remove元素是否成功！
    boolean remove(Object o)   如果 set 中存在指定的元素，则将其移除（可选操作）。更确切地讲，如果此 set 中包含满足 (o==null ? e==null : o.equals(e)) 的元素 e，则移除它。如果此 set 包含指定的元素（或者此 set 由于调用而发生更改），则返回 true（一旦调用返回，则此 set 不再包含指定的元素）。
       当 t2.y = 5;时，进行(o==null ? e==null : o.equals(e) 判断，为true，也不进行hashCode和equals判定
      当t2.y = 8;时，(o==null ? e==null : o.equals(e) 为false，即System.out.println(c.equals(t2));为false，即不包含t2，c.contains(c2)也为false,但是t2在堆中信息依然存在，信息可以输出

1. public static void main(String[] args) {
   
2.   
   
3. Collection<TwoPoint>  c=new HashSet<TwoPoint>();
   
4.                 TwoPoint t1=new TwoPoint(3,5);
   
5.                 TwoPoint t2=new TwoPoint(3,6);
   
6.                 TwoPoint t3=new TwoPoint(3,7);
   
7.                
   
8.                 c.add(t1);
   
9.                 c.add(t2);
   
10.                 c.add(t3);
    
11.                
    
12.                 System.out.println(c.size());
    
13.                 t2.y= 5;//
    
14.                 System.out.println(c.remove(t2));   //判断是否移除成功！
    
15.                 System.out.println(c.size());
    
16.                 Iterator<TwoPoint> sets=c.iterator();
    
17.                 while(sets.hasNext()){
    
18.                         TwoPoint tp=sets.next();
    
19.                         System.out.println(tp);
    
20.                 }
    

复制代码

我理解的也是这样的，如果改成t2.y=5的话，t2指向的对象与t1相同，也就是说t1==t2的结果是true，
c.remove(t2)；遍历集合，找到t2这个引用所指向的对象，也就是t1所指向的对象，然后將之删除。

看看我做的实验。透彻的分析了下HashSet的特点：

1. package demo;
   
2. import java.util.*;
   
3. 
   
4. public class Demo3 {
   
5. 
   
6. public static void main(String[] args) {
   
7.   
   
8. Collection<TwoPoint>  c=new HashSet<TwoPoint>();
   
9.                 TwoPoint t1=new TwoPoint(3,5);
   
10.                 TwoPoint t2=new TwoPoint(3,6);
    
11.                 TwoPoint t3=new TwoPoint(3,7);
    
12.                
    
13.                 c.add(t1);
    
14.                 c.add(t2);
    
15.                 c.add(t3);
    
16.                
    
17.                 System.out.println("集合的大小是："+c.size());
    
18.                 System.out.println("t1的hashcode是："+t1.hashCode());
    
19.                 System.out.println("t2的hashcode是："+t2.hashCode());
    
20.                 System.out.println("t3的hashcode是："+t3.hashCode());
    
21.                
    
22.                 t2.y=8;
    
23.                
    
24.                 //测试修改后t2的hashcode
    
25.                 System.out.println("t2的hashcode是："+t2.hashCode());
    
26.                
    
27.                
    
28.                 //不管是调用contains还是remove都会在集合中先去找t2的
    
29.                 //显然没有找到。所以这两个方法都是false
    
30.                 System.out.println(c.contains(t2));
    
31.                 System.out.println(c.remove(t2));
    
32.                
    
33.                
    
34.                 System.out.println("集合的大小是："+c.size());
    
35.                
    
36.                
    
37.               //如果把这里改成5
    
38.                 t2.y =5;
    
39.                 System.out.println(c);
    
40.                 //看结果是[3...5, 3...5, 3...7]。
    
41.                 //此时t2的hashcode和集合中t1的相同，但是t2在集合中的hashcode并不改变，不论这个对象的hashcode是多少
    
42.                
    
43.                
    
44.                 c.remove(t2);
    
45.                 System.out.println(c);
    
46.                 //这个时候你remove(t2),我觉得删除的是t1,t2永远都删除不掉了
    
47.                
    
48.                 //验证t1已经删除了
    
49.                 System.out.println(c.remove(t1));
    
50.         }
    
51. 
    
52. }
    
53. class TwoPoint{
    
54. //覆写了hashCode()方法
    
55.         public int hashCode() {
    
56.                 final int prime = 31;
    
57.                 int result = 1;
    
58.                 result = prime * result + x;
    
59.                 result = prime * result + y;
    
60.                 return result;
    
61.         }
    
62.         //覆写了equals()方法
    
63.         public boolean equals(Object obj) {
    
64.                 if (this == obj)
    
65.                         return true;
    
66.                 if (obj == null)
    
67.                         return false;
    
68.                 if (getClass() != obj.getClass())
    
69.                         return false;
    
70.                 TwoPoint other = (TwoPoint) obj;
    
71.                 if (x != other.x)
    
72.                         return false;
    
73.                 if (y != other.y)
    
74.                         return false;
    
75.                 return true;
    
76.         }
    
77.         int x;
    
78.         int y;
    
79.         TwoPoint(int x,int y){
    
80.                 this.x=x;
    
81.                 this.y=y;
    
82.         }
    
83.         public String toString(){
    
84.                 return x+"..."+y;
    
85.         }
    
86. }

复制代码

输出结果：

集合的大小是：3
t1的hashcode是：1059
t2的hashcode是：1060
t3的hashcode是：1061
t2的hashcode是：1062
false
false
集合的大小是：3
[3...5, 3...5, 3...7]
[3...5, 3...7]
false

我来说说吧，你的意思是理解错了，你要删除t2调用remove()方法,他是不会把你的t1给删除的，要是能把你的t1删了
那么这个方法就存在严重的安全隐患，remove()方法在执行时候会调用equals()方法来判断是否有这个元素
(o==null ? e==null : o.equals(e)) 这是remove()的判断条件，里面的o表示要删的元素,里面的e是代表set集合里面的元素
而你把equals()给覆盖了，程序调用remove()方法时候是依据你的equals()来判断的，看看你的equals()
当你t2里面的y改成9的时候，在你的equals()里面执行的是：
if (y != other.y)
return false;
这既然返回false了，remove()方法就认为不是你要删除的，当然是不能删除。
而你把t2改成5了，那么你的equals()只执行的是最后一条return true;这句，那个既然是true，当然就符合remove()的判断
认为是你要删除的元素，所以把你的t2删了，而不是把你的t1删了

xiewen 发表于 2013-5-4 10:19
你这道题太好了！

谢谢，看张老师的视频，他说是改变了y的值就无法从集合中移除，他说移除的时候是根据区域里找的，那我就想，如果把y改成其他区域的值，执行移除的时候会不会把其他区域的移除，所以问题就来了.......

xuluheng718 发表于 2013-5-4 13:43
我来说说吧，你的意思是理解错了，你要删除t2调用remove()方法,他是不会把你的t1给删除的，要是能把你的t1 ...

既然是把t2删了，也就是说他可以从集合中找到这个改变后的t2对么？既然t2.y=5的时候可以找到，那为什么t2.y=8的时候却找不到集合中的这个数了那？

孙胜 发表于 2013-5-4 11:55
看看我做的实验。透彻的分析了下HashSet的特点：输出结果：

集合的大小是：3

其实我也是觉得它找错了，把t1给删了，但是楼下的哥们说不是，现在我也 不清楚，继续实验中...

郑雪 发表于 2013-5-4 10:45
我理解的也是这样的，如果改成t2.y=5的话，t2指向的对象与t1相同，也就是说t1==t2的结果是true，
c.remove( ...

:lol开始我也是这样想的。

strawberry2013 发表于 2013-5-4 10:42
这个问题的关键就在与remove元素是否成功！
    boolean remove(Object o)   如果 set 中存在指定的元素， ...

看完你写的，我觉得你那我的理解就是正确的了，确实是把t1误删了是这样么？

ゞSunペ果果つ 发表于 2013-5-4 14:26
谢谢，看张老师的视频，他说是改变了y的值就无法从集合中移除，他说移除的时候是根据区域里找的，那我就 ...

我也看了张老师的视频是那样说的，你能发现这个问题你挺厉害的

ゞSunペ果果つ 发表于 2013-5-4 14:28
既然是把t2删了，也就是说他可以从集合中找到这个改变后的t2对么？既然t2.y=5的时候可以找到，那为什么t2 ...

是我错了，又验证了次，把t2的值改成和t1时候确实吧t1给删了，因为删除时候是把指针放在集合开始处根据你复写的equals()开始找，条件符合就把t1给删了，因为你的equals()里面，所有条件不符合时候返回的ture，所以remove()返回的是true()

xuluheng718 发表于 2013-5-4 14:49
是我错了，又验证了次，把t2的值改成和t1时候确实吧t1给删了，因为删除时候是把指针放在集合开始处根据你 ...

嗯也验证了，你确实是错了，我也改了信息了，我有个自己验证的方法，你可以看看，我们一起谈论，互相学习，谢谢了，我相信，以后我们谁不会忘记这个事情，这才是自己的知识

xiewen 发表于 2013-5-4 14:37
我也看了张老师的视频是那样说的，你能发现这个问题你挺厉害的

呵呵，就是看着想到了，就动手自己写代码试一试，结果更疑惑了，呵呵就贴出来了，刚才测试一下，我想的确实还是对的

ゞSunペ果果つ 发表于 2013-5-4 14:54
呵呵，就是看着想到了，就动手自己写代码试一试，结果更疑惑了，呵呵就贴出来了，刚才测试一下，我想的确 ...

没复写hashCode()和equals()这两个方法用集合本身的方法是不会出现这个问题的，是你复写equals()方法的时候
出现的安全隐患

其实三楼的那位说的很好了、、、