Java: How to get around the lack of an equatable interface?

Question

As far as I know, things like SortedMapor SortedSet, use compareTo(and not equals) for types Comparable<?>to check for equality ( contains, containsKey).

But what if certain types are equivalent in concept and not comparable?
(Hash codes, memory addresses, ...)

I need to declare Comparator<?>and override the method int compareTo(T o1, To2). Well, I can return 0 for instances that are considered equal. But, for unsubstantiated cases, what do I return when the order is not obvious?

Is the approach of using SortedMap or SortedSet on equatable , but (on the concept) is not comparable to the type of good, in any case?

Thank!

EDIT:
I don't want to keep things sorted, but I would use a “regular” map and set, I could not “override” the equality behavior.

EDIT 2:
Why can't I just override equals(...):
I need to change the behavior of foreign class equality. I can’t edit it.

EDIT 3:
Think of .NET: they have an IEquatable interface that the cat modifies equality behavior without touching comparable behavior.

4:
compareTo return 0 1 ? ? , , SortedMap/SortedSet compareTo . , , ? . * . , . . 1 .

5:
? ? : Comparator?

6:
Mark Peters waxwing . , equals hashCode, .

Answer 1

.

public class Foreign {
  // undesired equals() and hashCode() implementation
}


public class ForeignWrapper {
   private Foreign foreign;

   public ForeignWrapper(Foreign foreign) {
      this.foreign = foreign;
   }

   public void equals() {
       // your equals implementation, using fields from foreign
   }

   public int hashCode() {
       // your hashCode implementation, using fields from foreign
   }

}

new ForeignWrapper(foreign) HashSet/HashMap. , , , .

Answer 2

, SortedMap SortedSet , . , SortedSet. , , , , "".

HashMap/Set.

Edit # 2

, - . , .

Edit # 3

Java equals . .

Edit # 4

, 1 !

SortedSets , . . , , , A.compareTo(B) > 0, B.compareTo(A) < 0. , .

public static void main(String[] args) throws Exception {
    SortedSet<MyClass> set = new TreeSet<MyClass>();
    MyClass one = new MyClass(1);
    set.add(one);
    set.add(new MyClass(2));
    set.add(new MyClass(3));
    System.out.println(set.contains(one));
}
private static class MyClass implements Comparable<MyClass> {
    private final int data;
    private MyClass(int data) { this.data = data; }
    public int compareTo(MyClass o) { return (data == o.data ? 0 : 1); }
}

false, , , .

Answer 3

, / .

, , HashMap HashSet ? SortedMap SortedSet, .

Answer 4

, "" , "" .

, ?

, () O (log n) . , , - (HashMap, HashSet), O (1).

Answer 5

SortedMap SortedSet equatable, ( ) ?

. , , ?

equals() hashcode() Map/Set.

Answer 6

hashCode, , , HashMap .

Answer 7

, , , , somethings, Set/Map, , Object.equals.

AbstractSet AbstractMap AbstractCollection.contains, .

, , , .

. http://java.sun.com/javase/6/docs/api/java/util/AbstractSet.html http://java.sun.com/javase/6/docs/api/java/util/AbstractCollection.html#contains(java.lang.Object)

Answer 8

HashMap HashSet, Equality

interface Equality<T>//Defines the equality behavior
{
   int hashCode(T t);//Required, always make sure equals = true => same hashCode
   boolean areEqual(T t,Object t2);
}
class EqualWrapper<T>//Wraps object and equality for the HashMap/Set
{
   T object;
   Equality<T> equal;
   int hashCode(){return equal.hashCode(object);}
   boolean equals(Object o){return equal.areEqual(object,o);}

}
class MySet<T>extends AbstractSet<T>
{
   private HashSet<EqualWrapper<T> > internalSet = new HashSet<T>();
   private Equality<T> equal;
   public MySet(Equality<T> et){equal = et;}
   // TODO implement abstract functions to wrapp 
   // objects and forward them to 
   // internalSet  
}

, . , jre

Answer 9

, ; , , ? , , SortedMap SortedSet. ( ? Map Set).

equals() Java Object, Object, equals(). , equals() , , .

(, HashMap HashSet), hashCode(), , hashCode() equals() (. Object , ).

Answer 10

, , SortedXXX . , , - , , , " " - , .

Answer 11

(custom) Comparator, Sorted [Set | Map] ...

javadocs : All keys inserted into a sorted map must implement the Comparable interface (or be accepted by the specified comparator).

SortedSet<MyObject> s = new TreeSet<MyObject>(new Comparator<MyObject>() {
    @Override
    public int compare(T o1, T o2) {
        // your very specific, fancy dancy code here
    }
});

http://java.sun.com/javase/6/docs/api/

Answer 12

, (, ), - Set Map, , LinkedHashSet LinkedHashMap .

---

: :

. .

/? TreeSet TreeMap Comparator. .

SortedSet<String> set = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);

( String ).

. :

• Sun:

Answer 13

, "" , "" -.

equals() . , IEquatable. SortedSet/SortedMap, , @ptomli, .

Using a HashMap / HashSet instead seems like a good suggestion. Have you looked at them?