Comparable et généricité

**gvdmoort** · 22/03/2014, 13h48

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 Tuplelt;Kgt; implements Comparable {
 
  protected K[] elements;
 
  public K get (int n) throws RuntimeException {
    try {
      return ((K) elements[n]);
    } catch (ArrayIndexOutOfBoundsException e) {
      throw new RuntimeException(quot;elements[quot; + n + quot;] not in tuplequot;);
    }
  }
 
  public int hashCode () {
    Long L = new Long(elements[0].hashCode());
    for (int i=1; i lt; elements.length; i++) {
      long l = ((long) L.hashCode()) lt;lt; 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 lt; elements.length; i++) {
        if (! this.elements[i].equals(t.elements[i])) {
          return false;
        }
      }
    }
    return true;
  }
 
  public String toString () {
    StringBuffer sb = new StringBuffer(quot;[quot;);
    sb.append(elements[0]);
    for (int i=1; i lt; elements.length; i++) {
      sb.append(quot;,quot; + elements[i]);
    }
    sb.append(quot;]quot;);
    return sb.toString();
  }
 
  public int compareTo(Object o) throws ClassCastException {
    Tuple t;
    if (! (o instanceof Tuple)) {
      throw new ClassCastException(o + quot; is not a Tuplequot;);
    } 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 lt; t.elements.length)
        return -1;
      else
        return 1;
    }
  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**adiGuba** · 22/03/2014, 14h21

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract class Tuplelt;K extends Comparablelt;Kgt;gt; ...

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 : Sélectionner tout - Visualiser dans une fenêtre à part
```
public abstract class Tuplelt;Kgt; implements Comparablelt;Tuplelt;Kgt;gt; { // 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 Tuplelt;?gt;) {
			Tuplelt;?gt; other = (Tuplelt;?gt;) obj;
			return Arrays.equals(this.elements, other.elements);
		}
		return false;
	}
 
	@Override
	public String toString() {
		return Arrays.toString(this.elements);
	}

a++

**gvdmoort** · 22/03/2014, 22h08

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract class Tuplelt;K extends Comparablelt;Kgt;gt; ...

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract class Tuplelt;Kgt; implements Comparablelt;Tuplelt;Kgt;gt; { // OK

Proposition 1.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Proposition 2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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+,

**joel.drigo** · 22/03/2014, 22h54

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract class Tuplelt;K extends Comparablelt;Kgt;gt; implements Comparablelt;Tuplelt;Kgt;gt; {

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.

**gvdmoort** · 23/03/2014, 10h16

Re-bonjour,

Envoyé par joel.drigo

Utilises cette signature :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract class Tuplelt;K extends Comparablelt;Kgt;gt; implements Comparablelt;Tuplelt;Kgt;gt; {

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**gvdmoort** · 23/03/2014, 10h46

Re-bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 Tuplelt;K extends Comparablegt; 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 + quot; is not a Tuplequot;);
    } 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 lt; t.elements.length)
        return -1;
      else
        return 1;
    }
  }
}

Par contre, la sous-classe ne compile pas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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+,

**joel.drigo** · 23/03/2014, 11h15

Envoyé par gvdmoort

Re-bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ javac -cp $CLASSPATH -d lib/ Graph/Tuple.java
Graph/Tuple.java:65: compareTo(K) in java.lang.Comparablelt;Kgt; 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public int compareTo(Object o) throws ClassCastException {
    Tuplelt;Kgt; t;
    if (! (o instanceof Tuple)) {
      throw new ClassCastException(o + quot; is not a Tuplequot;);
    } else {
      t = (Tuplelt;Kgt;) 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(Tuplelt;Kgt; t) throws ClassCastException {
        ...
    }

**joel.drigo** · 23/03/2014, 11h17

Envoyé par gvdmoort

Par contre, la sous-classe ne compile pas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
package Graph;
 
public class OrderedTuplelt;K extends Comparablegt; 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.

**bouye** · 04/05/2014, 23h57

En fait, non...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public class OrderedTuplelt;K extends Comparablegt; 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

Comparable et généricité

Langage Java

Discussions similaires

Partager

Partager