Comparable et généricité

Version imprimable

Bonjour à tous,

J'ai implémenté une classe Tuple dont l'utilité est de pouvoir rassembler des éléments homogènes dans un conteneur non modifiable qui peut servir de clé à une map.

Il y a une classe abstraite Tuple et deux sous-classes OrderedTuple et UnorderedTuple. Pour ces deux dernières, les éléments en nombre variables sont passés en arguments à l'unique constructeur (par la suite, on ne peut donc les modifier).

J'ai introduit des méthodes hashCode et equals, et cette classe semble fonctionner. Le problème est que je souhaiterais en faire une classe comparable. Pour effectuer la comparaison, on itère sur les éléments du tuple. Il faudrait donc pouvoir comparer ceux-ci, mais c'est là que ça coince, vu que la méthode compareTo n'est pas connue pour le type de ces éléments.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
public abstract class Tuple<K> implements Comparable {
 
  protected K[] elements;
 
  public K get (int n) throws RuntimeException {
    try {
      return ((K) elements[n]);
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new RuntimeException("elements[" + n + "] not in tuple");
    }
  }
 
  public int hashCode () {
    Long L = new Long(elements[0].hashCode());
    for (int i=1; i < elements.length; i++) {
      long l = ((long) L.hashCode()) << 23; // ça semble meilleur avec un premier
      l     += elements[i].hashCode();
      L      = new Long(l); 
    }
    return L.hashCode();
  }
 
  public boolean equals(Tuple t) {
    if (t == null) {
      return false;
    } else if (this.elements.length != t.elements.length) {
      return false;
    } else {
      for (int i=0; i < elements.length; i++) {
        if (! this.elements[i].equals(t.elements[i])) {
          return false;
        }
      }
    }
    return true;
  }
 
  public String toString () {
    StringBuffer sb = new StringBuffer("[");
    sb.append(elements[0]);
    for (int i=1; i < elements.length; i++) {
      sb.append("," + elements[i]);
    }
    sb.append("]");
    return sb.toString();
  }
 
  public int compareTo(Object o) throws ClassCastException {
    Tuple t;
    if (! (o instanceof Tuple)) {
      throw new ClassCastException(o + " is not a Tuple");
    } else {
      t = (Tuple) o;
    }
    int i = 0;
    try {             // on itère sur les éléments   
      while (true) {  // tant qu'on n'a pas atteint la fin d'un tableau
                      // on compare les éléments
        if (! this.elements[i].equals(t.elements[i])) {
 
          // s'ils sont différents, on renvoie leur comparaison
          return this.get(i).compareTo(t.get(i));
 
        } else {
 
          // sinon, on compare les suivants
          i++;
 
        }
      }
    } catch (Exception e) {
      if (this.elements.length < t.elements.length)
        return -1;
      else
        return 1;
    }
  }
}

Code:

1
2
3
4
5
6
Graph/Tuple.java:66: cannot find symbol
symbol  : method compareTo(java.lang.Object)
location: class java.lang.Object
          return this.get(i).compareTo(t.get(i));
                            ^
1 error

Il me semblerait aussi logique que compareTo renvoie une exception si le type des éléments de l'instance est différent de celui du tuple passé en argument, mais, je ne vois pas du tout comment faire.

Merci d'avance pour toute réponse,

G.

Salut,

C'est normal que tu ne puisses pas appeler la méthode compareTo(), car K n'est pas défini comme un objet Comparable.

Tu as deux solutions.

Soit définir K comme Comparable, mais dans ce cas tu ne pourras pas l'utiliser avec des objets non-comparable :

Code:

public abstract class Tuple<K extends Comparable<K>> ...

Soit caster les objets K en "Comparable" avant d'appeler compareTo(), au risque de recevoir une exception si ce n'est pas le cas.
Le type Comparable est paramétré, et il est préférable de l'utiliser de la sorte lorsqu'on l'implémente :

Code:

public abstract class Tuple<K> implements Comparable<Tuple<K>> { // OK

A quoi sert ce try/catch dans get() ? Pourquoi ne pas laisser remonter directement l'ArrayIndexOutOfBoundsException ?
Attention car equals(Tuple) ne redéfini pas equals(Object) ! Utilises l'annoation @Override pour être sûr ;)
Tu sembes ignorer l'existance de la classe Arrays. Elle possède pourtant des implémentations bien mieux adaptés pour tes méthodes hashCode(), equals() et toString() :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 @Override public int hashCode() { return Arrays.hashCode(this.elements); } @Override public boolean equals(Object obj) { if (obj==this) { return true; } if (obj instanceof Tuple<?>) { Tuple<?> other = (Tuple<?>) obj; return Arrays.equals(this.elements, other.elements); } return false; } @Override public String toString() { return Arrays.toString(this.elements); }
a++

Merci beaucoup pour ta réactivité, mais ni l'une ni l'autre solution ne fonctionne:

Citation:

Envoyé par adiGuba

Tu as deux solutions.

Soit définir K comme Comparable, mais dans ce cas tu ne pourras pas l'utiliser avec des objets non-comparable :

Code:

public abstract class Tuple<K extends Comparable<K>> ...

Soit caster les objets K en "Comparable" avant d'appeler compareTo(), au risque de recevoir une exception si ce n'est pas le cas.

Code:

public abstract class Tuple<K> implements Comparable<Tuple<K>> { // OK

Proposition 1.
Code:

1 2 3 4 5 $ javac -cp $CLASSPATH -d lib/ Graph/Tuple.java Graph/Tuple.java:65: compareTo(K) in java.lang.Comparable<K> cannot be applied to (java.lang.Comparable) return this.get(i).compareTo(t.get(i)); ^ 1 error
Proposition 2:
Code:

1 2 3 4 5 6 7 $ javac -cp $CLASSPATH -d lib/ Graph/Tuple.java Graph/Tuple.java:65: cannot find symbol symbol : method compareTo(java.lang.Object) location: class java.lang.Object return this.get(i).compareTo(t.get(i)); ^ 1 error
En l'état, tout ce qui se passe va au-delà de mon entendement et de mes maigres compétences...

a+,

22/03/2014, 22h54
joel.drigo

Salut,

Les deux extraits de code que tu as laissés dans l'extrait de citation tronquée de @AdiGuba ne sont pas les deux alternatives qu'il te proposait : le premier code est la première solution, et la seconde n'est pas accompagné d'un code. Le second bout de code était simplement un conseil d'implémentation de l'interface Comparable, qui est paramétrée. Il aurait peut être dû dire obligatoire que préférable. Utilises cette signature :

Code:

public abstract class Tuple<K extends Comparable<K>> implements Comparable<Tuple<K>> {

Ainsi, tu peux avoir une méthode de comparaison de Tuple<K>. Et elle peut appeler compareTo sur le retour de l'appel de get(int), qui renvoyant du K, impose à ce K d'être Comparable pour pouvoir avoir une méthode compareTo.

Re-bonjour,

Citation:

Envoyé par joel.drigo

Utilises cette signature :

Code:

public abstract class Tuple<K extends Comparable<K>> implements Comparable<Tuple<K>> {

Ainsi, tu peux avoir une méthode de comparaison de Tuple<K>. Et elle peut appeler compareTo sur le retour de l'appel de get(int), qui renvoyant du K, impose à ce K d'être Comparable pour pouvoir avoir une méthode compareTo.

Désolé, ça ne fonctionne toujours pas:
Code:

1 2 3 4 5 $ javac -cp $CLASSPATH -d lib/ Graph/Tuple.java Graph/Tuple.java:65: compareTo(K) in java.lang.Comparable<K> cannot be applied to (java.lang.Comparable) return this.get(i).compareTo(t.get(i)); ^ 1 error

(suite)

Re-bonjour,

Les choses évoluent un peu. Finalement, la classe-mère compile sous cette forme (ne me demandez pas pourquoi):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public abstract class Tuple<K extends Comparable> implements Comparable {
 
  protected K[] elements;
 
  // (autres méthodes omises)
 
  public int compareTo(Object o) throws ClassCastException {
    Tuple t;
    if (! (o instanceof Tuple)) {
      throw new ClassCastException(o + " is not a Tuple");
    } else {
      t = (Tuple) o;
    }
    int i = 0;
    try {             // on itère sur les éléments   
      while (true) {  // tant qu'on n'a pas atteint la fin d'un des tableaux
                      // on compare les éléments
        if (! this.elements[i].equals(t.elements[i])) {
 
          // s'ils sont différents, on renvoie leur comparaison
          return this.get(i).compareTo(t.get(i));
 
        } else {
 
          // sinon, on compare les suivants
          i++;
 
        }
      }
    } catch (Exception e) {
      if (this.elements.length < t.elements.length)
        return -1;
      else
        return 1;
    }
  }
}

Par contre, la sous-classe ne compile pas:

Code:

1
2
3
4
5
6
7
8
9
10
package Graph;
 
public class OrderedTuple<K extends Comparable> extends Tuple {
 
  public OrderedTuple (K... elements) {
    this.elements = new K[elements.length];
    for (int i = 0; i < elements.length; i++)
      this.elements[i] = elements[i];
  }
}

Code:

1
2
3
4
5
6
7
$ javac -cp $CLASSPATH -d lib/ Graph/OrderedTuple.java
Graph/OrderedTuple.java:6: generic array creation
    this.elements = new K[elements.length];
                    ^
Note: Graph/OrderedTuple.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error

«generic array creation» ???

a+,

Citation:

Envoyé par gvdmoort

Re-bonjour,

Désolé, ça ne fonctionne toujours pas:

Code:

1
2
3
4
5
$ javac -cp $CLASSPATH -d lib/ Graph/Tuple.java
Graph/Tuple.java:65: compareTo(K) in java.lang.Comparable<K> cannot be applied to (java.lang.Comparable)
          return this.get(i).compareTo(t.get(i));
                            ^
1 error

Oui, c'est parce que tu as écrit :

Code:

1
2
3
4
5
6
7
public int compareTo(Object o) throws ClassCastException {
    Tuple t;
    if (! (o instanceof Tuple)) {
      throw new ClassCastException(o + " is not a Tuple");
    } else {
      t = (Tuple) o;
    }...

Quand on utilise des types paramétrés, on les utilises partout sous forme paramétré :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public int compareTo(Object o) throws ClassCastException {
    Tuple<K> t;
    if (! (o instanceof Tuple)) {
      throw new ClassCastException(o + " is not a Tuple");
    } else {
      t = (Tuple<K>) o;
    }
    return compareTo(t);
}
 
    // normalement c'est cette méthode que l'interface t'oblige à implémenter (ça compilera parce que ta classe est abstraite...)
    public int compareTo(Tuple<K> t) throws ClassCastException {
        ...
    }

23/03/2014, 11h17
joel.drigo
Citation:
Envoyé par gvdmoort

Par contre, la sous-classe ne compile pas:

Code:

1 2 3 4 5 6 7 8 package Graph; public class OrderedTuple<K extends Comparable> extends Tuple { public OrderedTuple (K... elements) { this.elements = new K[elements.length]; ...

...

«generic array creation» ???
On ne peut pas créer un tableau à partir d'un paramètre générique : on est obligé de mentionner un nom de classe.

En fait, non...
Code:

1 2 3 4 5 6 7 8 public class OrderedTuple<K extends Comparable> extends Tuple { private final K[] elements; public OrderedTuple(K... elements) { this.elements = Arrays.copyOf(elements, elements.length); } }
EDIT - ce qui revient en lisant les sources a faire un

Code:

Array.newInstance(elements.getClass(), elements.length);

suivi d'une recopie des éléments a mano.
Mais bon voila, personne ne pense jamais a aller fouiller du cote des methodes des classe Arrays et Array...