Johan,

I can't have a thorough look at this until later, but the first thing I
noticed is that MyObject does not have equals and hashCode defined, yet you
are putting instances of it into hashed collections.
Even if that isn't causing the main issue you are demonstrating, you may
witness "surprising" behaviour.

Regards - Cemal
http://jWeekend.com jWeekend 


Johan Compagner wrote:
> 
> it has nothing to do with threading or concurent modification
> 
> Its really a simple test just run this:
> 
> import java.util.ArrayList;
> import java.util.Collection;
> import java.util.Comparator;
> import java.util.HashSet;
> import java.util.Iterator;
> import java.util.TreeSet;
> 
> public class Test
> {
>     public static void main(String[] args)
>     {
>         TreeSet<MyObject> set1 = new TreeSet<MyObject>(new
> Comparator<MyObject>(){
> 
>             public int compare(MyObject o1, MyObject o2)
>             {
>                 return o1.aString.compareToIgnoreCase(o2.aString);
>             }
>         });
> 
>         set1.add(new MyObject("johan"));
>         set1.add(new MyObject("rob"));
> 
>         HashSet<MyObject> set2 = new HashSet<MyObject>();
>         set2.add(new MyObject("johan"));
> 
> 
>         set1.removeAll(set2);
> 
>         System.err.println("this works: " + set1.size() + " == 1, and
> remainng object is " + set1.iterator().next() + " == rob");
> 
>         // add removed back in
>         set1.add(new MyObject("johan"));
> 
>         // increase the size of set2 with some other random others
>         set2.add(new MyObject("random1"));
>         set2.add(new MyObject("random2"));
> 
> 
>         // now size is bigger then set1, call removeall again:
>         set1.removeAll(set2);
> 
>         System.err.println("this doesnt work: " + set1.size() + " != 1, so
> now both objects stil remain! This is because removeAll isnt overwritten
> by
> TreeSet and AbstractSet walks over the smallest set but then compare
> fails");
> 
>         // same for retainAll that also compares wrong.
>         set1.retainAll(set2);
> 
>         System.err.println("set1 is now completely empty, but it should
> have
> 1 left: " + set1);
> 
>         // so both methods should always iterator through the colleciton
> they get and do the compare on its self
> 
>         set1 = new MyFixedTreeSet<MyObject>(new Comparator<MyObject>(){
> 
>             public int compare(MyObject o1, MyObject o2)
>             {
>                 return o1.aString.compareToIgnoreCase(o2.aString);
>             }
>         });
> 
>         set1.add(new MyObject("johan"));
>         set1.add(new MyObject("rob"));
> 
>         set1.removeAll(set2);
> 
>         System.err.println("now this works: " + set1.size() + " == 1, and
> remainng object is " + set1.iterator().next() + " == rob");
> 
>         // add removed back in
>         set1.add(new MyObject("johan"));
> 
>         set1.retainAll(set2);
> 
>         System.err.println("set1 is now correct, it has 1 left: " + set1);
> 
>     }
> 
>     public static class MyObject
>     {
>         private final String aString;
> 
>         MyObject(String str)
>         {
>             aString = str;
>         }
> 
>         @Override
>         public String toString()
>         {
>             return aString;
>         }
>     }
> 
>     public static class MyFixedTreeSet<E> extends TreeSet<E>
>     {
>         public MyFixedTreeSet(Comparator<? super E> comparator)
>         {
>             super(comparator);
>         }
> 
>         @Override
>         public boolean retainAll(Collection<?> c)
>         {
>             ArrayList<E> list = new ArrayList<E>();
>             Iterator<?> e = c.iterator();
>             while (e.hasNext()) {
>                 Object next = e.next();
>                 if (contains(next)) {
>                     list.add((E)next);
>                 }
>             }
>             boolean modified = list.size() < size();
>             if (modified)
>             {
>                 clear();
>                 for (E item : list)
>                 {
>                     add(item);
>                 }
>             }
>             return modified;
>         }
> 
>         @Override
>         public boolean removeAll(Collection<?> c)
>         {
>             boolean modified = false;
>             for (Iterator<?> i = c.iterator(); i.hasNext(); )
>              modified |= remove(i.next());
>             return modified;
>         }
>     }
> }
> 
> johan
> 
> 
> 
> On Wed, Mar 4, 2009 at 15:35, Brill Pappin <br...@pappin.ca> wrote:
> 
>> if "xxx" is a mutable Set then it should work.
>>
>> However you have to be careful about how you remove elements from the
>> collection you working with, depending on your you do it, you'll get an
>> exception about  concurrent modification.
>>
>> - Brill
>>
>>
>> On 3-Mar-09, at 5:44 PM, Johan Compagner wrote:
>>
>>  Is this the same?
>>>
>>> Set set1 = xxx
>>> Collection col1 = xxx;
>>>
>>> foreach (col in col1)
>>> set1.remove(col)
>>>
>>> or
>>>
>>> set1.removeAll(col1);
>>>
>>>
>>> ???
>>>
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: users-unsubscr...@wicket.apache.org
>> For additional commands, e-mail: users-h...@wicket.apache.org
>>
>>
> 
> 

-- 
View this message in context: 
http://www.nabble.com/a-bit-of-topic-but-i-couldnt-resist-....-tp22319709p22349449.html
Sent from the Wicket - User mailing list archive at Nabble.com.


---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscr...@wicket.apache.org
For additional commands, e-mail: users-h...@wicket.apache.org

Reply via email to