Yop,

Un moyen très pratique de faire des comparaisons dans des List java est d'utiliser l'interface Comparable
Il suffit que ton objet implémente Comparable, puis surcharger la méthode compareTo(Object o)

compareTo() doit retourner -1 si l'élement courant est plus petit que l'objet o, 0 si égal, 1 si plus grand.

Ensuite, pour trier ta List, il te suffit juste de faire
Collections.sort(taListeDElements);
Et ta liste est ordonnée.
Attention, c'est une méthode statique, tu dois l'appeller comme ci-dessus.

Petit exemple :

class Element implements Comparable {

 int x;

 int y;

...

int compareTo(Object o){
         Element elt = (Element) o;
         
         if(this.x < elt.x) return -1;
         if(this.x > elt.x) return 1;
         return 0;
}
...

}

Crois-moi, ce tri est très rapide, tu n'arriveras pas à de telles performances en faisant un algo à la main.

Que veux-tu faire exactement avec tes comparaisons de distances ?

http://java.sun.com/j2se/1.4.2/docs/api … rable.html
http://java.sun.com/j2se/1.4.2/docs/api … util.List)

Dernière modification par 22_80 (2008-10-28 19:29:30)

oyster_twiter a écrit:

ai je été clair ?

... ... ben ... j'avoue que non ...

Juste une remarque cependant ... un ArrayList se manipule comme un tableau :
obj[i]  <=> myArrayList.get(i) ... la seule différence, c'est qu'une ArrayList est en fait beaucoup plus puissante ... je développerai après.

Sinon, si vraiment ça te bloque, tu peux toujours transformer ton ArrayList en tableau :
http://java.sun.com/j2se/1.4.2/docs/api … #toArray()

... mais c'est vrai que c'est pas très clair ton histoire de double boucle ...

Dernière modification par 22_80 (2008-10-29 10:18:40)

ahah

ok,

bon, le fait de travailler avec une ArrayList est un choix délibéré donc je ne veux pas retouner au tableau (haha).
je te fourni la partie du code qui me pose problème :

//-------------------------------- springs ---------------------

    // CALC BOUNCE FORCES


   vec2d v = new vec2d(0,0);
    vec2d diff = new vec2d(0,0);

    // CALC BOUNCE FORCES
    for (int i=0; i < P_temp_A.size();i++) {
      for (int j=0; j<i; j++) {
        //DERIVS = (derivative)D_A.get(i)  ;
        PRTS_temp = (particle)P_temp_A.get(i)  ;
        particle PRTS_temp2 = (particle)P_temp_A.get(j)  ;

        // calc the vector which represents distance
        diff.set(PRTS_temp.pos);
        diff.sub(PRTS_temp2.pos);
        float distance = diff.length();

        // collision check!
        if (distance < (PRTS_temp.radius + PRTS_temp2.radius)){
          // 1 to 0 based on closeness
          float strength = (distance / (PRTS_temp.radius + PRTS_temp2.radius));
          // angle of collision
          float dir = (float)Math.atan2(-diff.y, diff.x);

          if (PRTS_temp2.bFixed != true){
            // dampen on collision
            v.set(PRTS_temp2.vel);
            v.mult(0.03f );
            PRTS_temp2.frc.sub(v);
            PRTS_temp2.frc.x -= 10*(1-strength)*Math.cos(dir);
            PRTS_temp2.frc.y += 10*(1-strength)*Math.sin(dir);
          }

          if (PRTS_temp.bFixed != true){
            v.set(PRTS_temp.vel);
            v.mult(0.03f );
            PRTS_temp.frc.sub(v);
            PRTS_temp.frc.x -= -10*(1-strength)*Math.cos(dir);
            PRTS_temp.frc.y += -10*(1-strength)*Math.sin(dir);
          }
        }
      }
    }

j'espere ça t'aidera à y voir plus clair...

+++

Ah ... attends ... je crois comprendre ...
Peut-être c'est l'opération de caste qui te dérange ... ?
La caste c'est quand tu fais ça :

Particule obj2 = (Particule) MyArrayList.get(j);

... tu précises le type de ton objet.

Si c'est le cas, c'est parfaitement normal ...
Un tableau est typé : Type[] tab : un tableau d'éléments de la classe Type
Alors qu'une ArrayList est une liste d'Object ... la classe mère de tous les objets java.
Disons que c'est générique ...
Donc quand tu récupères un élt de ton ArrayList, tu dois préciser quel est son type en le castant.

Si tu utilises une version de java >= 5, tu peux déclarer des ArrayList typées, à savoir :

List<Particule> maListe = new ArrayList<Particule>();

Et ainsi éviter l'opération de caste, ainsi dans ta boucle, tu peux accéder directement à tes attributs :

maListe.get(i).x

Dernière modification par 22_80 (2008-10-29 13:25:34)

Les ArrayList et les tableaux ont le même comportement, je ne pense pas qu'il y ait de pbs à ce niveau-là.
La seule différence dans les deux codes est le numParticules, mais j'imagine qu'il est setté sur le tab.length().

Juste par curiosité ... quel genre de modification du comportement ?

Tes objets particles n'ont pas changé d'une version à l'autre ?
p-e un attribut qui serait passé de float à int ... ce qui fausserait tes calculs ...
Les int sont vraiment traitres.

Bon débuggage en tout cas.

+
+

Dernière modification par 22_80 (2008-10-29 14:19:59)

De rien, oui ... envoie, je regarde ça.

+
+