salut,

je voulais savoir comment comparer deux elements d'une liste de type ArrayList dans processing, donc en Java...
pour calculer une distance entre deux objets par exemple, en utilisant une boucle for.
si quelqu'un à une idée

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)

salut!

merci pour ta réponse concise :D

en fait je souhaiterai comparer les variables de 2 objets contenus dans une ArrayList , en vue de calculer des Springs...
donc avec 2 boucles for, une première pour determiner mon premier objet avec (int i=0 ; i<MyArrayList.size(); i++)  et mon second objet avec (int j=0; j<i; j++).
du coup pour reperer mon premier objet je fais qque chose du type :

obj = (Objet) MyArrayList.get(i);

par contre pour le second j'ai plus de difficultés;
j'ai été contraint de faire ceci :

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

mais le resultat n'est pas probant. alors que dans un tableau il aurai suffit de faire : obj[i] et obj[j] pour comparer des variables des deux instances...
as tu une méthode plus efficace ?
ai je été clair ?:P
+++

oyster_twiter a écrit:

ai je été clair ?:P

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

Yep, journée pépère au taf ... j'essaye de comprendre ... c'est pas vraiment un pb de tri en fait ?
Tu as une liste d'Elts dont tu veux calculer la distance les uns aux autres ?

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

+++

okkkk ... ayé, j'y suis ...

citation :

par contre pour le second j'ai plus de difficultés;
j'ai été contraint de faire ceci :

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

Qu'est-ce qui te dérange dans cette opération ? ça m'a l'air très correct ...

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

En effet j'ai pu voir les possibilité de java >=5 mais je n'y suis pas pour plus longtemps d'ailleurs.
disons que je n'obtiens pas le meme resultat de comportement qu'avec l'ancien code qui est sous forme de tableaux:

     // CALC BOUNCE FORCES
    
     
    vec2d v = new vec2d(0,0);
    vec2d diff = new vec2d(0,0);
     
    // CALC BOUNCE FORCES
    for (int i=0; i < numParticles;i++) {
      for (int j=0; j<i; j++) {

      // calc the vector which represents distance
      diff.set(PRTS_temp[i].pos);
      diff.sub(PRTS_temp[j].pos);
      float distance = diff.length();

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

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

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

les comportements de spring diffèrents lorsque je passe à l'ArrayList, ce qui me mettait un doute sur la bonne syntaxe de mon code.
si ce n'est pas le cas, il y a peu etre des differences dans la façon de traiter l'info en tableau et en ArrayList ...
toujours est il que ce code et celui du post precedent sont sensés faire le meme chose et en fait... non.

...?

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.

+
+

merci pour tes eclaircies...
je vais voir ça
si tu veux je peux t'envoyer les .pde...
mais bon pas de soucis
merci
+++

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

+
+

...
juste pour répondre à ta question (toute à l'heure j'été en hyper vitesse :D), des changements de comportements type : les modelisations de rebonds codés dans la partie" Spring", génère une" étanchéité" des particules ce qui à pour effet de les faire rebondir les unes sur les autres.
Lorsque je passe en ArrayList les particules ont des comportements totalement autres : elles deviennent folles !
elles se grimpent les unes sur les autres ou rebondissent dans le vide, sans contact direct avec une autre particule ...:rolleyes::rolleyes: