Discussion :

[Kerod]

Bonjour (bonsoir),

Je cherche actuellement un moyen de tester le contenu d'un vecteur. Le problème (disons pour moi) est qu'il peut contenir soit un float soit un nouveau vecteur.

Comment dois-je m'y prendre pour la comparaison ?

Voici mon code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0; i < tailleListe(); i++)
    {
            Object currentElement = liste.get(i);
            if((Float) currentElement == java.sql.Types.FLOAT)
                chaine += currentElement;
            else 
            {
                Class cls = currentElement.getClass();
                if(cls.isArray())
                    chaine += listeEnChaine((Vector) currentElement);
            }
 
    }

Pour la comparaison de types je vois pas trop comment le faire

[Kerod]

Je viens de faire comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
for(int i = 0; i < liste.size(); i++)
    {
            Object currentElement = liste.get(i);
            if(currentElement.getClass().isArray())
                chaine += listeEnChaine((Vector) currentElement);
            else
            {
                chaine += currentElement;
            }
    }

Ca vous parait correct ??

[broumbroum]

Salut! Tu dois connaitre la condition instanceof normalement:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Vector v = new Stack(); // c'est plus efficace paraît-il, c'est une sous-classe
E e = new E(); // E pour n'importe quelle classe
v.add(element);
v.add(new Vector());
Object o = null;
//(...)
while(v.peek() != null) {
  if((obj = v.pop()) instanceof Vector) 
          //ce que tu veux en faire du Vecteur, recursif?
           obj;
   else // ce que tu veux garder... ? ici c'est pas un vecteur
        obj;
}

[Kerod]

En fait je suis limité au classe vector, list. Le reste n'est pas trop autorisé.

Et pour info j'ai un vecteur contenant des éléments qui peuvent être soit un float, soit une chaine, soit un vecteur. Le seul problème que j'ai c'est que je veux pouvoir parcourir tout le vecteur ainsi que ceux qui sont dans le vecteur lui même. Et donc il faudrait que je teste pour savoir si vecteur ou pas

[sinok]

Dans ton cas le problème est qu'instanceof ne gère pas les types primitifs. Enfin ce n'est pas un problème non plus car ton vecteur ne contient pas de type primitif mais des Objets. Donc si tu ajoutes à ton vecteur un int tu auras dans les faits un Integer dans ton Vecteur (java planque ce mécanisme depuis la version 1.5, avant il fallait procéder à la mimine et ajouter un Integer à ton Vector).

D'ailleurs il vaut mieux en général utiliser une List qu'un Vector (qui est une classe déconseillée, mais qui n'est pas deprecated à cause des multiples utilisations de Vector, en particulier dans Swing).

Sinon en général il est recommandé d'éviter de mettre des objets hétérogènes dans une même collection en prog objet, que ce soit java ou C++ ou C# ou smalltalk. Il existe toujours des solutions pour contourner ceci. (par exemple créer une collection d'objet qui gère en interne les multiples valeurs possibles pour les éléments de la collection).
Donc je dirais avant tout que ton problème est situé au niveau de la conception.

Sinon pour faire ce que tu voulais je préconiserai ceci:

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

List<Object> l = new ArrayList<Object>();
l.add("a");
l.add(1); //si tu es en 1.5 ça marche (cf autoboxing/unboxing voir la FAQ pour comprendre), sinon new Integer(1) a la place s
l.add(new Vector());
Object o = null;
StringBuffer chaineDest = new StringBuffer();  //Classe optimisée pour les append car non mutable au contraire de String qui est immuable cf tuto de gfx 
for(int i = 0; i<l.size(); i++) { //l'ArrayList est optimisée pour être utilisée avec des boucles for, dans le cas d'un linkedList par exemple mieux vaut passer par un Iterator
   Object o = l.get(i);
   if( o instanceof List){
      surementFaireDuRecursif(chaineDest);
   } else {
      chaineDest.append(o.toString(); //vrai tout le temps vu que tu manipules des objets.
   }
}

return chaineDest.toString(); //renvoie la chaine correspondant au contenu du buffer

[Kerod]

Merci pour cette réponse mais tu as précisé dans le code que ce sera vrai tout le temps. Il y a pas moyen de faire mon récursif que si je suis tombé sur un Vector ?

[sinok]

c'est le o.toString qui marchera à tous les coups désolé le "vrai" était mal choisi comme expression ^^ désolé, en fait c'est vrai tout le temps, sauf que séquentiellement tu as déja testé si tu avais une List (d'ailleurs Vector implémente l'interface List) donc le cas List ne sera pas possible dans le else

[Kerod]

Ok donc si j'ai bien compris le if nous dit si c'est une liste sinon c'est ma chaine ?

[sinok]

Mouaip c'est le but de l'opérateur instanceof qui te donne le type dynamique (cf cours de POO) de l'objet (que tu aurrais également pu récupérer grace au getClass, mais bon ça aurait fait un code plus verbeux et celà n'est jamais top top)

[Kerod]

Ok je vois. Donc j'oublie mon code barbare avec getClass() et je me tourne vers instanceof.

Merci beaucoup pour ton aide et tes conseils

[®om]

Si j'ai bien compris ton problème, qui à première vue paraît technique : tester le type des objets de ta collections, mais qui en fait semble plutôt être un problème de conception...

Que penses-tu d'une classe Noeud comme ça (qui n'a pas la prétention d'être parfaite, c'est juste une proposition, comme ça tu peuxsavoir avec la méthode isLeaf() de résoudre ton problème... Et comme ça tu peux utiliser une Collection de Noeuds...

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
public class Noeud {
 
    private float f;
    private List<Noeud> sub;
    private boolean leaf;
 
    public Noeud(float f) {
        this.f = f;
        leaf = true;
    }
 
    public Noeud(List<Noeud> sub) {
        this.sub = sub;
        leaf = false;
    }
 
    public boolean isLeaf() {
        return leaf;
    }
 
    public List<Noeud> getSousNoeuds() {
        assert !isLeaf() : "Ne doit pas être une feuille.";
        return sub;
    }
 
    public float getValue() {
        assert isLeaf() : "Doit être une feuille.";
        return f;
    }
 
}

Sinon tu pourrais aussi faire un héritage:
Noeud
+- NoeudInterne
+- NoeudFeuille

Comme ça tu peux toujours utiliser une Collection<Noeud>, mais il faudra faire des instanceif quand même...

[Kerod]

En fait, je pense que je vais garder ma structure actuelle et y ajouter quelque fonctionnalité. C'est-à-dire du style faire une structure qui contiendra le type de la variable plus la variable elle meme.Ainsi je n'aurai plus qu'à tester le type de la valeur (float, list, opérateur binaire) et après je n'aurai qu'à faire le traitement approprié

Meci à toi pour m'avoir inspiré

[®om]

Vu ta réponse, ton arbre semble servir à représenter une expression arithmétique...

Si c'est ça, tu pourras faire une classe par "élément" qui implémentent tous la même interface (parce que par exemple, pour opérateur binaire, tu ne peux pas avoir une liste qui contient 3 éléments en dessous, et cette structure permettrait de l'interdire).

Ensuite, tu peux utiliser le design pattern "Visiteur", pour parcourir de manière "générique" (affichage, traitement...) ton arborescence.

[Kerod]

Ben en fait je comptais partir sur une structure contenant un int qui sera défini (float, opérateur, liste) puis une variable de type Object qui prendra la valeur par conséquent j'aurai pas d'erreur de type