Discussion :

[scheme]

Bonjour à tous

Mon problème est très simple, je veux implémenter l'interface Comparable pour une classe qui contient une liste. J'essaie de faire comme ça:

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
public Class QValue implements Comparable{
 
    List<Double> val = new ArrayList<Double>();
 
   //constructeur etc
 
    public int compareTo(Object o) {
        QValue v = (QValue) o;
        if (this.val.size() == v.val.size()) {
            if(this.val.get(0) < v.val.get(0)) return -1;
            else if(this.val.get(0) > v.val.get(0)) return 1;
            else return 0;
        } else if (this.val.size() > v.val.size()) {
            return (1);
        } else return -1;
    }
}

Et ça plante lamentablement, je peux accéder à v.val.size, mais pas à v.val.get(0)

Auriez-vous une solution ?

Merci d'avance

[tchize_]

votre liste est probablement vide.

Et votre critère de comparaison est curieux.

[scheme]

Le probleme vient à la compilation, pas au runtime, je ne pense pas que le remplissage de la liste soit en cause.

Je suis d'accord que la comparaison n'est pas efficace, on m'impose cette méthode.

Le message d'erreur est:

Code :

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

1
2
operator < cannot be applied to java.lang.Object,java.lang.Double
if(this.val.get(0) < v.val.get(0)) return -1;

Je te remercie de m'aider

[tchize_]

heu, vous déclarer que o est de type QValue alors que vous comparer avec un classe appelée test. Et il semble que "val" dans QValue soit de type List<Object>

[scheme]

Oui pardon, j'ai écris que la classe s'appelle "test" un peu à la va vite, en fait elle s'appelle "QValue". Je vais modifier ça dans mon exemple.

C'est vrai que c'est un peu hasardeux d'implémenter la méthode compareTo avec un Object en paramètre, il aurait été plus judicieux de le faire en prenant directement un objet de type QValue.

En fait, ma classe implémente l'interface Comparable, c'est pour ça que la méthode compareTo a cette signature. Je pensais que c'était une bonne idée d'implémenter une interface "standard", mais peut-être vaut-il mieux que je redéfinisse une interface pour la comparaison ?

Peut-être aussi que je définis mal ma List<Double> et Java voit une List<Object>, je ne comprend pas trop pourquoi ni comment améliorer cela.

[tchize_]

Oui pardon, j'ai écris que la classe s'appelle "test" un peu à la va vite, en fait elle s'appelle "QValue". Je vais modifier ça dans mon exemple.

Le problème c'est que le code que vous donnez maintenant ne peut pas retourner l'erreur de compilation que vous donnez.

Veuillez donc nous donner votre code réel et l'erreur que vous avez, merci.

[scheme]

edit: post supprimé.

[billynirvana]

Pourquoi ne pas utilser le equals de la classe Double?!

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
public Class QValue implements Comparable{
 
	List<Double> val = new ArrayList<Double>();
 
	//constructeur etc
 
	public int compareTo(Object o) {
		QValue v = (QValue) o;
 
		//prévoir test si val ou o est null
 
		if (this.val.isEmpty() == false && this.val.size() == v.val.size() && this.val.get(0) != null) {
			return this.val.get(0).equals(v.val.get(0));
 
		} else if (this.val.size() > v.val.size()) {
			return 1;
 
		} else {
			return -1;
		}
	}
}

[scheme]

C'est surement une bonne idée, mais quand tu écris ça:

Code :

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

return this.val.get(0).equals(v.val.get(0));

Premièrement, ça retourne un boolean et pas un int, mais on pourrait contourner. Ce qui est plus génant c'est que ça test si les valeurs sont égales, pas quelle valeur est la plus grande. Ce qui bloque je pense, c'est l'utilisation des opérateurs < et >, je ne vois pas trop comment procéder

[billynirvana]

C'est surement une bonne idée, mais quand tu écris ça:

Code :

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

return this.val.get(0).equals(v.val.get(0));

Premièrement, ça retourne un boolean et pas un int, mais on pourrait contourner. Ce qui est plus génant c'est que ça test si les valeurs sont égales, pas quelle valeur est la plus grande. Ce qui bloque je pense, c'est l'utilisation des opérateurs < et >, je ne vois pas trop comment procéder

Bien vu et je m'excuse, j'avais en tête la méthode compareTo et j'ai écrit trop vite equals. Remplacez donc ce que j'ai écrit plus haut par compareTo.

[scheme]

Merci beaucoup à tous les deux, ça fonctionne très bien maintenant !

J'aimerais bien avoir une explication sur la nécessité de déclarer la liste de cette manière:

Code :

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

protected List<Double> l_val= new ArrayList<Double>();

J'ai lu à plusieurs endroits que Java faisait le cast tout seul et que c'était la nouvelle façon d'utiliser les lists depuis java 5, en réalité il n'en est rien ?

[nicolofontana12]

Bonjour à tous


[code]public Class QValue implements Comparable{

List<Double> val = new ArrayList<Double>();

Merci d'avance

Tu avais aussi ecrit Class au lieu du mot class, donc le compilateur ne le verra pas;

Pour eviter le cast, je te propose comme ça:

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
 
 
import java.util.ArrayList;
import java.util.List;
 
public class QValue implements Comparable<QValue> {
 
	List<Double> val = new ArrayList<Double>();
 
	public int compareTo(QValue otherQvalue) {
 
		return (this.val.size() == otherQvalue.val.size()) ? ((this.val.get(0) - otherQvalue.val.get(0)<0)?-1:1)
				                                           : this.val.size() - otherQvalue.val.size();
 
	}
 
 
}