Thank you all you guys are great, that is exactly what i did.
Nadav

That's exactly what I meant.  Either identityHashCode() or something
else can be used to distinguish non identical but equivalent elements.
Even random() or System.currentTimeMillis() work.

package util;

import java.util.Comparator;
import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;

public class Duplicates {

    public static void main( String[] args ) {
        // silly test with strings
        SortedSet s = new TreeSet( new Comparator() {
            public int compare( Object o1, Object o2 ) {
                String s1 = ( String ) o1;
                String s2 = ( String ) o2;
                int c = s1.compareTo( s2 );
                return c == 0 ? System.identityHashCode( s1 ) -
System.identityHashCode( s2 ) : c;
//                return c == 0 ? new Random().nextInt() : c;
            }
        } );

        // use new to create different objects
        s.add( "foo" );
        s.add( "bar" );
        s.add( new String( "foo" ) );
        s.add( new String( "foo" ) );
        s.add( new String( "foo" ) );
        s.add( new String( "foo" ) );

        System.out.println( s );
    }
}

=> [bar, foo, foo, foo, foo, foo]

Kind regards

    robert

Absolutely not.

On a typical, 32-bit implementation it is easy to find two objects with
the same identityHashCode at the same time. I can't see a particularly
feasible way of ensuring uniqueness.

What I suppose you could do, if you compare two objects with the same
identityHashMap is to keep a note, with WeakReferences, as to which you
decided should come first. Use, say, a
ConcurrentMap<Integer,List<WeakReference<Object>>>.

import java.util.List;
import java.lang.ref.WeakReference;

class ArbitraryComparator
implements java.util.Comparator<Object>
{
    public static final java.util.Comparator<Object> INSTANCE =
        new ArbitraryComparator();

    private static final
        java.util.concurrent.ConcurrentMap<
            Integer,List<WeakReference<Object>>
        > tie = new java.util.concurrent.ConcurrentHashMap<
            Integer,List<WeakReference<Object>>
        >();

    private ArbitraryComparator() {
    }
    public int compare(Object a, Object b) {
         // Check if really are identical.
         if (a == b) {
             return 0;
         }

         // Try hash code.
         int aHash = System.identityHashCode(a);
         int bHash = System.identityHashCode(b);
         if (aHash < bHash) {
             return -1;
         }
         if (aHash > bHash) {
             return 1;
         }

         // Last resort - find or make an arbitrary decision.
         Integer hash = aHash;
         List<WeakReference<Object>> list = tie.get(hash);
         if (list == null) {
             List<WeakReference<Object>> newList =
                 new java.util.ArrayList<WeakReference<Object>>();
             List<WeakReference<Object>> oldList =
                 tie.putIfAbsent(hash, newList);
             list = oldList==null ? newList : oldList;
         }
         synchronized (list) {
             // Clean list.
             for (
                 java.util.Iterator<WeakReference<Object>> iter =
                     list.iterator();
                 iter.hasNext();
             ) {
                 WeakReference<Object> ref = iter.next();
                 if (ref.get() == null) {
                     iter.remove();
                 }
             }
             // Compare on arbitrary index.
             int aIndex = index(list, a);
             int bIndex = index(list, b);
             assert aIndex != bIndex;
             return aIndex<bIndex ? -1 : 1;
         }
    }
    // Finds index of object in list, adding to list if necessary.
    private static int index(
        List<WeakReference<Object>> list, Object obj
    ) {
        int num = list.size();
        for (int ct=0; ct<num; ++ct) {
            if (list.get(ct) == obj) {
                // Found.
                return ct;
            }
        }
        // Not found
        list.add(new WeakReference<Object>(obj));
        return num;
    }
}

Disclaimer: Not tested in any way.

Tom Hawtin

Which does not satisfy the "in general" part of my statement.

Nope it is not guaranteed at all.

As I remember it really isn't just the address. As I remember they
permute it a little bit as a minor security tweak so that you don't know
the location in memory. As I recall it was like they computed a random
value at the startup of the VM that was used to permute the identity
hash. But I could be remembering totally wrong.

I've had this discussion several times before and in general there is no
way to accomplish a sorted implementation of List using TreeSet.
Actually you need a different abstraction than List because List assumes
you can insert items where you want. Bag is probably the more correct
and widely used term. A bag could be a super interface of List.

By "in general", I mean that:
- It allows multiple copies of objects that have the same contents to be
inserted and guarantees that they sorted in a stable fashion (they don't
suddenly change order).
- It allows multiple instances of the same object to be inserted.
- It works on all VMs and all platforms.
- The contract of Comparator is not violated.

It is possible to satisfy some subset of that using TreeSet and
Comparator, but not all of it.